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 回答