设计模式-工厂模式

工厂模式的三种形式

1.简单工厂
2.工厂方法
3.抽象工厂

1.简单工厂(静态工厂)

什么是工厂?
集中生产,对外提供生产产品的地方
简单工厂只需要向工厂传递进来一个类型,就返回一个对象

总结:

1.把创建跟使用分离
   对应客户端来说只是想要使用对象调用方法,不关心对象如何创建
2.便于统一管理方便维护
3.解耦
   创建对象有变动,不会影响对象使用的逻辑
4.获取对象的方式可以更加形象、具体
通过getxxx实例能直观的展示我们要获取的对象实例,相对于通过有参构造,更直观形象。

2.工厂方法

定义一个抽象工厂，其定义了产品的生产接口，但不负责具体的产品，将生产任务交给不同的派生类工厂。这样不用通过指定类型来创建对象了。

实例演示:
定义一个抽象工厂,提供两个具体的实现工厂实现具体的功能,当需要产品时,调用该类型的工厂生产

public interface AbstractFactory {//抽象接口
    Phone makePhone();
}

public class XiaoMiFactory implements AbstractFactory{//具体实现1
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}

public class AppleFactory implements AbstractFactory {//具体实现2
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
}

public class Demo {//测试类
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        appleFactory.makePhone();        // make iphone!
    }
}

总结:

1.当需要对实例增强时,只需增强工厂里的方法,
—就是增加手机的某个功能,在工厂统一改进就行,

2.工厂之间相互独立,不会相互影响
—某天我厂子干不了了,隔壁厂子还能干呢

3.对功能增强,也不影响其他的产品j

4.方便维护,便于理解

3.抽象工厂

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，无须指定它们具体的类。

public interface PC {//定义一个PC接口
    void make();
}

public class MiPC implements PC {//定义一个具体实现产品MIPC
    public MiPC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi PC!");
    }
}

public class MAC implements PC {//定义第二个实现产品MAC
    public MAC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make MAC!");
    }
}

public interface AbstractFactory {//定义一个抽象工厂,抽象两个生产的产品的方法
    Phone makePhone();
    PC makePC();
}

public class XiaoMiFactory implements AbstractFactory{
    //定义一个工厂,实现抽象工厂,重写方法,生产具体的产品
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
    @Override
    public PC makePC() {
        return new MiPC();
    }
}

public class AppleFactory implements AbstractFactory {
	 //定义一个工厂,实现抽象工厂,重写方法,生产具体的产品
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
    @Override
    public PC makePC() {
        return new MAC();
    }
}

public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        miFactory.makePC();                // make xiaomi PC!
        appleFactory.makePhone();        // make iphone!
        appleFactory.makePC();            // make MAC!
    }
}

总结

1.抽象工厂角色很多,但可以分为四个:
抽象工厂,具体工厂,抽象产品,具体产品

2.抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建

---

参照资料整理总结至:
https://www.cnblogs.com/yssjun/p/11102162.html 博主 alpha_panda
https://baijiahao.baidu.com/s?id=1643071573766349132&wfr=spider&for=pc
博主: 凯哥Java