【Android】三种工厂模式简析

简单介绍三种工厂模式：简单工厂模式，工厂方法模式，抽象工厂模式
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吃着包子豆浆的具体工厂，也可以添加骑着自行车吃着三明治牛奶的具体工厂，换不同的子公司去做，就有不同的结果