Strange infinite loop in java method overriding

While trying out different permutations and combinations of method overriding, I encountered a strange infinite loop. While calling an overridden method of the superclass from a mutator method in the superclass, the program goes into an infinite loop. The code which I used is as follows:

class A {
    private int x = 10;
     public void show() {
         System.out.println("Inside A's show showing private X: " + x);
     }
     
    public void change(int num) {
        this.x = num;
        // show(); Line 1
        this.show();  // Line 2
        // Line 1 and Line 2 on using interchangeably still yields the same infinite loop.
    }
}

class B extends A {
     public void show() {
        System.out.println("Inside B's show cant show private X:");
        // change(8);           Line 3
        super.change(8);    //  Line 4
        // Line 3 and Line 4 on using interchangeably still yields the same infinite loop.
     }
}

public class Main
{
	public static void main(String[] args) {
		B b = new B();
		b.show();
	}
}

The output is:

Inside B's show cant show private X:
Inside B's show cant show private X:
Inside B's show cant show private X:
Inside B's show cant show private X:
Inside B's show cant show private X:
Inside B's show cant show private X:
Inside B's show cant show private X:
... lots of times and then 

at A.change(Main.java:9)
at B.show(Main.java:17)
at A.change(Main.java:9)
at B.show(Main.java:17)
at A.change(Main.java:9)
at B.show(Main.java:17)
at A.change(Main.java:9)
at B.show(Main.java:17)
at A.change(Main.java:9)
at B.show(Main.java:17)
... lots of times

What is causing this program to go into this infinite loop and how can it be avoided?

In your A class, you call: this.show(), and as this means 'this object', that will call 'this object's show() implementation', and given that 'this object' is in fact an instance of B, the 'implementation of show()' is the one defined in B.java, thus causing the infinite loop. Note that show(); is just syntax sugar for this.show(); - no wonder then that both lines would do the same thing - both lines mean the same thing.

It sounds like your intent is not to call this object's implementation of the show() method, but: the show() method defined in this very file.

You cannot do that in java.

There is nothing you can write (not this, and not super, and nothing else either) to say: I want this explicit implementation.

You can work around this, of course:

public class A {
    public void show() {
        showImpl();
    }

    private static void showImpl() {
        // this method is static.
        // that means it has opted out, entirely, of inheritance.
        System.out.println("Inside A's show showing private X: " + x);
    }

    public void change(int num) {
        this.x = num;
        showImpl();
    }
}

Now you've fixed the problem. That call to showImpl will go to that exact implementation of showImpl in the same file, guaranteed, every time, because static methods don't 'do' dynamic lookup of the method.