标签: template-method-pattern

NVI(非虚拟接口)和模板方法模式之间有什么区别？

它们看起来非常相似,而且我已经读到它们基本相同,并且它们与模板在某种程度上更为通用有些微妙的不同.

我在Python中有一些面向对象的代码,其中一些类要扩展以提供缺少的自定义代码位(模板方法模式,但也包含变量),只能由超类使用,而不是由使用它们的客户端代码.

对于这样的抽象是否有任何样式约定(或者是沉闷的,因为它们在超类中的实现会是pass或者引发NonImplemented异常)方法和属性？

我一直在浏览PEP-0008,它只提到将下划线添加到不打算由子类使用的私有成员.

所以我一直在阅读关于Objective-C的模板方法,我试图了解它们的特殊之处.根据我的理解,Base类中的任何方法都可以被覆盖并且可以调用super吗？那么模板方法不仅仅是覆盖基类中的方法吗？

如果我错了,你能解释一下模板方法模式是什么,你能提供一个例子吗？

在许多程序中，存在带有后缀模板的类。例如org.springframework.web.client.RestTemplate，等。

模板作为类名后缀是什么意思？这是否意味着模板方法模式？

你知道原因吗？

祝你有美好的一天。

的模板的方法图案提供的抽象基类具有不可重写方法:该方法中实现了通用算法,并且不应当在子类覆盖.在Java中,模板方法final在抽象基类中声明,在C#中,sealed关键字具有类似的含义,但不能声明未重写的方法sealed.

public abstract class Base
{
    protected abstract AlgorithmStep1();

    protected abstract AlgorithmStep2();

    public sealed void TemplateMethod()   // sealed: compile error
    {
        AlgorithmStep1();
        AlgorithmStep2();
    }
}

我怎么解决这个问题？为什么不能阻止子类覆盖一个方法(在C#中)？

我有一个执行一些工作的util类.显然,它是关闭扩展,所有方法都是静态的.为简单起见,该类看起来像这样:

public final class Util {
    private Util() { }

    public static void doWork() {
        // some work
        int variable = help();
        // some work uses variable
    }

    private static int help() {
        // some helper functionality
    }
}

该类具有doWork执行大量计算的方法.顺便说一句,方法调用helper方法help获取一些结果,其余的代码使用help方法返回的结果.

现在,在客户端代码中我想重用方法的功能doWork,而不是调用help我想调用help2方法.最简单的解决方案就是创建doWork2替换help为的方法help2.

这是非常糟糕的方法,因为每个变化都doWork必须在doWork2两者之间复制.这与Template Method模式非常相似,但由于我们这里没有扩展,我们无法应用它.

我想出的最佳解决方案是为此方法添加参数,但保留所有现有用户doWork:

public static void doWork() {
    doWorkWithParameter(true);
}

public static void …

我相信模板方法模式涉及封装算法中的每一步.

我认为活动的生命周期(onCreate,onResume等)是必须由具体类覆盖的步骤.

这是否意味着Android活动生命周期(活动和片段类)符合模板设计模式,或者是否存在更适合它的不同模式

谢谢

请考虑以下带有模板方法设计模式的代码:

class A {
    public:
        void templateMethod() {
            doSomething();
        }
    private:
        virtual void doSomething() {
            std::cout << “42\n”;
        }
};
class B : public A {
    private:
        void doSomething() override {
            std::cout << “43\n”;
        }
};

int main() {
    // case 1
    A a; // value semantics
    a.templateMethod(); // knows at compile time that A::doSomething() must be called

    // case 2
    B b; // value semantics
    b.templateMethod(); // knows at compile time that B::doSomething() must be called

    // case 3 …

当我想使用模板方法模式时，我经常遇到这种情况，但模板方法需要不同类型的参数，如下所示：

public abstract class AbstractFoo  {

    public void process(TypeA a, TypeB b) {

     //do common processing
        if (b == null) {
          doProcess(a);
        } else if(a == null) {
          doProcess(b);
        }
    }

    public abstract void doProcess(TypeA a);
    public abstract void doProcess(TypeB b);
}

这看起来不太好。提供的参数之一必须为 null，并且所有服务都必须为其他类型实现虚拟 doProcess 方法。有没有更好的模式呢？你如何处理这个问题？我不想使用构造函数，因为这些服务是 spring bean。同样的问题也适用于策略模式。

GOF 谈论“工厂方法”模式的框架。框架需要对象，但对象的实现取决于应用程序，因此创建了创建对象的抽象方法。此外，由于需要返回类型，因此定义了所需对象的接口，它定义了该对象所需的 api。实际对象是由子类（具体应用程序）创建的。这是一种创作模式。

对于模板模式，唯一的变化是封装类不知道某些行为的实现，因此它将其抽象为方法，使用它，但将实现留给子类。这是行为模式。

两者之间唯一的区别是

1. Factory method is creational and Template is behavioural.
2. Factory method abstracts a method to create an object where as template pattern abstracts a method for some policy or algorithm. 

示例代码

 /**factory-method example**/
 public abstract class Application{          
        public void create(){
              View contentView = createContentView();
              Menu menu = contentView.obtainMenu();
              generateMenuItems(menu);
        }
        public abstract View createContentView(); //factory-method
        public void generateMenuItems(Menu menu){
              // some code
        }
 }

  /** Product Specification**/            
 public interface View{
      public abstract Menu obtainMenu(); …