Java 中是否有办法根据 object 的子类调用不同的子方法？

Question

In my project I have a superclass and two subclasses extending from it. There is a method in the superclass that is overriden differently in each subclass. I want to know if it's possible to introduce a method (in another class) that takes object of either subclass as a parameter and calls a method overriden in one of subclasses (depending on to which subclass does the object belong).

public class Superclass{
    public int method(){return 0;}
}
public class Subclass1 extends Superclass{
    public int method(){return 1;}
}
public class Subclass2 extends Superclass{
    public int method(){return 2;}
}
public class CallingClass{
    public static int dependantCall(Superclass parameter){return parameter.method}

I want to be able to do something like

Subclass1 subclassObject = new Subclass1;
System.out.println(CallingClass.dependantCall(subclassObject));

and get output

1

Answer 1

That is what Polymorphism is for. Defining the Superclass as a parameter type will allow you to pass either subclass in.

For example in your other class you can define it like this:

// classes Dog and Cat extend Animal and override makeNoise()
class Owner{

  playWith(Animal a){
    a.makeNoise();
  }

}

Now the Owner can accept owner.makeNoise(cat) and owner.makeNoise(dog)

More reading: https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html

Answer 2

Yes, it is entirely possible. Here's how that method would look like:

public <T extends Superclass> void foo(T subclassObject) {
...
} 

Or:

public void foo(Superclass obj) {
...
}

Note that in the above method, you can pass subclasses' objects as well (they are covariant data types).

Answer 3

This is what Java does by default when you create subclases, so no need to do anything special. Each object carries it's type information at run time, and the method invoked would always be the most specific one for the object. Example:

public class Doer {
  public void doSomething() {
    // Body presence
  };
}

public class Painter extends Doer {
  @Override
  public void doSomething() {
    // Paint here
  }
}

public class Manager extends Doer {
  @Override
  public void doSomething() {
    // Micromanage here
  }
}

// Elsewhere in your code: 
public void busyness(Doer doer) {
   doer.doSomething();
}

A style note: if it is possible, one should prefer using interfaces instead of base classes (base classes those should be used only if you want to share implementation between subclasses). Example with interfaces:

public interface Doer {
  void doSomething();
}

public class JackOfAllTrades implements Does {
  @Override
  public void doSomething() {
     // Do whatever necessary
  }
}

// Client code stays exactly the same as above: 
public void busyness(Doer doer) {
   doer.doSomething();
}

Note that in Java a class can have only one base class but can implement multiple interfaces.

@Override annotations are not strictly required, but they help Java compiler to spot some errors for you (eg if you misprint method name).

In your example it would look like

public class CallingClass {
  public static int dependantCall(Superclass parameter) {
    return parameter.method();
  }
}

Subclass1 subclassObject = new Subclass1();
System.out.println(CallingClass.dependantCall(subclassObject));