创建接口参考并将其分配给实现对象认为是一个干净的设计决策

Question

I have a base class called Tiger

class Tiger implements Attack{
@Override
public void pounce(int intensity){
}
@Override
public void threatLevel(int level){
}

}

Attack interface:

Interface Attack{
void pounce(int intensity);
void threatLevel(int level);
 }

Another subclass SiberianTiger

class SiberianTiger extends Tiger{
public void setupSiberianTiger(int intensity,int level){
  pounce(intenisty);
  threatlevel(level);
}

}

public static void main(){
Attack attack =new SiberianTiger();
//setup the Siberian Tiger meow >.<
((SiberianTiger)attack).setupSiberianTiger(4,5);
}

So my question is it a good design decision to initialize the SiberianTiger instance the way I am doing. How can I improve upon it.
((SiberianTiger)attack).setupSiberianTiger(4,5);

Answer 1

You should declare your variables with the type you know you will use the fields and methods available. In this case, there's no benefit in declaring this:

Attack attack = new SiberianTiger();
((SiberianTiger)attack).setupSiberianTiger(4,5);

It is better to declare the variable as SiberianTiger :

SiberianTiger siberianTiger = new SiberianTiger();
siberianTiger.setupSiberianTiger(4,5);

The benefit of using super class or interface cannot be seen in this small piece of code. For instance, you can see it if you have a collection of Attack s:

List<Attack> attackList = new ArrayList<>();

SiberianTiger siberianTiger = new SiberianTiger();
siberianTiger.setupSiberianTiger(4,5);
attackList.add(siberianTiger);

for (Attack attack : attackList) {
    attack.<doSomething>();
}

Of course, there are other ways to improve this design like creating a proper constructor for SiberianTiger where you pass the variables, apply Factory Pattern or Builder, etc.

Answer 2

I would write a factory class and avoid the casting.

Clients should deal with Attack references, not concrete subtypes.

I agree with the comment about the interface name: good names matter. I'd prefer Attacker .

public class AttackerFactory {
    private static final AttackerFactory instance = new AttackerFactory();

    private AttackerFactory() {}

    public static AttackerFactory getInstance() { return instance; }

    public Attack createAttacker(Class<Attack> attackerClass, int intensity, int threatLevel) {
        // Create what you want here
    }
}

Answer 3

No. A design that requires you to cast is not clean. Fortunately for you, there's an easy alternative in this case:

public static void main(){
    SiberianTiger attack = new SiberianTiger();
    //setup the Siberian Tiger meow >.<
    attack.setupSiberianTiger(4,5);
}

More generally, you should always declare the least-specific type that is consistent with your usage requirements . In your case, you want to use an initialization method that is specific to class SiberianTiger , so that's the type you should be declaring.

You can certainly pass that SiberianTiger object to a method that accepts any kind of Attack , or assign it to such a variable, etc.. That's an altogether different matter.