设计模式-工厂设计模式

做用：** 负责创建对象，使用户无需考虑对象的创建细节，属于创建型设计模式

测试被用到的类

顶层接口Person类

//顶层接口
public interface Phone {

    //定义的普通方法
    public void printName();

}

小米手机实体类实现了接口Phone

//小米手机实体类实现了接口Phone
public class MiPhone implements Phone {

    @Override
    public void printName() {
        System.out.println("小米手机被创建。。。。");
    }
}

华为手机实体类实现了接口Phone

//华为手机实体类实现了接口Phone
public class HwPhone implements Phone {


    @Override
    public void printName() {
        System.out.println("华为手机被创建。。。");
    }
}

苹果手机实体类实现了接口Phone

//苹果手机实体类实现了接口Phone
public class IPhone implements Phone {

    @Override
    public void printName() {
        System.out.println("苹果手机被创建。。");
    }
}

简单工厂

public class SimpleFactoryPattern {

    private String Mi = "小米";
    private String HW = "华为";
    private String IPhone = "苹果";

    public Phone createPerson(String name){
        if(Mi.equals(name)){
            return new MiPhone();
        }else if (HW.equals(name)){
            return new HwPhone();
        }else if (IPhone.equals(name)){
            return new IPhone();
        }
        //都不满足返回null
        return null;
    }
}

测试

//测试简单工厂

        //创建对象
        SimpleFactoryPattern simpleFactory = new SimpleFactoryPattern();

        //通过对象获取实例
        Phone mi = simpleFactory.createPhone("小米");
        Phone iPhone = simpleFactory.createPhone("苹果");
        Phone HW = simpleFactory.createPhone("华为");

        //调用方法测试
        mi.printName();

        iPhone.printName();

        HW.printName();

//测试结果：

小米手机被创建。。。。
苹果手机被创建。。
华为手机被创建。。。

Process finished with exit code 0

总结：

​ 特点：

​ 在创建对象时，对象的创建过程完全由工厂实现，用户不需要考虑创建细节。

​ 出现问题：

​ 1.当我们想再添加同样的类时，就需要修改工厂内的逻辑，违反了开闭原则，不利于扩展。

​ 2.因为是依据字符串判断，不严谨，容易出现误差。

方法工厂

顶层的工厂接口（定义工厂的结构）

//最顶层的工厂接口
public interface MethodFactoryPattern {

    public Phone createPhone();

}

苹果手机工厂实现了MethodFactoryPattern工厂

//创建苹果手机的工厂
public class IPhoneFactory implements MethodFactoryPattern{
    @Override
    public Phone createPhone() {
        return new IPhone();
    }
}

小米手机工厂实现了MethodFactoryPattern工厂

//创建小米手机的工厂
public class MiFactory implements MethodFactoryPattern{
    @Override
    public Phone createPhone() {
        return new MiPhone();
    }
}

测试

 //测试方法工厂

        //获取苹果手机工厂
        MethodFactoryPattern iPhoneFactory = new IPhoneFactory();

        //苹果手机工厂创建苹果手机
        Phone iPhone = iPhoneFactory.createPhone();

        iPhone.printName();


        //获取小米手机工厂
        MethodFactoryPattern miFactory = new MiFactory();
        //小米手机工厂创建小米手机
        Phone miPhone = miFactory.createPhone();

        miPhone.printName();

//测试结果
苹果手机被创建。。
小米手机被创建。。。。

Process finished with exit code 0

总结：

​ 特点：方法工厂模式中对工厂也定义了抽象，再添加新的产品时，已经不需要去修改工厂，而是直 接添加相应的工厂，再去添加产品。遵守了开闭原则，有利于程序的扩展。

​ 问题：类结构体系相对复杂，比较难以理解。

测试抽象工厂添加一套电脑产品测试类

电脑产品的顶层抽象

//电脑产品的顶层抽象
public interface Computer {

    public void printName();

}

小米电脑实体类实现了Computer接口

//小米电脑实体类实现了Computer接口
public class MiComputer implements Computer{

    @Override
    public void printName() {
        System.out.println("小米电脑。。。");
    }
}

苹果电脑实体类实现了Computer接口

//苹果电脑实体类实现了Computer接口
public class AppleComputer implements Computer{
    @Override
    public void printName() {
        System.out.println("苹果电脑创建。。。");
    }
}

华为电脑实体类实现了Computer接口

//华为电脑实体类实现了Computer接口
public class HWComputer implements Computer {

        @Override
        public void printName() {
            System.out.println("小米电脑。。。");
        }

}

抽象工厂

抽象工厂的顶层接口

public interface AbstractFactory {

    //创建手机
    public Phone createPhone();

    //创建电脑
    public Computer createComputer();

}

苹果工厂实现了AbstractFactory

//苹果工厂实现了AbstractFactory
public class AppleFactory implements AbstractFactory{
    @Override
    public Phone createPhone() {
        return new IPhone();
    }

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

小米工厂实现了AbstractFactory

//小米公司实现了AbstractFactory
public class MiFactory implements AbstractFactory{
    @Override
    public Phone createPhone() {
        return new MiPhone();
    }

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

华为公司实现了AbstractFactory

//华为公司实现了AbstractFactory
public class HWFactory implements AbstractFactory{
    @Override
    public Phone createPhone() {
        return new HwPhone();
    }

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

测试

//测试抽象工厂


    //如果想买苹果手机

        //获取苹果公司
        AbstractFactory appleFactory = new AppleFactory();
        //苹果公司生产苹果手机
        Phone iPhone = appleFactory.createPhone();

        iPhone.printName();

    //如果想小米电脑
        
        //获取小米公司
        AbstractFactory miFactory = new MiFactory();

        //小米公司生产小米电脑
        Computer miComputer = miFactory.createComputer();

        miComputer.printName();

//测试结果
苹果手机被创建。。
小米电脑。。。

Process finished with exit code 0

总结

​ 特点：

​ 将一整个品牌交由工厂管理，使产品的创建隔离。

​ 当添加一整套产品组（比如联想公司的加入），不需要修改原有代码。实现接口即可。

​

​ 出现的问题：

​ 如果当苹果公司加入新产品，比如平板电脑，就回影响整个体系结构，不利于单个产品的更改

​ 抽象工厂模式只适用于一整套产品组的增加，不适用于单个产品的维护

最后总结

简单工厂：

​ 不能算是真正意义上的设计模式，但可以将客户程序从具体类解耦，适合类大量重复的创建。

工厂方法：

​ 使用继承，把对象的创建委托给子类，由子类来实现创建方法，适用于产品数量不稳定。

抽象工厂：

​ 可以说是将整个产品组看做成一个产品，适用于群体类型结构。

工厂模式可以帮助我们针对抽象/接口编程，而不是针对具体类编程，在不同的场景下按具体情况来使用