标签: template-method-pattern

我想在javascript中实现模板方法模式.

我有一个带有一些子类的PropertyDecorator:OpenButtonDecorator,SeeButtonDecorator等等.我想在Property decorator中有下一个函数:

var build = function(){
   decorate(); //Abstract in PropertyDecorator, defined in subclasses
   return le.build();
}

我怎样才能使这个场景有效？也许我实现了错误的继承:S(也帮助:))

先感谢您.

这是TemplateMethod Pattern的一个例子吗？

public abstract class Character{

    public final void useWeapon(){
        useBusterSword();
        useMateriaBlade();
        useUltimateWeapon();
    }

    public abstract void useBusterSword();
    public abstract void useMateriaBlade();
    public abstract void useUltimateWeapon();
}

public class Cloud extends Character{

    public void useUltimateWeapon() {
        System.out.println("Change Weapon to Ultima Weapon");
    }


    public void useBusterSword() {

    }


    public void useMateriaBlade() {

    }
}


public class TestGame {
    public static void main(String[] args){
        Character cloud = new Cloud();
        cloud.useWeapon();
    }
}

如果是这样,使用这种模式比战略模式有什么好处？

战略模式

public class Character {
    WeaponBehavior w;
    public void …

嗯,我正在经历这个关于"在MSDN上的优秀文章基类用途 ".虽然我理解基类和接口的概念,但我无法理解本文第二段中的模板方法的用法(" 受保护的方法和构造函数 ").

有没有人可以借助一个简单的实际例子帮助我理解这个概念？或许,理解模板方法的概念是一个很好的起点.

提前致谢.

可能的重复：
在构造函数内调用虚函数

我有一个 Shape 类及其子类 Sphere ：

//Shape : 

class Shape
{
    public:
        Shape(const string& name);
        virtual ~Shape();

        virtual string getName();

    protected:

        string mName;

};

Shape::Shape(const string& name) : mName(name)
{
   /*Some stuff proper to Shape*/

   /*Some stuff proper to subclass (sphere)*/

   /*Some stuff proper to Shape*/
}

Shape::~Shape(){}

string Shape::getName(){ return mName; }


//Sphere :

class Sphere : public Shape
{
    public:
        Sphere(const string& name, const float radius);
        virtual ~Sphere();

        virtual string getRadius();

    protected:

        float mRadius;
}

Sphere::Sphere(const string& …

如何实现模板方法模式的变体，其中具体类不从基类继承，但保持模式的整体特征。它不能继承的原因是它被迫从另一个类继承，并且多重继承不可用。

例如，假设以下 Tempate Method 模式：

public abstract class BaseClass {
    public void Alpha() {
        Beta();
    }

    public abstract void Beta();

    public void Gamma() {
        Delta();
    }

    public abstract void Delta();

}

public ConcreteClass : BaseClass {
    public override void Beta() {
        Gamma();
    }

    public override void Delta() {
        Console.WriteLine("Delta");
    }
}

...
var object = new ConcreteClass();
object.Alpha(); // will outout "Delta"

如何在没有 ConcreteClass 继承 BaseClass 的情况下获得相同的结果？

当我的注意力被这个吸引时，我正在阅读有关设计模式的内容，特别是有关模板方法的内容。

阅读解释和具体代码后，我仍然想知道为什么这是“模板方法”设计模式的示例。

根据 GoF 的说法，这种模式的目的是：

\n

\xe2\x80\x9c 定义操作中算法的骨架，将一些步骤推迟到子类。模板方法允许子类重新定义算法的某些步骤，而不更改算法\xe2\x80\x99s 结构。\xe2\x80\x9d

\n

并且有两个参与者：

\n

AbstractClass：
\n - 定义具体子类定义的抽象基元操作，以实现算法的步骤
\n - 实现定义算法骨架的模板方法。模板方法调用原始操作以及 AbstractClass 或其他对象中定义的操作。
\n 具体类：
\n 实现原始操作以执行算法的子类特定步骤。

\n

为什么“JdbcOperations”中的代码被认为是“模板方法”设计模式？

\n
• 即使我将其与类似文件（如“JmsTemplate”）中的代码进行比较，我也没有看到在超级/抽象类中定义任何“全局/通用”算法。
\n
• 具体类中实现的函数都没有在超类中定义。所有定义的方法都是通过使用接口添加的，在本例中是接口“JdbcOperations”，并且没有一个方法实际上覆盖父级中的方法。
\n

我发现它对于消除 样板代码非常方便非常方便。但为什么这是一个模板方法而不仅仅是一个漂亮的编码技巧。对我来说，它看起来不像模板方法所具有的任何特征。

在Go中实现模板方法模式是否有一种优雅的规范方法？在C++中,它看起来像这样:

#include <iostream>
#include <memory>

class Runner {
public:
    void Start() {
        // some prepare stuff...
        Run();
    }
private:
    virtual void Run() = 0;
};

class Logger : public Runner {
private:
    virtual void Run() override {
        std::cout << "Running..." << std::endl;
    }
};

int main() {
    std::unique_ptr<Runner> l = std::make_unique<Logger>();
    l->Start();
    return 0;
}

在golang我写了这样的东西:

package main

import (
    "fmt"
    "time"
)

type Runner struct {
    doRun func()
    needStop bool
}

func (r *Runner) Start() {
    go r.doRun()
} …

注意：以下问题与模板方法设计模式和C ++函数模板有关。为了区分两者，在引用设计模式时将使用斜体，在引用C ++模板时将使用粗体。

模板方法模式的思想是使算法的各个部分可互换。这通常是通过继承来实现的，子类提供了具体的实现，这些实现被插入到基类的算法中。但是，如果挂钩方法需要为template，则此方法将无法工作，因为模板不能是虚拟的。这是一个不编译的简单示例：

class Base
{
public:

    // This is the template method
    template <typename T>
    void doSomething(T input)
    {
        //...
        auto converted = ConvertInput(input);
        //...
        std::cout << converted;
    }

protected:
    //compile error "member function templates cannot be virtual"
    template <typename T>
    virtual T ConvertInput(T input) = 0;
};

class Derived : public Base
{
protected:
    template <typename T>
    T ConvertInput(T input)
    {
        return 2 * …

据我所知,Template方法只不过是调用子类中定义的虚方法或抽象方法的普通方法.我是对的,或者我想念这个模式还有其他重要的东西吗？

abstract class Foo {
  public void IamTemplateMethod() { // which will be called in child class object
    method1(); // because this...
    method2(); // ...or this method was called in me
  }
  public virtual void method1() { ... } // to be overriden in child class
  public abstract void method2() { ... } // to be defined in child class
}

如果我是对的,有没有其他常用方法来实现Template方法？

什么是可接受的术语(如果有的话),用于描述只能虚拟调用的方法以及基础中的其他方法？我偶尔会看到这被称为回调,但这似乎偏离了该术语的原始定义.我甚至不确定这是一种被称为模式的优点,但我正试图在评论我的代码时变得更加精确.谢谢您的帮助!

// Abstract class.
class A {
public:
  void run() { while (call()) { /* ... */ } }
private:
  virtual bool call() = 0;
};

// Completion/specialization of A.
class B : public A {
private:
  // Standard term to indicate this pattern?
  bool call();
};

摘要:这似乎被称为非虚拟接口模式,这是模板方法模式的一个特例.感谢Nick和Steven的帮助!

在对上一个问题的有用答案之后,我开始使用模板方法模式来创建具有许多不同选项的类.如果没有全部实现它们,那么我对该类对象的当前声明现在看起来像这样:

pc < prg, tc, 9, 0, 4, 4, test, true, true, true, true, false, true, true, 10, 0, -1, 3, 3 > mp;

你如何处理长模板参数列表？我应该使用枚举/定义而不是真/假和数字吗？有常用的替代品吗？

语境

我最近遇到了一个基本的OOP / Ada 2012设计问题。

基本上，我有一个实现接口协定的父类。这是在实现提供程序（ConcreteX）中分几个步骤完成的。子类通过仅覆盖其中一个步骤（DerivedY，Step_2）来扩展此实现。（试图获得一些SOLID属性）

我天真地认为会发生调度。没有。我重新发现调度与Java或其他OOP中的调度不同，并提供了解决方案。

在阿达调度经常问/回答/记录了几个问题：动态调度Ada中，动态调度Ada中，访问类型，阿达T'Class基础

而不是使用：

This.Step_1; This.Step_2;

我最终使用：

T_Concrete_X'Class (This).Step_1; T_Concrete_X'Class (This).Step_2;

题

在Ada OOP类设计中，我在两种选择之间挣扎：

1. 在父类中，定义行为+原语并提供默认实现，即Current_Class'Class(This).method()（=下面提供的工作示例）

2. 使用模板设计模式，以便将执行步骤的实现委派给另一个类

即在给定的示例中：

-- T_Concrete_X does not have a child class (current example)
overriding procedure If_A_Proc_1 (This : in out T_Concrete_X) is
begin
   -- This.template_executor being set with different classes realizing the Step_1/Step_2 contracts(current example)
   This.template_executor.Step_1;
   This.template_executor.Step_2;
end If_A_Proc_1;

1是应避免达到预期行为的语法“技巧”吗？

我总是觉得当我写一个显式的演员表时，那是设计不力的标志。

工作示例：

src / interfacea.ads

package InterfaceA is

   type T_InterfaceA is interface;
   type T_InterfaceA_Class_Access …

Facade 和 Template 方法模式有什么区别？它们都提供子系统的高级视图并对用户隐藏它。

外观图案

 internal class SubsystemA
    {
        internal string A1()
        {
            return "Subsystem A, Method A1\n";
        }
        internal string A2()
        {
            return "Subsystem A, Method A2\n";
        }
    }
    internal class SubsystemB
    {
        internal string B1()
        {
            return "Subsystem B, Method B1\n";
        }
    }
    internal class SubsystemC
    {
        internal string C1()
        {
            return "Subsystem C, Method C1\n";
        }
    }

    public static class Facade
    {

        static SubsystemA a = new SubsystemA();
        static SubsystemB b = new SubsystemB();
        static SubsystemC c …