0

所以，我研究设计模式，我研究模板方法。

根据我的理解，它是一组方法（骨架），包装在抽象类的方法（操作）中（如果通过遗产完成），不同的具体子类在其中编写自己的这些方法的实现（不是全部） ）。

但是我有一个疑问，如果某个具体的实体没有使用骨架的某些，也许是 2 种方法会发生什么？，这里我有一个我做的例子，这完全违反了 SRP：

using System;

namespace TemplatePattern
{
    public abstract class Coffee
    {

        public void MakeCoffee()
        {
            HeatWater();

            PutCoffee();

            if (HaveMilk())
            {
                PutMilk();
            }

            if (HaveGratedChocolate())
            {
                PutGratedChocolate();
            }

            PutSweetener();

            ServeCoffee();
        }

        internal void HeatWater()
        {
            Console.WriteLine($"I heated the water");
        }

        internal void ServeCoffee()
        {
            Console.WriteLine($"Coffee Served");
        }

        internal void PutCoffee()
        {
            Console.WriteLine("I put 2 spoons of Coffee");
        }

        internal virtual void PutMilk() { }

        internal virtual void PutGratedChocolate() { }

        internal abstract void PutSweetener();

        public virtual bool HaveMilk()
        {
            return false;
        }

        public virtual bool HaveGratedChocolate()
        {
            return false;
        }
    }
}

具体类 SimpleCoffeeWithMilk：

using System;
namespace TemplatePattern
{
    public class SimpleCoffeWithMilk : Coffee
    {

        public override bool HaveMilk()
        {
            return true;
        }

        internal override void PutSweetener()
        {
            Console.WriteLine($"I put 1 spoon of Sugar");
        }

        internal override void PutMilk()
        {
            Console.WriteLine($"I put 100Cc of Milk");
        }
    }
}

另一个具体类：

using System;

namespace TemplatePattern
{
    public class CoffeeWithChocolate : Coffee
    {
        public override bool HaveGratedChocolate()
        {
            return true;
        }

        internal override void PutGratedChocolate()
        {
            Console.WriteLine("Put Chocolate");
        }

        internal override void PutSweetener()
        {
            Console.WriteLine($"Put Sugar");
        }

    }
}

主要入口点：

using System;

namespace TemplatePattern
{
    class Program
    {
        static void Main(string[] args)
        {
            SimpleCoffeWithMilk coffeWithMilk = new SimpleCoffeWithMilk();
            CoffeeWithChocolate coffeeWithChocolate = new CoffeeWithChocolate();

            coffeWithMilk.MakeCoffee();

            Console.WriteLine("\n\n");

            coffeeWithChocolate.MakeCoffee();

            Console.ReadLine();

        }
    }
}

这个想法是摆脱那些 If 的语句，有没有办法用模板方法做到这一点，其中一些方法根据具体类执行？

我正在考虑创建接口，例如在其上ICoffeeWithMilk使用PutMilk()方法并在我的SimpleCoffeeWithMilk具体类上实现该接口，但是看着 UML，我看到的模板方法不依赖于接口。

编辑：现在想起来，我不能用接口作为，模板方法在操作中涉及到一组有序的方法，所以这些方法是在操作之外的。

编辑 2：好的，我在想那PutMilk()是PutGratedChocolate()Hook 方法，也许我可以使它们成为抽象方法，并且在具体类中不要放置任何实现，甚至是未实现的异常类。有了这个，它们可以在我的模板方法中没有任何 if 语句的情况下存在。但我认为，我不确定这是否违反了 Liskov 替换原则。

编辑 3：嗯......我又在想，得出的结论是，如果这些方法是虚拟的并且在抽象类上没有实现，我不应该担心问具体类是否使用该方法，然后你写算法，如果你不使用它，那就不要，它什么也不做，它会进入下一步。

4

2 回答 2

1

只需删除if语句并让具体通过执行它们来做出决定，如下所示：

public abstract class Coffee
{
    public void MakeCoffee()
    {
        PutMilk();
    }

    protected abstract void PutMilk();
}

public class SimpleCoffeWithMilk : Coffee
{    
    public override void PutMilk()
    {
        Console.WriteLine($"I put 100Cc of Milk");
    }
}

public class SimpleCoffeNoMilk : Coffee
{    
    public override void PutMilk()
    {
        //no op
    }
}

至于您对这个解决方案的关注，我认为它不违反 Liskov。LSP 声明子类型必须可以替代它的基类的任何其他继承者，这些情况就是这样。您可以调用PutMilk其中任何一个，他们将把所有适合他们专业化接口的牛奶放在一起。这些变化都不会影响调用方法。需要明确的是，您可以设计一个可以做到这一点的示例，但在这种情况下，您不会在那里遇到问题。

于 2018-07-10T04:16:33.943 回答
0

您可以将选择语句（在这种情况下为 if 语句）传输到您的模板，但如果您需要检查某些条件，则无法摆脱它们。天气你这样做

public abstract class Coffee
{
    public abstract bool HaveMilk();

    public void MakeCoffee()
    {
        if (HaveMilk())
        {
            PutMilk();
        }
    }
}

public class SimpleCoffeWithMilk : Coffee
{
    public bool HaveMilk()
    {
        return true;
    }

    public override void PutMilk()
    {
        Console.WriteLine($"I put 100Cc of Milk");
    }
}

或者像这样

public abstract class Coffee
{
    public void MakeCoffee()
    {
        PutMilk();
    }
}

public class SimpleCoffeWithMilk : Coffee
{
    public bool HaveMilk()
    {
        return true;
    }

    public override void PutMilk()
    {
        if (HaveMilk())
        {
            Console.WriteLine($"I put 100Cc of Milk");
        }
    }
}

我坚信后者是您正在寻找的。

于 2018-06-27T08:34:02.210 回答