• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

无废话设计模式(1)–简单工厂、工厂方法、抽象工厂

开发技术 开发技术 1周前 (07-31) 14次浏览

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-一句话总结

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

喜欢 (0)