工厂方法（创建型）

工厂方法（Factory Method）

　　1、定义一个用于创建对象的接口，让子类决定实例化哪一个类。使一个类的实例化延迟到其子类。

　　

　　Client：作为开始节点

　　Game：抽象产品基类，做为具体的产品抽象类，所有同类的产品都继承它

　　Factory：抽象工厂基类，任何产品工厂必须继承

　　xxxGame：具体产品类，继承抽象产品基类，并实现，由工厂创建实例对象。

　　xxxxFactory：具体的工厂类，用于创建产品实例

　　

namespace 工厂方法
{
    class Program
    {
        static void Main(string[] args)
        {
　　　　　　　
            Console.WriteLine("打开LOL");
            //创建工厂   例如：电脑上某加密文件夹下有很多游戏，文件夹可视为一个抽象工厂，具体某游戏的包视为一个生产的工厂
            GameFactory lol = new LOLFactory();
            //找到工厂里的EXE
            Game l= lol.OpenGame();
            //开打游戏开始氪金
            l.Play();
            l.Khorium();
            Console.WriteLine("==================分割线=================");
            Console.WriteLine("打开DNF");
            GameFactory dnf = new DNFFactory();
            Game g = dnf.OpenGame();
            g.Play();
            g.Khorium();
            Console.ReadLine();
        }
    }
    /// <summary>
    /// 抽象工厂类
    /// </summary>
    public abstract class Game
    {
        public abstract void Play();
        public abstract void Khorium();
    }

    public class LOL : Game
    {
        public override void Khorium()
        {
            Console.WriteLine("皮肤不错充钱买个来装B");
        }
        public override void Play()
        {
            Console.WriteLine("开一局嗨起来");
        }
    }
    public class DNF : Game
    {
        public override void Khorium()
        {
            Console.WriteLine("充钱不一定变强，不充钱一定是垃圾");
        }
        public override void Play()
        {
            Console.WriteLine("又是充满希望的一天");
        }
    }
    /// <summary>
    /// 抽象产品
    /// </summary>
    public abstract class GameFactory
    {
        public abstract Game OpenGame();
    }
    public class LOLFactory : GameFactory
    {
        public override Game OpenGame()
        {
            return new LOL();
        }
    }
    public class DNFFactory : GameFactory
    {
        public override Game OpenGame()
        {
            return new DNF();
        }
    }
}

 

　　 使用工厂方法实现的系统，如果系统需要添加新产品时，我们可以利用多态性来完成系统的扩展，对于抽象工厂类和具体工厂中的代码都不需要做任何改动，例如：想玩吃鸡，上面没有，在不改动抽象工厂和抽象产品的情况下，只需要添加具体产品和具体生产工厂对象。

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 工厂方法
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("打开LOL");
            GameFactory lol = new LOLFactory();
            Game l= lol.OpenGame();
            //开打游戏开始氪金
            l.Play();
            l.Khorium();
            Console.WriteLine("==================分割线=================");
            Console.WriteLine("打开DNF");
            GameFactory dnf = new DNFFactory();
            Game g = dnf.OpenGame();
            g.Play();
            g.Khorium();

            Console.WriteLine("==================分割线=================");

            GameFactory pubg = new PUBGFactory();
            Console.WriteLine("开始吃鸡");
            Game game= pubg.OpenGame();
            game.Khorium();
            game.Play();
       

            Console.ReadLine();
        }
    }
    /// <summary>
    /// 抽象工厂类
    /// </summary>
    public abstract class Game
    {
        public abstract void Play();

        public abstract void Khorium();


    }
    public class PUBG : Game
    {
        public override void Khorium()
        {
             Console.WriteLine("首付+月供");
        }

        public override void Play()
        {
            Console.WriteLine("晚上吃鸡");
        }
    }
    public class LOL : Game
    {
        public override void Khorium()
        {
            Console.WriteLine("皮肤不错充钱买个来装B");
        }

        public override void Play()
        {
            Console.WriteLine("开一局嗨起来");
        }
    }
    public class DNF : Game
    {
        public override void Khorium()
        {
            Console.WriteLine("充钱不一定变强，不充钱一定是垃圾");
        }

        public override void Play()
        {
            Console.WriteLine("又是充满希望的一天");
        }
    }
    /// <summary>
    /// 抽象产品
    /// </summary>
    public abstract class GameFactory
    {
        public abstract Game OpenGame();
    }

    public class LOLFactory : GameFactory
    {
        public override Game OpenGame()
        {
            return new LOL();
        }
      
    }
    public class DNFFactory : GameFactory
    {
        public override Game OpenGame()
        {
            return new DNF();
        }
    }

    public class PUBGFactory : GameFactory
    {
        public override Game OpenGame()
        {
            return new PUBG();
        }
    }

}

　　优点:

　　　（1）、 在工厂方法中，用户只需要知道所要产品的具体工厂，无须关系具体的创建过程，甚至不需要具体产品类的类名。

           （2）、在系统增加新的产品时，我们只需要添加一个具体产品类和对应的实现工厂，无需对原工厂进行任何修改，很好地符合了“开闭原则”。

　　缺点：

　　　　（1）、每次增加一个产品时，都需要增加一个具体类和对象实现工厂，是的系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

　　使用场景：

　　　 （1）、一个类不知道它所需要的对象的类。在工厂方法模式中，我们不需要具体产品的类名，我们只需要知道创建它的具体工厂即可。

            （2）、一个类通过其子类来指定创建那个对象。在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。

            （3）、将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定。

　　

转载于:https://www.cnblogs.com/li-lun/p/9047441.html