2

我有一个关于设计模式的问题。

假设我想设计杀猪厂

所以方法将是

1）抓猪

2）干净的猪

3）杀猪

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

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

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

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

但我不能有抽象类的实例，所以我很困惑如何实现它。请记住，我必须对卡车上的所有猪执行此过程。

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

4

3 回答 3

3

我会建议一种与之前在这里建议的方法不同的方法。

我会做这样的事情：

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->clean->kill 的顺序执行。抽象方法受到保护，因为它们是 public 的内部实现executeKillPig。

于 2013-04-18T14:13:38.067 回答
1

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

代码要点：

  1. abstract强调 IS A 关系的基类
  2. 模板模式以确保步骤的顺序正确
  3. 策略模式——一个abstract类和一个Interface（大写的“I”）一样是一个接口（小“i”）。
  4. 扩展基础而不使用接口。
  5. 没有具体类的耦合。耦合不是abstractvs的问题，interface而是好的设计。
    公共抽象动物{
        公共抽象 bool Escape(){}
        公共抽象字符串 SaySomething(){}
    }

    公共 Wabbit : 动物 {
        public override bool Escape() {//wabbit 疯狂跳跃 }
        public override string SaySomething() { return @"What's Up Doc?"; }
    }


    公共抽象类杀手{
        受保护的动物食品；
        受保护的抽象 void Catch(){}
        受保护的抽象 void Kill(){}
        受保护的抽象 void Clean(){}

        受保护的抽象字符串 Lure(){}

        // 这个方法定义了流程：方法和顺序
        // 那些调用。具体如何执行每个单独的步骤由子类决定。
        // 即使你定义了一个“PigKiller”接口我们也需要这个方法
        // ** 在基类中 ** 以确保所有 Killer 都做对了。
        // 这个方法是子类的模板（模式）。
        受保护的无效FeedTheFamily（动物的东西Tasty）{
            食物=好吃的东西；
            抓住（）;
            杀（）;
            干净的（）;
        }

    }
    公共类 WabbitHunter : 杀手 {
        protected override Catch() { //wabbit 捕捉技术 }
        protected override Kill() { //wabbit 杀戮技术 }
        protected override Clean() { //wabbit 清洁技术 }
        protected override Lure() { return "来吧，你这个傻瓜！"; }

    }

    // 客户端代码 ********************
    公共课 AHuntingWeWillGo {
        杀手猎人；
        动物猎物；

        public AHuntingWeWillGo (Killer aHunter, Animal aAnimal) {
            猎人=猎人；
            猎物=动物；
        }

        公共无效狩猎（）{
            if (!prey.Escape()) 猎人.FeedTheFamily(猎物)
        }
    }


    公共静态无效主要（）{
        // 看，妈！没有耦合。因为我们传入我们的对象
        // 在使用类中新建它们

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

        safari.Hunt();
   }
于 2013-04-18T21:04:24.440 回答
0

您面临的问题是指称为多态性的 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();
}

正如我们在参数中看到的，我们不使用 classAnimalKiller或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 在 method 范围内相同doTheRequiredOperation。不同之处在于我们将一次类型分配给类型，而在第二次我们将类型分配给接口。

结论

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

于 2013-04-15T18:33:08.377 回答