Question

因此，我开始学习一本名为“从头开始的设计模式”的书，并在其初始章节中给出了一个场景，其中以鸭类为例，构图比骚扰更可取。

public abstract class Duck
{
   Swim()
       { 
          //all ducks can swim same way
       }
   abstract Look();// ducks can look different
}

因此，上述鸭子类别是由不同类型的鸭子以及某些假橡胶鸭子继承的。

（基于鸭子类型）

      Duck obj=new IndoDuck();
         //Or
     //Duck obj =new MallardDuck();

     obj.Swim();
     obj.Look();

所以直到现在看起来还不错。

现在进行了更改，为鸭子添加了飞行行为。

我们不能只将fly方法行为添加到抽象鸭子类中，因为有一些伪造的鸭子会飞。

因此作者创建了一个IFly接口，该接口将由Flyable类和NonFlyable类实现。

interface IFly
{
 Fly();
}

Flyable: IFly
{
 Fly()
{
  // can fly
}
}

NonFlyable:IFly
{
 Fly()
{
  // cant fly
}
}

因此该IFly接口将不会由所有不同的鸭子类实现，因为这将是一个巨大的变化，以向这些鸭子添加可飞行/不可飞行的行为。因此，在这里用束缚似乎不是一个好主意。

作者建议IFly接口将在Duck类中用作组合。

public abstract class Duck
{
   Swim()
       { 
          //all ducks can swim same way
       }
   abstract Look();// ducks can look different

IFly Fly();
}

所以现在我能做的。

      Duck obj=new IndoDuck();
         //Or
     //Duck obj =new MallardDuck();

     obj.Swim();
     obj.Look();
obj.Fly =new Flyable();
//or
obj.Fly=new NonFlyable();

所以我的问题是我如何根据类型知道是要添加Flyable功能还是将NonFlyable设置为某个地方，我必须告诉我的每个鸭子类它们飞行还是不正确？那么，构图如何真正解决我无法联系或错过的问题呢？请帮忙。

Answer 1

所以我的问题是我如何根据类型知道是要添加Flyable功能还是将NonFlyable设置为某个地方，我必须告诉我的每个鸭子类它们飞还是不飞

决定使用哪个IFly子类来创建鸭子的代码通常位于Factory类中。这样的 Factory 类的简单，简单的实现看起来像：

public class DuckFactory {
    public static Duck createDuck(DuckType type) {
         if(DuckType.FlyableMallard.equals(type)) {
              return new MallardDuck();
         } else if(DuckType.Mallard.equals(type)) {
              return new MallardDuck(new NonFlyable());
         }
    }
}

请注意，Duck子类应该具有一个接受Flyable参数的构造函数，而不是使用obj.Fly = Flyable进行设置。为此，您可以将这些构造函数添加到Duck类本身中：

 public abstract class Duck {
       protected IFly flyBehavior;
       public AbstractDuck(IFly flyBehavior) {
            this.flyBehavior = flyBehavior;
       }

       public AbstractDuck() {
            //all ducks can fly by default
            this.flyBehavior = new Flyable();
       }

       protected abstract void look();
       //other methods
 }

然后，每个鸭子子类都可以从extend AbstractDuck继承并自动继承构造函数。然后，一个简单的主程序可以通过简单地传递从命令行接收的类型来创建Duck实例：

DuckType duckType = [duck type recieved as program input]
Duck duck  = DuckFactory.create(duckType);

那么构图如何真正解决问题

从上面的示例可以清楚地看出，通过组合，您可以使用单个名为MallardDuck的类并添加Flyable或NonFlyable行为，而不必强制执行该行为为Duck子类覆盖。

通过继承进行组合（进入设计模式）

1 个答案: