96             {
  97                 // s%_%i%
  98                 bytes[i+1] = 'i';
  99                 bytes[i+5] = 'i';
 100                 break;
 101             }
 102         }
 103         Files.write(p, bytes);
 104     }
 105 
 106     static class Base {
 107         protected int value;
 108         Base(int v) {
 109             this.value = v;
 110         }
 111         int called() {
 112             finalizedSum.addAndGet(value);
 113             return value;
 114         }
 115         protected void finalize() {
 116             System.out.println("Base.finalize() sum += " + called());
 117             finalizedCount.incrementAndGet();
 118         }
 119     }
 120     static class PublicFinalize extends Base {
 121         PublicFinalize(int v) {
 122             super(v);
 123         }
 124         public void finalize() {
 125             finalizedSum.addAndGet(value * 100);
 126             System.out.println("PublicFinalize.finalize() sum += " + called() +
 127                 "+"+value+"*100");
 128             finalizedCount.incrementAndGet();
 129         }
 130     }
 131     static class Subclass extends Base {
 132         Subclass(int v) {
 133             super(v);
 134         }
 135         protected void finalize() {
 136             // no value added to sum
 137             System.out.println("Subclass.finalize() sum += 0");
 138             finalizedCount.incrementAndGet();
 139         }
 140     }
 141     static class SubSubclass extends Subclass {
 142         SubSubclass(int v) {
 143             super(v);
 144         }
 145         protected final void finalize() {
 146             finalizedSum.addAndGet(value);
 147             System.out.println("SubSubclass.finalize() sum +=" +value);
 148             finalizedCount.incrementAndGet();
 149         }
 150     }
 151     static class PrivateFinalize extends Base {
 152         PrivateFinalize(int v) {
 153             super(v);
 154         }
 155         private void f_nal_ze() {
 156             // finalization catches any exception
 157             System.out.println("Error: private finalize invoked!!");
 158             privateFinalizeInvoked = true;
 159             finalizedCount.incrementAndGet();
 160         }
 161     }
 162     static class NoOverride extends PrivateFinalize {
 163         NoOverride(int v) {
 164             super(v);
 165         }
 166     }
 167 }

  96             {
  97                 // s%_%i%
  98                 bytes[i+1] = 'i';
  99                 bytes[i+5] = 'i';
 100                 break;
 101             }
 102         }
 103         Files.write(p, bytes);
 104     }
 105 
 106     static class Base {
 107         protected int value;
 108         Base(int v) {
 109             this.value = v;
 110         }
 111         int called() {
 112             finalizedSum.addAndGet(value);
 113             return value;
 114         }
 115         protected void finalize() {
 116             called();
 117             finalizedCount.incrementAndGet();
 118         }
 119     }
 120     static class PublicFinalize extends Base {
 121         PublicFinalize(int v) {
 122             super(v);
 123         }
 124         public void finalize() {
 125             finalizedSum.addAndGet(value * 100);
 126             called();

 127             finalizedCount.incrementAndGet();
 128         }
 129     }
 130     static class Subclass extends Base {
 131         Subclass(int v) {
 132             super(v);
 133         }
 134         protected void finalize() {
 135             // no value added to sum

 136             finalizedCount.incrementAndGet();
 137         }
 138     }
 139     static class SubSubclass extends Subclass {
 140         SubSubclass(int v) {
 141             super(v);
 142         }
 143         protected final void finalize() {
 144             finalizedSum.addAndGet(value);

 145             finalizedCount.incrementAndGet();
 146         }
 147     }
 148     static class PrivateFinalize extends Base {
 149         PrivateFinalize(int v) {
 150             super(v);
 151         }
 152         private void f_nal_ze() {
 153             // finalization catches any exception

 154             privateFinalizeInvoked = true;
 155             finalizedCount.incrementAndGet();
 156         }
 157     }
 158     static class NoOverride extends PrivateFinalize {
 159         NoOverride(int v) {
 160             super(v);
 161         }
 162     }
 163 }