02- 工厂模式：

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。

著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() ；

工厂模式也是用来创建实例对象的且具有更大的可扩展性和尽量少的修改量。

工厂模式定义
【通常我们都要在创建sample实例时一般是用new ,但是如果创建对象的同时要进行初始化的工作,且不是简单赋值，查询数据库，是有很长一段代码操作，new 中的构造函数是没办法满足。如果非写入构造函数中，也是有悖于Java[面向对象的原则，但是如果利用工厂模式，将代码“封装”起来(减少段和段之间耦合联系性)，这样会降低代码耦合提高代码服用。】

下面例子中鼠标，键盘，耳麦为产品，惠普，戴尔为工厂。

1.简单工厂模式

简单工厂模式：简而言之，就是有一个专门生产某个产品的类。

比如下图中的鼠标工厂，专业生产鼠标，给参数 0，生产戴尔鼠标，给参数 1，生产惠普鼠标。

/** @create: 2020-02-15 22:20
 * 简单工厂模式
 **/
public class SimpleFactory {
    public static void main(String[] args) {
        Car  car1 = (Car)Factory.get("奥迪");
        car1.create();
        Car  car2 = (Car)Factory.get("宝马");
        car2.create();
    }
}
//生产车的工厂
class Factory {
    public static Object get(String carType) {
        Car car =null;
        if (carType.equals("奥迪")) {
            car = new Aodi();
        } else if (carType.equals("宝马")) {
            car = new Baoma();
        }
        return car;
    }
}
//奥迪车的类
class Aodi implements Car{
    @Override
    public void create() {
        System.out.println("生产奥迪");
    }
}
//宝马车的类
class Baoma implements Car{
    @Override
    public void create() {
        System.out.println("生产宝马");
    }
}
//汽车的接口
interface Car {
    void create();
}

2.工厂模式

工厂模式也就是鼠标工厂是个父类，有生产鼠标这个接口。
戴尔鼠标工厂，惠普鼠标工厂继承它，可以分别生产戴尔鼠标，惠普鼠标。
生产哪种鼠标不再由参数决定，而是创建鼠标工厂时，由戴尔鼠标工厂创建。
后续直接调用鼠标工厂.生产鼠标()即可

/**工厂方法模式
 **/
public class MethodFactoryTest {
    public static void main(String[] args) {
        //需要生产奔驰就调用奔驰车的工厂
        Aotuo aotuo = AotuoFactory.Create();
        aotuo.Run();
        //需要生产奥拓就调用生产凹凸车的工厂
        Benchi benchi = BenchiFactory.Create();
        benchi.Run();
    }

}
//创建一个接口
interface Cars{
   void  Run();
}
//生产奥拓车的工厂
class AotuoFactory {
    public static Aotuo Create() {
        return new Aotuo();
    }

}
//生产奔驰车的工厂
class BenchiFactory {
    public static Benchi Create() {
         return new Benchi() ;
    }
}

class Aotuo implements Cars{
    @Override
    public void Run() {
        System.out.println("生产奥拓");
    }
}
class Benchi implements Cars{
    @Override
    public void Run() {
        System.out.println("生产奔驰");
    }
}

3.抽象工厂模式

抽象工厂模式也就是不仅生产鼠标，同时生产键盘。
也就是 PC 厂商是个父类，有生产鼠标，生产键盘两个接口。
戴尔工厂，惠普工厂继承它，可以分别生产戴尔鼠标+戴尔键盘，和惠普鼠标+惠普键盘。
创建工厂时，由戴尔工厂创建。
后续工厂.生产鼠标()则生产戴尔鼠标，工厂.生产键盘()则生产戴尔键盘。

3-1 .在抽象工厂模式中，假设我们需要增加一个工厂

假设我们增加华硕工厂，则我们需要增加华硕工厂，和戴尔工厂一样，继承 PC 厂商。
之后创建华硕鼠标，继承鼠标类。创建华硕键盘，继承键盘类即可。

3-2 .在抽象工厂模式中，假设我们需要增加一个产品

假设我们增加耳麦这个产品，则首先我们需要增加耳麦这个父类，再加上戴尔耳麦，惠普耳麦这两个子类。
之后在PC厂商这个父类中，增加生产耳麦的接口。最后在戴尔工厂，惠普工厂这两个类中，分别实现生产戴尔耳麦，惠普耳麦的功能。以上。

/**
 * 抽象工厂模式
 **/
public class AbstractFactory {
    public static void main(String[] args) {
        DaierKebo daierKebo = DaierFactory.CreateKebo();
        daierKebo.click();
        DaierMouse daierMouse = DaierFactory.CreateMouse();
        daierMouse.Run();
        HuibuKebo huibuKebo = HuibuFactory.CreateKebo();
        huibuKebo.click();
        HuipuMouse huipuMouse = HuibuFactory.CreateMouse();
        huipuMouse.Run();
        LianxiangKebo lianxiangKebo = LianxiangFactory.CreateKebo();
        lianxiangKebo.click();
        LianxiangMouse lianxiangMouse = LianxiangFactory.CreateMouse();
        lianxiangMouse.Run();
    }
}

//生产鼠标和接口 和生产键盘的接口
interface  Mouse{
    void Run();
}
interface Kebo{
    void click();
}

//接口的实现类惠普 和戴尔
class DaierMouse implements  Mouse{
    @Override
    public void Run() {
        System.out.println("生产戴尔的鼠标");
    }
}
class HuipuMouse implements  Mouse{
    @Override
    public void Run() {
        System.out.println("生产惠普的鼠标");
    }
}

class DaierKebo implements  Kebo{
    @Override
    public void click() {
        System.out.println("生产戴尔的键盘");
    }
}
class HuibuKebo implements  Kebo{
    @Override
    public void click() {
        System.out.println("生产惠普的键盘");
    }
}

//戴尔 和惠普的工厂
class DaierFactory{
   public static  DaierMouse CreateMouse(){
        return new DaierMouse();
    }
    public static  DaierKebo CreateKebo(){
        return new DaierKebo();
    }
}
class  HuibuFactory{
    public static  HuipuMouse CreateMouse(){
        return new HuipuMouse();
    }
    public static  HuibuKebo CreateKebo(){
        return new HuibuKebo();
    }
}

//增加一个联想公司
class LianxiangMouse implements  Mouse{
    @Override
    public void Run() {
        System.out.println("生产联想鼠标");
    }
}
class  LianxiangKebo implements Kebo{
    @Override
    public void click() {
        System.out.println("生产联想键盘");
    }
}
class LianxiangFactory {
    public static LianxiangMouse CreateMouse(){
        return new LianxiangMouse();
    }
    public static  LianxiangKebo CreateKebo(){
        return new LianxiangKebo();
    }
}

由此可见，工厂方法确实为系统结构提供了非常灵活强大的动态扩展机制，只要我们更换一下具体的工厂方法，系统其他地方无需一点变换，就有可能将系统功能进行改头换面的变化。

————————————————
版权声明：本文为CSDN博主「openstack_developer」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/wqwqwqwq403/article/details/89043234