java - 策略模式，将函数传递给父方法

Question

我想实现类似策略模式的东西。我在 Parent 方法中有通用逻辑，我需要将特定逻辑(通过转换等)传递给父方法。

我有以下类(class):

class A{
    public Object generateData(Function fetchData, AbstractForm form)
    {
        List<DataBean> dataBeans = (List<DataBean>) fetchData.apply(form);
        //...
    }
}

class B extends A{
    void someMethod(AbstractForm form){
        Function<AbstractForm, List<DataBean>> fetchFunction = new Function<AbstractForm, List<DataBean>>() {
            //here goes form specific casting and other data fetch specific logic
            return dataBeans;
        }
        super.generateData(fetchFunction, form);
    }
}

我在这里是否正确地理解了函数的概念？

Answer 1

正确使用策略模式意味着上下文(在您的案例类中为 A )和策略(在您的案例中为 Function 的实现)之间的聚合。

您可以在下图中看到这种关系(取自四人帮书籍，Design patterns: elements of reusable object-oriented software)。

下面我对您的问题应用了传统的策略模式方法。在这种情况下，我做到了 Function.apply(AbstractForm)返回 List<DataBean>消除类型转换的需要。您当然可以使用泛型来制作 Function更灵活。

策略

public interface Function {
    List<DataBean> apply(AbstractForm form);    
}

上下文

public class A {

    private Function fetchData; // strategy

    public void setStrategy(Function fetchData) { // method for setting the strategy
        this.fetchData = fetchData;
    }

    // precondition: fetchData != null
    public Object generateData(AbstractForm form) {
        List<DataBean> dataBeans = fetchData.apply(form); // using the strategy
        return null; // whatever you want to return
    }    
}

在这种情况下，扩展类 A不是必需的，因为我们可以使用 Function 注入(inject)我们的策略( setStrategy(Function) ) .然而，我们总是可以扩展 A用预定义的策略来伟大的对象。

例如:

public class B extends A {

    public B() {
        setStrategy((form) -> null); // implement your concrete strategy here
    }
}

使用工厂方法

由于可能需要用于获取数据的策略，并且可能没有“默认”可供使用且可能永远不会更改，因此可以使用工厂方法模式来强制创建产品 (Function)。笔记类A现在是抽象的并包含工厂方法 createFunction()然后在子类中实现(例如 B )以创建 Function .

工厂方法模式的设计可以在下面的 UML 中看到。在这种情况下，我们的 Product 现在是以前我们的 Strategy ( Function )，Creator 是类 A , ConcreteCreator 是类 B .

创作者

public abstract class A {

    private Function fetchData; // product to be used

    public class A() {
        fetchData = createFunction(); // call factory method
    }

    protected abstract Function createFunction(); // factory method

    // precondition: fetchData != null
    public Object generateData(AbstractForm form) {
        List<DataBean> dataBeans = fetchData.apply(form); // using the product
        return null; // whatever you want to return
    }

}

具体创作者

public class B extends A {

    @Override
    protected Function createFunction() {
        return (form) -> null; // return product
    }
}

在这种情况下，产品是固定的且不可更改的，但这可以通过将两种模式混合在一起并包括 setStrategy(Function) 来克服。再次下课A在第一个例子中。