1

As shown below, I tried to cast the object of the sub-class to that of its parent class. That went well. But, when I try to access the overridden method of the parent class, it doesn't happen. Instead the overriding method in the child class is called. I know I can do this using the super keyword, but I just want to know why this can't be done by casting?

This is the parent class:

public class Parent {
    public void print() {
        System.out.println("In parent");
    }
}

This is the child class which has its properties inherited from the parent class:

public class Child extends Parent{
    public void print() {
        System.out.println("In child");
    }
}

This is the class which contains the main method:

public class Main {

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

}
  • 2
    Because you are not calling a method on a _class_ but on an _instance_. And the instance you are using is always of type `Child`, regardless to what you cast it. – Seelenvirtuose Feb 02 '21 at 09:01
  • You will need to have another method that calls super. – kks21199 Feb 02 '21 at 09:02
  • Once I cast the `Child` object to a `Parent` object, will it not be a parent object? If not, why? –  Feb 02 '21 at 09:03
  • 1
    "Once I cast the Child object to a Parent object, will it not be a parent object?" No, it will not. How should it become another object? It is still the same object! – Seelenvirtuose Feb 02 '21 at 09:04
  • @S.Tiss Because the `Child` object will always be a `Child` object. You can cast it to `parent` object only because it extends from it. – kks21199 Feb 02 '21 at 09:04

4 Answers4

2

Clarification

In your example, the object is always Child. Casting is applied only to the reference variable. This casting never impacts the actual object.

Options

  1. As mentioned by others, add a separate method that will call super.() or use hiding. Hiding is not actually overriding.

Beware of the side effects of hiding

public class AccessParent {
    public static void main(String[] args) {
        Parent p = new Child();
        p.methodC();
        System.out.println(new String(new char[20]).replace("\0", "-"));
        p.methodD();
    }
}

class Parent {
    void methodA() {
        System.out.println("Parent.methodA");
    }

    private void methodB() {
        System.out.println("Parent.methodB");
        // this will still call Child.methodA
        // a hidden method can not control the scope of overridden method
        methodA();
    }

    void methodC() {
        System.out.println("Parent.methodC");
        methodB();
    }

    void methodD() {
        System.out.println("Parent.methodD");
        // hidden method will be called
        // technically Child.methodB() is not overridden
        methodB();
    }
}

class Child extends Parent {
    @Override
    void methodA() {
        System.out.println("Child.methodA");
    }

    // this not overridden
    void methodB() {
        System.out.println("Child.methodB");
    }
}

This will output

Parent.methodC
Parent.methodB
Child.methodA
--------------------
Parent.methodD
Parent.methodB
Child.methodA```
Thiyanesh
  • 2,360
  • 1
  • 4
  • 11
1

You can't access a overriden method directly from a child class. The best you can do is add another function to your child that calls the parent print function.

public class Child extends Parent{
    public void print() {
        System.out.println("In child");
    }
    
    public void printParent() {
        super.print()
    }
}

Then you can access it like this,

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.printParent();
    }
}
kks21199
  • 1,116
  • 2
  • 10
  • 29
1

Overriding is a principle which gives weightage on inheritance.

If you have a specific requirement to behave as per the casting then the method must be class level "static" instead of instance level.

You would loose the beauty of true inheritance and enter in hiding it more. However, the same can be achieved in casting way

package com.company.language;

public class InheritanceTrial {
    public static void main(String[] args) {
        Child child = new Child();
        child.print();
        ((Parent)child).print();
    }
}
class Parent {
    public static void print() {
        System.out.println("In parent");
    }
}

class Child extends Parent{
    public static void print() {
        System.out.println("In child");
    }
}
Rizwan
  • 2,369
  • 22
  • 27
0

With the help of java.lang.invoke.MethodHandles, java.lang.invoke.MethodHandle and java.lang.invoke.MethodType we can only access the immediate parent's method. So this might help your question.

Working solution

public class Child extends Parent {
  public static void main(String[] args) throws Throwable {
      MethodHandle MH_Parent = MethodHandles.lookup().findSpecial(Parent.class, "print" , MethodType.methodType(void.class), Child.class);
      MH_Parent.invokeExact(new Child());
  }
    public void print() {
        System.out.println("In child");
    }
}

class Parent {
    void print() {
        System.out.println("In parent");
    }
}

Failing Solution

class Parent {
    public void print() {
        System.out.println("In parent");
    }
}

class Child extends Parent{
    public void print() {
        System.out.println("In child");
    }
}

public class Main {
    public static void main(String[] args) throws Throwable {
      MethodHandle MH_Parent = MethodHandles.lookup().findSpecial(Parent.class, "print" , MethodType.methodType(void.class), Child.class);
      MH_Parent.invokeExact(new Child());
    }
}
Annamalai Palanikumar
  • 334
  • 4
  • 19