簡單介紹三種工廠模式：簡單工廠模式，工廠方法模式，抽象工廠模式
1.簡單工廠模式
這是一個小工廠，什麼都由自己生產，別人要什麼就呼叫自己的相應工具去生產
具備三個特徵：具體工廠A，具體生產工具B，抽象生產物件C
就是 A呼叫工具B去生產C，工具可以有多種（我成為類B工具），每種生產對應的產品（類C產品，C是所有產品的父介面），下面看程式碼

//抽象產品角色：交通工具車   類C
    public abstract class Car
    {
        public virtual void GoToWork()
        {
        }
    }

    //具體產品角色：自行車  工具B
 

    public class Bike : Car
    {
        public override void GoToWork()
        {
            Console.WriteLine("騎自行車去上班");
        }
    }
    //具體產品角色：公交車  工具B
    public class Bus : Car
    {
        public override void GoToWork()
        {
            Console.WriteLine("做公交車去上班");
        }
    }
    //工廠角色：簡單工廠類  
 

    public class SimpleFactory
    {
        public static Car CreateSimple(string str)
        {
            Car simple = null;
            switch (str)
            {
                case "Bike":
                    simple = new Bike();
                    break;
                case "Bus":
                    simple = new
 
 Bus();
                    break;
                //……
            }
            return simple;

        }
    }


Car car = SimpleFactory.CreateSimple("Bus");
    car.GoToWork();

2.工廠方法模式
就像一個公司做大了，涉及的業務多了，管理就不方便了，這時候往往會成了子公司，讓每一個子公司去負責一塊業務，自己就稱為了管理子公司的母公司，而不涉及具體的業務（抽象） 所以就有四 個角色： 母公司 ->抽象工廠 ，子公司 -> 具體工廠， 產品類 -> 抽象介面， 生產工具類 -> 具體方法

//抽象產品角色：交通工具車
    public abstract class Car
    {
        public virtual void GoToWork()
        {
        }

    }

    //具體產品角色：自行車
    public class Bike : Car
    {
        public override void GoToWork()
        {
            Console.WriteLine("騎自行車去上班");
        }
    }
    //具體產品角色：公交車
    public class Bus : Car
    {
        public override void GoToWork()
        {
            Console.WriteLine("做公交車去上班");
        }
    }

    //抽象工廠角色：工廠介面
    public interface IFactory
    {
        Car ByWhatWay();
    }
    //具體工廠類：自行車類
    public class BikeFactory : IFactory
    {
        public Car ByWhatWay()
        {
            return new Bike();
        }
    }
    //具體工廠類：公交車類
    public class BusFactory : IFactory
    {
        public Car ByWhatWay()
        {
            return new Bus();
        }

    }

 //根據客戶端例項化的工廠決定如何去上班
 IFactory factory = new BusFactory();   //常規寫法
 Car car = factory.ByWhatWay();
 car.GoToWork();

3.抽象工廠模式，這個模式就是前面連個模式的結合，即做大了，成為了母公司，並且子公司也做大了，可以做很多業務。從大局來看，是工廠方法模式，從區域性看，是簡單工廠模式，就這樣，直接看程式碼

//抽象交通工具車
    public abstract class Car
    {
        //名字
        public string CarName{ get; set; }
        public virtual string GoToWork()
        {
            return CarName;
        }

    }
    //抽象早飯類
    public abstract class BreakFast
    {
        //早飯名稱
        public string FoodName { get; set; }

        public virtual string Eat()
        {
            return FoodName;
        }
    }

    //自行車
    public class Bike : Car
    {
        public override string GoToWork()
        {
            CarName = "騎著自行車";
            return CarName;
        }
    }
    //公交車
    public class Suv: Car
    {
        public override string GoToWork()
        {
            CarName = "開著SUV汽車";
            return CarName;
        }
    }

    //高逼格早飯：三明治牛奶
    public class SandWichAndMilk : BreakFast
    {
        public override string Eat()
        {
            FoodName = "三明治和牛奶";
            return FoodName;
        }
    }

    //苦逼早飯：包子豆漿
    public class BaoziAndDoujiang : BreakFast
    {
        public override string Eat()
        {
            FoodName = "包子豆漿";
            return FoodName;
        }
    }

    //抽象工廠類
    public abstract class AbstractFactory
    {
        //建立交通工具方法
        public abstract Car CreatCar();

        //建立早飯方法
        public abstract BreakFast CreateBreakFast();

    }

    //具體工廠類：苦逼程式設計師
    public class LowFactory : AbstractFactory
    {
        public override Car CreatCar()
        {
            return new Bike();
        }

        public override BreakFast CreateBreakFast()
        {
            return new BaoziAndDoujiang();
        }
    }
    //具體工廠類：高逼格程式設計師
    public class HighFactory : AbstractFactory
    {
        public override Car CreatCar()
        {
            return new Suv();
        }

        public override BreakFast CreateBreakFast()
        {
            return new SandWichAndMilk();
        }
    }

    public class CoderLove
    {
        private Car car;
        private BreakFast breakFast;
        public CoderLove (AbstractFactory fac)
        {
            car=fac.CreatCar();
            breakFast=fac.CreateBreakFast();
        }

        public void GetCoderLove()
        {
            Console.WriteLine("早飯吃完"+breakFast.Eat()+","+car.GoToWork()+"去上班");
        }
    }
// 選擇派哪個子公司去做
AbstractFactory factory=new HighFactory();
// 子公司和業務聯絡
 CoderLove coder=new CoderLove(factory);
 // 做事
 coder.GetCoderLove();

抽象工廠模式隔離了具體類的生成，使得客戶並不需要知道什麼被建立。

由於這種隔離，更換一個具體工廠就變得相對容易。所有的具體工廠都實現了抽象工廠中定義的那些公共介面，因此只需改變具體工廠的例項，就可以在某種程度上改變整個軟體系統的行為。

除了以上苦逼程式設計師，高逼格程式設計師，還可以具體新增一個開車SUV吃著包子豆漿的具體工廠，也可以新增騎著自行車吃著三明治牛奶的具體工廠，換不同的子公司去做，就有不同的結果