Java | What will happen when an infinite loop is called to create the objects in the same Reference?

package com.java.gc;

import java.util.List;

import java.util.ArrayList;

class Finalize extends Thread {

     int[] array;

     private int thread;

     public Finalize(int thread) {

           array = new int [1000000];

           this.thread = thread;

     }

     @Override

     public void run() {

           for (int i = 0; i < array.length; i++) {

                array[i] = i;

           }

     }

    

     @Override

     protected void finalize() throws Throwable {

           System.err.println("finalize " + thread);

     }

}

public class TestFinalize {

     public static void main(String[] args) {

           int counter = 0;

          

           List<Finalize> list = new ArrayList<Finalize>();

          

           while(true) {

                Finalize finalize = new Finalize(counter++);

               

                /** Uncomment the below line will lead to

                 * "java.lang.OutOfMemoryError: Java heap space"

                 *

                 *  However, when the line is commented then all

                 *  finalize object are eligible for garbage collection and finalize

                 *  method will be called for each object while garbage collection.

                 */

                //list.add(finalize);

                finalize.start();

           }

     }

}

Output:

When objects are eligible for garbage collection i.e when list.add(finalize) is commented.

finalize 0

finalize 19

finalize 20

finalize 21

finalize 14

finalize 15

finalize 16

finalize 17

finalize 18

finalize 9

Output:

When objects are eligible for garbage collection i.e when list.add(finalize) is uncommented.

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

     at com.java.gc.Finalize.<init>(TestFinalize.java:10)

     at com.java.gc.TestFinalize.main(TestFinalize.java:33)

Java | How do you access a parent class method two levels down?

We don't: it violates encapsulation.

It is fine to say, "No, I don't want my own behavior - I want my parent's behavior" because it's assumed that you'll only do so when it maintains your own state correctly.

However, you can't bypass your parent's behavior - that would stop it from enforcing its own consistency. If the parent class wants to allow you to call the grandparent method directly, it can expose that via a separate method... but that's up to the parent class.

Workaround using flag:

package com.java.oops;

/**

 * Grand Parent Class

 */

class AClass {

     public void method(boolean gpFlag) {

           System.out.println("Class A");

     }

}

/**

 * Parent Class.

 */

class BClass extends AClass {

     public void method(boolean gpFlag) {

           super.method(gpFlag);

           if(gpFlag) {

                return;

           }

           System.out.println("Class B");

     }

}

/**

 * Child Class.

 */

class CClass extends BClass {

     public void method(boolean gpFlag) {

           super.method(gpFlag);

           System.out.println("Class C");

     }

}

public class CallGrandParent {

     public static void main(String[] args) {

           CClass c = new CClass();

           boolean gpFlag = true;

           c.method(gpFlag);

     }

}

Output:

Class A

Class C