某些類的對象可以具有特定的行為，但其他對象則不具有

Question

我該如何設計這種特殊情況。

問題是：

1. 如果我在Bird中實現Swim並將diveNow（）行為添加到“飛得很高”，但由於所有鳥類都無法飛行，因此不需要。

換句話說“有些對象可以做到這一點，有些則不能，兩者都屬於同一個類。

我可以使用策略模式。 怎么樣？ 如果我有一大堆行為[接口]有同樣的問題怎么辦？

另一種情況（如果我在動物中覆蓋flyNow（）但是當然有些動物可以飛行（飛行的MOBULAS，飛行的LEMURS。）

Answer 1

並非所有的鳥都能飛，所以不要在那里實施Fly ：

class Bird {}

但有些鳥可以：

class FlyingBird extends Bird implements Fly {}

鴨子是可以飛行和游泳的鳥類。 兩種可能性（兩者都有相同的效果，鴨子是可以飛行和游泳的鳥）：

class Duck extends Bird implements Fly, Swim {}
class Duck extends FlyingBird implements Swim {}

企鵝是可以游泳但不會飛的鳥類：

class Penguin extends Bird implements Swim {}

鴕鳥既不會飛也不會游泳（AFAIK）：

class Ostrich extends Bird {}

Answer 2

我不知道策略模式在這里是否有用，但它似乎是一個匿名類，你可以在其中實現flyNow()和diveNow() ：

Bird divingCapableBird = new Bird() {
    void flyNow() {

    }

    void diveNow() {

    }
};

這種方法的問題是像divingCapableBird instanceof Swim這樣的語句會返回false ，因為divingCapableBird的類型沒有實現Swim接口。

為了解決這個問題，你可以實現一個實現Swim並extends Bird的類，並公開這兩個方法：

class DivingCapableBird extends Bird implements Swim {
    //methods here
}

然而，這個結構也存在另一個問題 - 現在事實證明DivingCapableBird不是Animal 。

這里所有邪惡的根源是Animal不應該同時實現Swim和Fly接口。

Animal應該是頂級（ abstract ）類，而接口應該由Animal特定子類實現。

所以，你應該擁有的是：

interface Swim {
    void diveNow();
}

interface Fly {
    void flyNow();
}

abstract class Animal {
   //some common animal features go here
}

class Bird implements Fly {
    //implement methods
}

class DivingCapableBird extends Bird implement Swim {
    //implement methods
}

Answer 3

只是將動物及其行為分開：

interface Animal {}

class Bird implements Animal {}

abstract class AbstractBehavior {
   protected final Animal animal;
   Behavior(Animal animal) {
      this.animal = animal;
   }
}

class SwimImpl extends AbstractBehavior implements Swim {
   SwimImpl(Animal animal) {
      super(animal);
   }
   void swim() { System.out.println(animal + " is swimming."); }
}

class FlyImpl implements Fly {
   FlyImpl(Animal animal) {
      super(animal);
   }
   void fly() { System.out.println(animal + " is flying."); }
}

然后以你喜歡的方式組成它們：

class SwimFly implements Swim, Fly {
   private Swim swim;
   private Fly fly;

   SwimFly(Animal animal) {
      this.swim = new SwimImpl(animal);
      this.fly= new FlyImpl(animal);
   }

   void swim() { swim.swim(); }
   void fly() { fly.fly(); }
}

Bird duck = new Bird();
SwimFly duckBehavior = new SwimFly(duck);
duckBehavior.swim();
duckBehavior.fly();

Bird penguin = new Bird();
Swim penguinBehavior = new SwimImpl(penguin);
penguinBehavior.swim();

基本上，這是Bridge設計模式，可防止每種可能的動物和行為組合的子類數量激增。

鏈接頁面的一個很好的例子：

Answer 4

你可以去使用一些作文。 如果在適當的類中分離這些行為，即使在同一個類的成員之間也可以自由切換實現。

這也與您的戰略模式有關。 你可以這樣：

public interface Behaviour {

    void act();

}

public class FlightBehaviour implements Behaviour {

    public void act() {
      System.out.println("I am flying");
    }

}

public class FlightlessBehaviour implements Behaviour {

    public void act() {
        System.out.println("I don't feel like flying, although I have wings");
    }

}

然后，您可以在Animal類層次結構中組合任意數量的行為。 對於有多種行為的動物和類似的東西，這可能變得相當復雜，但如果你仔細計划，我想你可能會利用它。