无废话设计模式（1）--简单工厂、工厂方法、抽象工厂

0-前言

　　简单工厂、工厂方法、抽象工厂都是创建型的设计模式，三个设计模式都是工厂的变种，不复杂，下面我们来快速学习这三种；

1-简单工厂模式

　　太简单，UML图就不画了，直接上代码：

//-----------------1、简单工厂------------
//1-1、生产者父类
class PhoneMaker
{
    public void  getPhone(){}
}
//1-2、具体生产者
class IphoneMaker extends PhoneMaker
{
    @Override
    public void getPhone()
    {
        System.out.println("生产出了苹果手机");
    }
}
class HuaweiMaker extends PhoneMaker
{
    @Override
    public void getPhone()
    {
        System.out.println("生产出了华为手机");
    }
}

//1-3 工厂
class PhoneFactory
{
    public  PhoneMaker makePhone(int phoneType)
    {
        PhoneMaker pm = null;
        switch (phoneType)
        {
            case 1:
                pm=new IphoneMaker();
                break;
            case 2:
                pm=new HuaweiMaker();
                break;
            default :
                    break;

        }
        return pm;
    }
}

客户端：

        //1、简单工厂模式
        PhoneFactory pf=new PhoneFactory();
        PhoneMaker pm = pf.makePhone(1);
        pm.getPhone();

优缺点：

优点
（1）简单工厂包含必要的判断逻辑，简单工厂实现了对象的创建和使用的分离。
（2）客户端无需知道所创建的具体产品类的类名，只需要具体产品类对应的参数即可！
（3）在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性

缺点
（1）工厂类的职责过重，包含逻辑判断语句，它一旦有问题，整个系统都要出问题（2）在添加新的类的时候，简单工厂类就要修改，违反了开放——封闭原则！

2-工厂方法模式

同样，直接上代码：

//----------------2、工厂方法模式---------------------
//生产者接口
interface ITVMaker
{
    void getTV();
}
//工厂接口
interface ITVFactory
{
    ITVMaker getTVMaker();
}

//----------------
//具体生产者
class AppleTVMaker implements ITVMaker
{
    @Override
    public void getTV()
    {
        System.out.println("生产出了苹果电视");
    }
}
class  HuaweiTVMaker implements ITVMaker
{
    @Override
    public void getTV()
    {
        System.out.println("生产出了华为电视");
    }
}
//具体工厂
class AppleTVFactory implements  ITVFactory
{
    @Override
    public ITVMaker getTVMaker()
    {
        return new AppleTVMaker();
    }
}
class HuaweiTVFactory implements ITVFactory
{
    @Override
    public ITVMaker getTVMaker()
    {
        return new HuaweiTVMaker();
    }
}

客户端：

        //2、工厂方法模式
        //如果要苹果电视
        ITVFactory  tvf = new AppleTVFactory();
        ITVMaker tvm = tvf.getTVMaker();
        tvm.getTV();
        //如果要华为电视
        // ITVFactory  tvf = new HuaweiTVFactory();

优缺点：

优点：
（1）工厂方法用来创建客户所需要的产品，同时隐藏了哪种具体产品类将被实例化的细节，用户只需要要关注工厂，不需要关注创建的细节！
(2)在增加修改新的产品的时候不用修改代码，只需要增加对应的工厂就好，完全符合开放——封闭性原则！
（3）创建对象的细节完全封装在具体的工厂内部，而且有了抽象的工厂类，所有的具体工厂都继承了自己的父类！完美的体现了多态性！

缺点：
（1）在增加新的产品时，也必须增加新的工厂类，会带来额外的开销

3-抽象工厂模式

同样，直接上代码：

//--------------------3、抽象工厂模式--------------
//产品接口
class BookMaker //产品1
{
    public void makeBook()
    {}
}
class  PenMaker //产品2
{
    public void makePen()
    {}
}
//工厂接口
interface IstudentFactory
{
    BookMaker CreateBookmaker();
    PenMaker CreatPenkmaker();
}
//------实现具体产品
class MinBookMaker extends BookMaker
{
    @Override
    public void makeBook()
    {
        System.out.println("生产了小学课本");
    }
}
class  MinPenMaker extends PenMaker
{
    @Override
    public void makePen()
    {
        System.out.println("生产了小学生用的笔");
    }
}
//  。。。。。产品1234...
//具体工厂
class  MinStudentFactory implements IstudentFactory
{
    @Override
    public BookMaker CreateBookmaker()
    {
        return  new MinBookMaker();
    }

    @Override
    public PenMaker CreatPenkmaker()
    {
        return  new MinPenMaker();
    }
}
//......工厂1234.....

客户端：

//3、抽象工厂
        IstudentFactory factory = new MinStudentFactory(); //生产小学生的产品系列
        BookMaker bookMaker = factory.CreateBookmaker();
        PenMaker penMaker =factory.CreatPenkmaker();
        bookMaker.makeBook();
        penMaker.makePen();
　　　　　//...生产中学生的系列产品.....
　　　　　// IstudentFactory factory = new MiddleStudentFactory();

//----- 3.1 以下是配合反射的抽象工厂------
        String studentType="Min";
        try
        {
           // Class<?> c =Class.forName(this.getClass().getPackage().getName() + studentType + "StudentFactory");
            Class<?> c =Class.forName("com.anson.designpattern.designPattern.MinStudentFactory");
            IstudentFactory studentFactory = (IstudentFactory)c.newInstance();
            BookMaker bookMaker1 = studentFactory.CreateBookmaker();
            PenMaker penMaker1 =studentFactory.CreatPenkmaker();
            bookMaker1.makeBook();
            penMaker1.makePen();
        }
        catch (Exception e)
        {
            System.out.println(e);
        }

优缺点：

增加一个产品族很简单，而增加一个新的产品就会非常复杂！

4-一句话总结

简单工厂 ： 用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）
工厂方法 ： 用来生产同一等级结构中的固定产品。（支持增加任意产品）
抽象工厂 ： 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）