首页手记设计模式----工厂设计模式

设计模式----工厂设计模式

标签：

Java

工厂设计模式概念

什么是工厂设计模式

工厂设计模式，理解为用来生产对象的，Java是面向对象编程语言，Java语言中，对象都是需要创建的，对象都是通过关键字new实例化，试想，如果在程序中需要实例化10个对象，遇到需求变更，实例化的对象需要改变，那实例化对象的10处地方都需要修改；这个时候可以设计为工厂模式，如果获取对象不是直接new实例化的，而是通过工厂获取对象，那么，对象有修改的时候，只需要通过修改工厂中的对象，就可以将所有的对象修改，所有得出工厂模式的最大优点是：解耦

工厂设计模式分类

简单工厂（不属于23设计及模式）
工厂方法
抽象工厂

一、简单工厂

概述

简单工厂不属于23种设计模式，更像是对代码结构的一种改造，将实例化对象的代码进行抽取，抽取成工厂的类，在程序代码种需要用到该对象的时候，从工厂种获取即可，如果对该实例有修改，也只需要修改简单工厂中实例化对象即可。

举例

比如现在有一个接口Phone，定义生产手机；这个接口有两个实现类，分别是XiaoMi和HuaWei；如果需求要实例化小米或者华为手机，直接用类进行实例化对象即可；假设现在程序中有100处实例化了小米手机，还有100处实例化了华为手机，维护的时候需要依次去修改；这个时候可以考虑简单工厂的方式，将实例化手机对象的操作交给工厂，只需要告诉工厂需求，就能够得到相应的对象。

图示
代码事例

1）定义Phone接口

public interface Phone {
    //创建手机的方法
    public String getPhone();
}

2）定义华为手机类，实现Phone接口

public class HuaWei implements Phone{
    //重写创建电话的方法
    @Override
    public String getPhone() {
        return "创建一个华为手机对象";
    }
}

3）定义小米手机类，实现Phone接口

public class XiaoMi implements Phone{
    //重写创建手机的方法
    @Override
    public String getPhone() {
        return "创建一个小米手机对象";
    }
}

上面一个Phone接口和两个实现类，关系类图如下：

编写一个简单工厂类，提供创建对象的方法

//定义简单工厂类
public class SimpleFactory {
    //创建手机的方法
    public static Phone createPhone(String type){
        if("小米".equals(type)){
            return new XiaoMi();
        }else if("华为".equals(type)){
            return new HuaWei();
        }else{
            throw new RuntimeException("该工厂不可识别类型-->"+type);
        }
    }

    //测试一下工厂类中创建手机的方法
    public static void main(String[] args) {
        Phone p1 = SimpleFactory.createPhone("小米");
        System.out.println(p1.getPhone());
        Phone p2 = SimpleFactory.createPhone("华为");
        System.out.println(p2.getPhone());
    }
}

总结：在简单工厂中，创建对象的方法中创建对象数量较少，需要创建什么对象只需要传入逻辑参数即可，比如上述代码中的String type一样。

二、工厂方法模式

概述

工厂方法模式指定义一个创建对象的接口，但让是实现了这个接口的类来决定实例化那个类，工厂方法让类的实例化转换到子类中进行；简单理解：定义一个工厂接口，将该接口的实现类都设计成一个工厂，在工厂的实现类中创建对象，这样就减少了简单工厂里面复杂的逻辑判断，用户需要哪个对象，只需要获取对应的工厂，再由工厂获取对象即可。

图示

事例代码

简单工厂案例中用到的Phone接口、HuaWei实现类和XiaoMi实现类在这个案例中继续使用，下面只写从工厂接口开始

1）创建工厂接口，该接口中只定义，不做实现

public interface PhoneFactory {
	//定义创建电话的方法
    public Phone createPhone();
}

2）定义创建华为电话对象的工厂

public class HuaWeiFactory implements PhoneFactory{
    //重写创建电话的方法
    @Override
    public Phone createPhone() {
        return new HuaWei();
    }
}

3）定义创建小米手机对象的工厂

public class XiaoMiFactory implements PhoneFactory{
    //重写创建电话的方法
    @Override
    public Phone createPhone() {
        return new XiaoMi();
    }
}

4）测试上述方法

public class Test {
    public static void main(String[] args) {
        //创建华为手机
        HuaWeiFactory huaWeiFactory = new HuaWeiFactory();
        Phone huaweiPhone = huaWeiFactory.createPhone();
        System.out.println(huaweiPhone.getPhone());

        //创建小米手机
        XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
        Phone xiaomiPhone = xiaoMiFactory.createPhone();
        System.out.println(xiaomiPhone.getPhone());
    }
}

上面工厂接口和工厂接口实现类关系图

三、抽象工厂

概念

抽象工厂是指提供一个创建一系列相关或相互依赖对象的接口，无需指定他们具体的类；和方法工厂做比较，方法工厂要求先有对应类的对象，如果新增类，那么就需要新增工厂类，会导致类爆炸；在抽象工厂中，调用工厂的时候，可能工厂都还没有，需要的时候再去拿到具体的工厂或者补充，可以提升系统的扩展性

图示

事例代码

这里仍然引用简单工厂模式里面的Phone代码，并且按照同样的模式，新增两个Computer接口及实现类和Ipad接口及实现类，比较简单.

1）Phone接口及实现类

//手机接口
public interface Phone {

    //定义获取手机的方法
    public String getPhone();
}

//华为手机实现类
public class HuaWeiPhone implements Phone{
    @Override
    public String getPhone() {
        return "创建华为手机";
    }
}

//小米手机实现类
public class XiaoMiPhone implements Phone{
    @Override
    public String getPhone() {
        return "创建小米手机";
    }
}

2）Computer接口及实现类

//定义电脑接口
public interface Computer {
    //定义获取电脑的方法
    public String getComputer();
}

//华为电脑
public class HuaWeiComputer implements Computer{
    @Override
    public String getComputer() {
        return "创建华为电脑";
    }
}

//创建小米电脑
public class XiaoMiComputer implements Computer{
    @Override
    public String getComputer() {
        return "创建小米电脑";
    }
}

3）Ipad接口及实现类

//平板的接口
public interface Ipad {

    public String getIpad();
}

//华为平板电脑
public class HuaWeiIpad implements Ipad{
    @Override
    public String getIpad() {
        return "创建华为平板电脑";
    }
}

//小米平板电脑
public class XiaoMiIpad implements Ipad{
    @Override
    public String getIpad() {
        return "创建小米平板电脑";
    }
}

4）编写顶层工厂接口

public interface AbstractFactory {
    //定义创建手机的方法
    public Phone createPhone();

    //定义创建电脑的方法
    public Computer createComputer();

    //定义创建平板电脑的方法
    public Ipad createIpad();
}

5）定义华为工厂，实现顶层工厂接口

public class HuaWeiFactory implements AbstractFactory{
    @Override
    public Phone createPhone() {
        return new HuaWeiPhone();
    }

    @Override
    public Computer createComputer() {
        return new HuaWeiComputer();
    }

    @Override
    public Ipad createIpad() {
        return new HuaWeiIpad();
    }
}

6）定义小米工厂，实现顶层工厂接口

public class XiaoMi implements AbstractFactory{
    @Override
    public Phone createPhone() {
        return new XiaoMiPhone();
    }

    @Override
    public Computer createComputer() {
        return new XiaoMiComputer();
    }

    @Override
    public Ipad createIpad() {
        return new XiaoMiIpad();
    }
}

7）测试类

public class Test {
    public static void main(String[] args) {
        //创建华为对象
        HuaWeiFactory huaWeiFactory = new HuaWeiFactory();
        Phone huaweiPhone = huaWeiFactory.createPhone();
        Computer huaweiComputer = huaWeiFactory.createComputer();
        Ipad huaweiIpad = huaWeiFactory.createIpad();
        //打印
        System.out.println(huaweiPhone.getPhone()+":"+
                huaweiComputer.getComputer()+":"+
                huaweiIpad.getIpad());

        //创建小米对象
        XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
        Phone xiaomiPhone = xiaoMiFactory.createPhone();
        Computer xiaomiComputer = xiaoMiFactory.createComputer();
        Ipad xiaomiIpad = xiaoMiFactory.createIpad();
        //打印
        System.out.println(xiaomiPhone.getPhone()+":"+
                xiaomiComputer.getComputer()+":"+
                xiaomiIpad.getIpad());

    }
}