Question

我对设计模式有疑问。

假设我想设计养猪工厂

所以方法将是

1）抓猪

2）清洁猪

3）杀猪

现在因为这些猪是由卡车司机提供给我的

现在如果想设计一个应用程序我应该如何进行我所做的是

public class killer{  
private Pig pig ;  
public void catchPig(){ //do something };  
public void cleanPig(){ };  
public void killPig(){};  
}

现在iam的事情，因为我知道步骤将以catchPig--->cleanPig---->KillPig方式调用，所以我应该有一个包含这些方法的抽象类和一个调用所有这三种方法的执行方法。

但我不能拥有抽象类的实例，所以我很困惑如何实现它。 remenber我必须为卡车上的所有猪执行这个过程。

所以我的问题是我应该选择哪种设计以及哪种设计模式最能解决这些问题。

Answer 1

我建议采用与之前建议不同的方法。

我会做这样的事情：

public abstract class Killer {
   protected Pig pig;

   protected abstract void catchPig();

   protected abstract void cleanPig();

   protected abstract void killPig();

   public void executeKillPig {
       catchPig();
       cleanPig();
       killPig();
   }
}

每个kill都将扩展Killer类，并且必须实现抽象方法。 executeKillPig()对于每个子类都是相同的，并且将始终按照您希望catch-＆gt; clean-＆gt; kill的顺序执行。抽象方法受到保护，因为它们是公共executeKillPig的内部实现。

Answer 2

这扩展了Avi的答案并解决了评论。

代码点：

abstract基类强调IS A关系
确保步骤顺序正确的模板模式
策略模式 - abstract类与Interface（大写“I”）一样多是一个接口（小“i”）。
扩展基础，不使用界面。
没有混凝土类的耦合。耦合不是abstract vs interface的问题，而是良好的设计。

    public abstract Animal {
        public abstract bool Escape(){}
        public abstract string SaySomething(){}
    }

    public Wabbit : Animal {
        public override bool Escape() {//wabbit hopping frantically }
        public override string SaySomething() { return @"What's Up Doc?"; }
    }


    public abstract class Killer {
        protected Animal food;
        protected abstract void Catch(){}
        protected abstract void Kill(){}
        protected abstract void Clean(){}

        protected abstract string Lure(){}

        // this method defines the process: the methods and the order of
        // those calls. Exactly how to do each individual step is left up to sub classes.
        // Even if you define a "PigKiller" interface we need this method
        // ** in the base class ** to make sure all Killer's do it right. 
        // This method is the template (pattern) for subclasses. 
        protected void FeedTheFamily(Animal somethingTasty) {
            food = somethingTasty;
            Catch();
            Kill();
            Clean();
        }

    }
    public class WabbitHunter : Killer {
        protected override Catch() { //wabbit catching technique }
        protected override Kill() { //wabbit killing technique }
        protected override Clean() { //wabbit cleaning technique }
        protected override Lure() { return "Come here you wascuhwy wabbit!"; }

    }

    // client code ********************
    public class AHuntingWeWillGo {
        Killer hunter;
        Animal prey;

        public AHuntingWeWillGo (Killer aHunter, Animal aAnimal) {
            hunter = aHunter;
            prey = aAnimal;
        }

        public void Hunt() {
            if ( !prey.Escape() ) hunter.FeedTheFamily(prey)
        }
    }


    public static void main () {
        // look, ma! no coupling. Because we pass in our objects vice
        // new them up inside the using classes

        Killer ElmerFudd = new WabbitHunter();
        Animal BugsBunny = new Wabbit();
        AHuntingWeWillGo safari = new AHuntingWeWillGo( ElmerFudd, BugsBunny );

        safari.Hunt();
   }

Answer 3

您遇到的问题是指名为polymorphism

的OOP的一部分

而不是抽象类我将使用一个接口，接口和抽象类之间的区别在于接口只有方法描述符，抽象类也可以有实现方法。

public interface InterfaceOfPigKiller {

  void catchPig(); 
  void cleanPig();
  void killPig();
}

在抽象类中，我们实现了三个可用方法中的两个，因为我们假设这些操作对于将继承我们的类的每个未来类型都是通用的。

public abstract class AbstractPigKiller implements InterfaceOfPigKiller{

  private Ping pig; 

  public void catchPig() {
    //the logic of catching pigs. 
  } 

  public void cleanPig() {
   // the logic of pig cleaning. 
  }

}

现在我们将创建两个新类：

AnimalKiller - 负责猪死亡的人。
AnimalSaver - 负责猪释放的人。

public class AnimalKiller extends AbstractPigKiller { 

 public void killPig() {
   // The killing operation
 }

}

public class AnimalSaver extends AbstractPigKiller {

 public void killPing() {
   // The operation that will make pig free
 }

}

我们的结构让我们看看它是如何工作的。

首先执行序列的方法：

public void doTheRequiredOperation(InterfaceOfPigKiller killer) {

   killer.catchPig();
   killer.cleanPig();
   killer.killPig();
}

正如我们在参数中看到的，我们不使用类AnimalKiller或AnimalSever。而不是我们有接口。感谢这个操作，我们可以在任何实现使用过的接口的类上操作。

示例1：

public void test() {

  AnimalKiller aKiller = new AnimalKiller();// We create new instance of class AnimalKiller and assign to variable aKiller with is type of `AnimalKilleraKiller `
  AnimalSaver aSaver = new AnimalSaver(); //

  doTheRequiredOperation(aKiller);
  doTheRequiredOperation(aSaver);


}

示例2：

public void test() {

  InterfaceOfPigKiller aKiller = new AnimalKiller();// We create new instance of class AnimalKiller and assign to variable aKiller with is type of `InterfaceOfPigKiller `
  InterfaceOfPigKiller aSaver = new AnimalSaver(); //

  doTheRequiredOperation(aKiller);
  doTheRequiredOperation(aSaver);


}

代码示例1和2同样在方法doTheRequiredOperation的范围内。不同之处在于我们在类型中分配一次类型，在第二种中我们将类型分配给接口。

结论

我们无法创建抽象类或接口的新对象，但我们可以将对象分配给接口或类类型。

设计模式查询

3 个答案: