Oop 设计模式查询_Oop_Design Patterns

Oop 设计模式查询

oop design-patterns

Oop 设计模式查询,oop,design-patterns,Oop,Design Patterns,我有一个关于设计模式的问题假设我想设计杀猪工厂因此，方法将是 1）抓猪 2）清洁猪 3）杀猪既然这些猪是卡车司机给我的现在，如果我想设计一个应用程序，我应该如何继续我所做的是 public class killer{ private Pig pig ; public void catchPig(){ //do something }; public void cleanPig(){ }; public void killPig(){}; } 现在我很高兴，因

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

假设我想设计杀猪工厂

因此，方法将是

1）抓猪

2）清洁猪

3）杀猪

既然这些猪是卡车司机给我的

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

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

现在我很高兴，因为我知道这些步骤将以

catchPig-->cleanPig-->KillPig

的方式调用，所以我应该有一个包含这些方法的抽象类和一个调用所有这3个方法的execute方法

但我不能有抽象类的实例，所以我不知道如何实现它。请记住，我必须对卡车上的所有清管器执行此过程

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

您所面临的问题是指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. 
  }

}

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

动物贩子——对猪死亡负责的人
AnimalSaver-负责释放猪的人员

因为我们有我们的结构，让我们看看它将如何工作

首先是将执行序列的方法：

public void doTheRequiredOperation(InterfaceOfPigKiller killer) {

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

正如我们在参数中看到的，我们不使用class

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

的范围内相同。不同之处在于，在中，我们将一次类型分配给类型，在第二次中，我们将类型分配给接口

结论

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

您面临的问题是指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. 
  }

}

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

动物贩子——对猪死亡负责的人
AnimalSaver-负责释放猪的人员

因为我们有我们的结构，让我们看看它将如何工作

首先是将执行序列的方法：

public void doTheRequiredOperation(InterfaceOfPigKiller killer) {

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

正如我们在参数中看到的，我们不使用class

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

的范围内相同。不同之处在于，在中，我们将一次类型分配给类型，在第二次中，我们将类型分配给接口

结论

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

我会建议一种不同于之前在此建议的方法

我会这样做：

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

的内部实现。我建议使用一种不同于之前建议的方法

我会这样做：

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

的内部实现。这扩展了Avi的答案并解决了注释问题

守则的要点：

abstract

基类强调的是一种关系

模板模式，以确保步骤顺序正确

策略模式-一个

抽象类就像一个接口（大写“i”）一样，也是一个接口（小“i”）


扩展基础，不要使用接口
没有具体类的耦合。耦合不是抽象
与接口
的问题，而是良好的设计
公共抽象动物{
公共抽象bool Escape（）{}
公共抽象字符串SaySomething（）{}
}
公猫：动物{
public override bool Escape（）{//wabbit疯狂跳跃}
公共重写字符串SaySomething（）{return@“What's Up Doc？”；}
}
公共抽象类杀手{
受保护动物食品；
受保护的抽象void Catch（）{}
受保护的抽象void Kill（）{}
受保护的抽象void Clean（）{}
受保护的抽象字符串Lure（）{}
//该方法定义了过程：方法和顺序
//这些调用。具体如何执行每个单独的步骤由子类决定。