03_工厂方法模式

工厂方法模式是一种创建型设计模式，用于定义一个创建对象的接口，但将实际创建对象的工作延迟到子类中。这样可以使一个类的实例化延迟到其子类中，从而实现解耦和灵活性。

在工厂方法模式中，通常包含以下几个角色：

1. 抽象工厂（Creator）：定义创建对象的接口，通常包含一个抽象的工厂方法，由子类实现具体的对象创建逻辑。
2. 具体工厂（ConcreteCreator）：实现抽象工厂接口，负责创建具体的对象。
3. 抽象产品（Product）：定义工厂方法创建的对象的接口。
4. 具体产品（ConcreteProduct）：实现抽象产品接口，是具体工厂创建的对象。

 

Product

public interface IFruit
    {
        /// <summary>
        /// 水果的数量
        /// </summary>
        double Amount { get; }
        /// <summary>
        /// 种植
        /// </summary>
        /// <param name="amount"></param>
        void Plant(int amount);
        /// <summary>
        /// 生成
        /// </summary>
        /// <param name="days"></param>
        void Grow(int days);
        /// <summary>
        /// 收获
        /// </summary>
        /// <returns></returns>
        double Harvest();
    }

 

ConcreteProduct

苹果

public class Apple : IFruit
    {
        public double Amount { get; private set; }

        public void Grow(int days)
        {
            Amount *= days * 0.85;
        }

        public double Harvest()
        {
            return Amount;
        }

        public void Plant(int amount)
        {
            Amount = amount;
        }
    }

香蕉

 public class Banana : IFruit
    {
        public double Amount { get; private set; }

        public void Grow(int days)
        {
            Amount *= days * 2;
        }

        public double Harvest()
        {
            return Amount;
        }

        public void Plant(int amount)
        {
            Amount = amount;
        }
    }

橘子

public class Orange : IFruit
    {
        public double Amount { get; private set; }

        public void Grow(int days)
        {
            Amount *= days * 1.5;
        }

        public double Harvest()
        {
            return Amount;
        }

        public void Plant(int amount)
        {
            Amount = amount;
        }
    }

 

Creator

public interface IFruitFactory
    {
        IFruit Create();
    }

 

ConcreteCreator

苹果

 public class AppleFactory : IFruitFactory
    {
        public IFruit Create()
        {
            return new Apple();
        }
    }

香蕉

public class BananaFactory : IFruitFactory
    {
        public IFruit Create()
        {
            return new Banana();
        }
    }

橘子

 public class OrangeFactory : IFruitFactory
    {
        public IFruit Create()
        {
            return new Orange();
        }
    }

 

internal class Client
    {
        /*
    优点：

　　　　（1）工厂方法模式就很好的减轻了工厂类的负担，把某一类/某一种"水果"交由一个工厂生产；（对应简单工厂的缺点1）

　　　　（2）增加某一类"水果"并不需要修改工厂类，只需要添加生产这类"水果"的工厂即可，使得工厂类符合开放-封闭原则。

　　缺点：

　　　　（1）相比简单工厂，实现略复杂。

　　　　（2）对于某些可以形成产品族的情况处理比较复杂。我们可以借用抽象工厂来实现。
    */

        public void Start()
        {
            DoStuff(new AppleFactory().Create());
            DoStuff(new BananaFactory().Create());
            DoStuff(new OrangeFactory().Create());
        }

        private void DoStuff(IFruit fruit)
        {
            fruit.Plant(10);
            fruit.Grow(180);
            Console.WriteLine($"{fruit.GetType().Name}收获:{fruit.Harvest()}");
        }
    }

 

调用

static void Main(string[] args)
        {
            new Client().Start();

            Console.ReadKey();
        }