超类的子方法（java）

Question

I have a superclass, let's say BaseClass and two subclasses, let's say SubclassA and SubclassB , they don't have any other relationship between them but their parent class.

At a lot of places in my code I need to call to methods that both the subclasses have but not the parentclass... And I find myself repeating a lot of code which looks like:

if (obj instanceof SubclassA) {
// stuff
} else if (obj instanceof SubclassB) {
// same stuff
}

The first idea should be to put that "stuff" into a method in superclass, but I can't as that superclass is parent to other subclasses that don't have that behavior...

So... is there a way to avoid repeating aaaalll of that code?

Maybe a common superclass for both subclasses that is a subclass itself of superclass?

Answer 1

I would suggest extracting the method as an abstract method in the parent(if the parent is abstract), or just a method that will be overridden in child classes. If this is not possible, or desirable I would suggest adding a common abstract class that extends the parent that has just the method that is common to both subclasses, that will be then extended by the two subclasses.

If adding and changing the parent class might be an issue, you can do the same thing by using an interface that is then implemented by both subclasses and where you need to call your code you will just cast to the given interface and call the needed method.

Something like this:

interface CommonInterface {
   void commonMethod();
}

class SubClassB implements CommonInterface {
    void commonMethod() {
        // implementation
    }
}

class SubClassA implements CommonInterface {
    void commonMethod() {
       // implementation
    }
}

//...
if (obj instanceof CommonInterface) {
   ((CommonInterface)object).stuffCall();
} 

Answer 2

Add the method to the super class.
Make it with an empty body.

In SubClassA override it, implement the logic you need.
In SubClassB override it, implement the logic you need.

Then in your calling code, instead of doing

if (obj instanceof SubclassA) {
    obj.method();
} else if (obj instanceof SubclassB) {
    obj.method();
}

just do this

obj.method();

provided obj is declared as an instance of the parent class.

The empty method body in the super class guarantees you have
no issues with this "but I can't as that super class is parent
to other subclasses that don't have that behavior" .

So the idea is that you will have empty behavior
in the super class and in all the sub classes which
do not explicitly override this method.

Answer 3

What about the following two ways:

1. Declare the target method in super class and provide a default implementation(eg empty method, do nothing) as well. Subclass will override that behavior if needed.
2. Declare the target method in a Interface, and make SubclassA and SubclassB implementation of the interface. The super class and other subclasses don't need to implement the interface.

Answer 4

如果SubClassA和SubClassB具有某些在Subclass C，D，E等中不存在的行为，则只需在父级与A和B之间引入一个中间类。C，D等源自父级，而B源自新类，这包含A和B共享的功能。

Answer 5

Firstly, the concept of polymorphism is to do away with the need to check the type of an object before calling methods on it. So, this should not be necessary in an OO-language.

Secondly, the reason why you might use an abstract parent class over an interface would but because there is some shared functionality between sub-types (subclasses). So, if there is shared, common functionality between SubclassA and SubclassB then leave your superclass intact, otherwise switch it to an interface.

Likewise, and as you suggest yourself, if SubclassA and SubclassB have a common behaviour (but their own implementation) then utilise a separate API (if other sub-types of BaseClass do not also share that behaviour (your #doStuff call).

In this case, I'd introduce interface Stuff containing method #doStuff and have both my SubclassA and SubclassB implement it, each providing it's own implementation. Your clients can then treat your obj instance as a Stuff , irrespective of it's real type and polymorphism will do the rest.

interface Stuff {
    void doStuff();
}

public class SubclassA extends BaseClass implements Stuff {
    // Does it need BaseClass still?
    public doStuff() {
        ...
    } 
}

public class SubclassB extends BaseClass implements Stuff {
    // Does it need BaseClass still?
    public doStuff() {
        ...
    } 
}

// Example client code...
public class MyStuffClient {

    Stuff s = new SubclassA();
    ...
    public void onStuff() {
        s.doStuff();
    } 
}

Decide if you really need the suer class BaseClass .

Answer 6

You can make the method on the superclass protected . For example, you can do this on SuperClass :

package test;
public SuperClass {
   protected void myMethod() {
      ...stuff...
   }
}

exposing on SubclassA

package test;
public SubclassA extends SuperClass {
   public void myMethod() {
      super.myMethod();
   }
}

and hiding on SubclassB (just not override it)

package test;
public SubclassB extends SuperClass {
}

From a different package , protected methods are not visible unless the class override it changing its visibility modifier.

Source: http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html