Parent class has run() and walk(). Parent run() calls walk(). Child Class overrides Parent class. Inside run(), it calls super.run(). Walk() calls super.walk(). In the main class, Parent p = new child(); p.run(). What will be the order of execution?

Question

Accepted Answer

The order of execution will be: parent's run() -> child's run() -> parent's walk()

When p.run() is called, it will first execute the run() method of the parent class
Inside the parent's run() method, it will call the walk() method of the parent class
Since the child class overrides the parent class, the child's run() method will be executed next
Inside the child's run() method, it will call the run() method of the parent class using super.run()
Finally, the walk() method of the parent class will be executed

Accepted Answer

Code : public class Parent {
    public void run() {
        System.out.println("Parent Run");
        walk();
    }

public void walk() {
        System.out.println("Parent Walk");
    }

public static class Child extends Parent {
        @java.lang.Override
        public void run() {
            System.out.println("Child Run");
            super.run();
        }

@java.lang.Override
        public void walk() {
            System.out.println("Child Walk");
            super.walk();
        }
    }

public static void main(String[] args) {
        Parent p = new Child();
        p.run();
    }

}

Answer : Child Run > Parent Run > Child Walk > Parent Walk

Explanation : Child Run calls Parent Run which calls Walk which is actually overridden in Child, so Parent Run calls Child Walk which in turn calls Parent Walk

Accepted Answer

code be like

package logical;

public class Parent {
	void run() {
		System.out.println("Inside Parent's run");
		walk();
	}

void walk() {
		System.out.println("Inside Parent's walk");
	}
}
package logical;

public class Child extends Parent {

@Override
	void run() {
		System.out.println("Inside Child's run");
		super.run();
	}

@Override
	void walk() {
		System.out.println("Inside Child's walk");
		super.walk();
	}

}
package logical;

public class ParentChild {
	public static void main(String[] args) {
		Parent p = new Child();
		p.run();
	}
}

Output -

Inside Child's run
Inside Parent's run
Inside Child's walk
Inside Parent's walk

Accepted Answer

Let's break down the order of execution step by step:

Parent p = new Child();: Here, you are creating an instance of the Child class but assigning it to a reference variable of type Parent. This is allowed in Java due to polymorphism. The actual type of the object is Child, but the reference type is Parent.

p.run();: You are calling the run() method on the p reference, which is of type Parent. Since run() is overridden in the Child class, the overridden version in the Child class will be executed.

Now, let's look at the execution order within the overridden run() method in the Child class:

class Parent {
    void run() {
        walk();
    }

void walk() {
        System.out.println("Parent walking");
    }
}

class Child extends Parent {
    @Override
    void run() {
        super.run(); // Calls Parent's run(), which in turn calls walk()
    }

@Override
    void walk() {
        super.walk(); // Calls Parent's walk()
        System.out.println("Child walking");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Child();
        p.run();
    }
}

Here's the order of execution:

p.run();: Calls the overridden run() method in the Child class.
super.run();: Calls the run() method in the Parent class.
walk();: Calls the overridden walk() method in the Child class.
super.walk();: Calls the walk() method in the Parent class.
System.out.println("Parent walking");: Prints "Parent walking" from the walk() method in the Parent class.
System.out.println("Child walking");: Prints "Child walking" from the overridden walk() method in the Child class.
So, the final output will be:

Parent walking
Child walking

Accepted Answer

Child.run() method is called.
Parent.run() method is called from within Child.run().
Parent.walk() method is called from within Parent.run().

Parent class has run() and walk(). Parent run() calls walk(). Child Class overrides Parent class. Inside run(), it calls super.run(). Walk() calls super.walk(). In the main class, Parent p = new child(); p.run(). What will be the order of execution?

Wissen Technology Java Developer interview questions & answers

Popular interview questions of Java Developer