抽象类，面向对象的设计模式

Question

我有一个所谓的“操作” 抽象类，这个类有一个名为“准备”抽象方法。

public abstract class Operation { 
    public abstract void prepare() throws Exception; 
    public abstract void run() throws Exception; 
    // other stuff here that's not abstract 
    public void printHelloWorld() { 
     System.out.println("Hello World!"); 
    } 

} 

唯一的问题是，一些事情是“操作”（ 一些类，扩展操作）需要的参数准备（一些 需要整型，有的需要字符串，有的需要更复杂的数据类型。 。所以这并不总是一个int）

public class Teleportation extends Operation { 
    @Override 
    public void prepare(int capacityRequired) throws Exception { 
     // do stuff 
    } 
    @Override 
    public void run() throws Exception { 
    } 
} 

我用它来实现这一 以及如何设置什么OOP模式了这个代码？

编辑：

理想情况下，我要准备和运行操作是这样的：

for (Operation operation : operations) { 
    operation.prepare(); 
    operation.run(); 
} 

假设我用这个解决方案：

public class Teleportation extends Operation { 
     private int cReq; 
     public void setCapacityRequired(int cReq) { 
     this.cReq = cReq; 
     } 
     @Override 
     public void prepare() throws Exception { 
       // I can do the preparation stuff 
       // since I have access to cReq here 
     } 
     @Override 
     public void run() throws Exception { 
     } 
    } 

然后 - 我不知道是否是可以避免这种情况：

for (Operation operation : operations) { 
     if (operation.getClass().isInstanceOf(Teleporation.class)) { 
       ((Teleporation)operation).setCapacityRequired(5); 
     } 
     operation.prepare(); 
     operation.run(); 
    } 

Answer 1

我建议有一个额外的构造函数，您可以添加必要的数据该实现需要并将其存储在类实现的字段中。

对于示例：

public class Teleportation extends Operation { 
    private final int capacityRequired; 
    public Teleportation(int capacityRequired) { 
     this.capacityRequired = capacityRequired; 
    } 
    public void prepare() throws Exception { 
    // do stuff using the capacityRequired field... 
    } 
} 

这种方法适用于更复杂的参数，以及。

Answer 2

这里要做的第一件事就是重载抽象类的操作并用你的容量重载。

public class Teleportation extends Operation { 

    public void prepare() throws Exception { 
     prepare(0); 
    } 

    public void prepare(int capacityRequired) throws Exception { 
     //do stuff 
    } 
} 

---

并记住KISS和YAGNI声明，也没有必要使用设计模式，在你的代码的任何地方，只要他们让事情变得更简单。

Answer 3

您也需要扩大抽象类包括两个方法签名或更改签名采取了可变参数的int参数：

public abstract class Operation { 
    public abstract void prepare(int... args) throws Exception; 
} 

Answer 4

您可以使用通用类为您的操作类：

public abstract class Operation<T> 
{ 
    private T operationModel; 

    public Operation(T operationModel) 
    { 
     super(); 
     this.operationModel = operationModel; 
    } 

    public abstract void prepare() throws Exception; 

    public abstract void run() throws Exception; 

    public T getOperationModel() 
    { 
     return operationModel; 
    } 
} 

那么对于具体的类，在适当的参数类型扩展它（你可以为每个操作的具体类）：

public class TeleOperation extends Operation<TeleOperationModel> 
{ 
    public TeleOperation(TeleOperationModel operationModel) 
    { 
     super(operationModel); 
    } 

    @Override 
    public void prepare() throws Exception 
    { 
     TeleOperationModel teleOperationModel = getOperationModel(); 
     //... 

    } 

    @Override 
    public void run() throws Exception 
    { 

    } 
} 

public class TeleOperationModel 
{ 
    private int capacity; 
    .... 
} 

和：

public class MicroOperation extends Operation<MicroOperationModel> 
{ 
    public MicroOperation(MicroOperationModel operationModel) 
    { 
     super(operationModel); 
    } 

    @Override 
    public void prepare() throws Exception 
    { 
     MicroOperationModel microOperationModel = getOperationModel(); 
     //... 
    } 

    @Override 
    public void run() throws Exception 
    { 

    } 
} 

public class MicroOperationModel 
{ 
    private int x; 
    private int y; 
    private int z; 
    .... 
}