超级好懂的设计模式——工厂模式

精心整理了设计模式——工厂模式，并配图加代码，方便理解，实属不易，但是难免不了存在纰漏，感谢大家的指正与理解！觉的写的不错的小伙伴儿，一键三连支持一下，后期会有持续更新！！抱拳了罒ω罒

1. 工厂模式简介

  工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。主要有三种不同实现方式：简单工厂模式，工厂方法模式，抽象工厂模式。
  应用实例： 您需要一部手机，可以直接从工厂里面提货，而不用去管这部手机是怎么做出来的，以及这个手机里面的具体实现。

2. 简单工厂模式

  该模式对对象创建管理方式最为简单，该模式通过向工厂传递类型来指定要创建的对象。

下面我们使用门的生产来讲解该模式：
Door接口：门生产的标准规范接口

 public interface Door{ 
     void make();
 }

WoodDoor 类：生产木门的类

 class WoodDoor implements Door{

     @Override
     public void make() {
         System.out.println("生产一扇木门");
     }
 }

IronDoor 类：生产铁门的类

class IronDoor implements Door{

    @Override
    public void make() {
        System.out.println("生产一扇铁门");
    }
}

DoorFactory类：工厂类，生产不同的门。

class DoorFactory{
    public Door makeDoor(String type) {
        if (type.equalsIgnoreCase("wood")){
            return new WoodDoor();
        }else if (type.equalsIgnoreCase("iron")){
            return new IronDoor();
        }else return null;
    }
}

测试程序

public class test {
    public static void main(String[] args) {
        DoorFactory df = new DoorFactory();
        Door wood = df.makeDoor("wood");
        Door iron = df.makeDoor("iron");
        wood.make();//生产一扇木门
        iron.make();//生产一扇铁门
    }
}

  如果我们还需要生产不锈钢门，那么就需要在DoorFactory类中添加添加相应的判断逻辑（增加if判断）。那么这样就会修改了原有的代码，违背了设计模式的开闭原则(对扩展开放，对修改关闭)，这样就会每次扩展功能的时候都需要对工厂类进行修改，增加了开销。

3. 工厂方法模式

  工厂方法模式将生成具体产品的任务分发给具体的产品工厂，也就是定义一个抽象工厂，但不负责具体的产品，将生产任务交给不同的派生类工厂。

其中和产品相关的Door接口、WoodDoor 类和IronDoor 类的定义不变。
AbstractFactory接口：生产不同产品的工厂的抽象类（接口）

public interface AbstractFactory{ 
     Door makeDoor();
 }

WoodFactory：生产木门的工厂

class WoodFactory implements AbstractFactory{

    @Override
    public Door makeDoor() {
        return new WoodDoor();
    }
}

IronFactory：生产铁门的工厂

class IronFactory implements AbstractFactory{

    @Override
    public Door makeDoor() {
        return new IronDoor();
    }
}

演示：

public class test {
    public static void main(String[] args) {
        AbstractFactory wdf = new WoodFactory();
        AbstractFactory idf = new IronFactory();
        Door wooddoor = wdf.makeDoor();
        Door irondoor = idf.makeDoor();
        wooddoor.make();//生产一扇木门
        irondoor.make();//生产一扇铁门
    }
}

  符合开闭原则，如果我们还需要生产不锈钢门，只需要增加具体的产品类（和具体的⼯⼚类，不需要修改原有的代码；
  符合单⼀职责原则，每个⼯⼚只负责⽣产对应的产品；

4. 抽象工厂模式

  上面两种模式不管工厂怎么拆分抽象，都只是针对一类产品，抽象工厂模式通过在抽象工厂中增加创建产品的接口，并在具体子工厂中实现新加产品的创建，从而实现多类产品。即工厂方法模式实现单个产品（实现门），抽象工厂模式实现多个产品（实现门和窗）
接下来使用生产门和窗户的例子来讲解该模式。
其中和门相关的Door接口、WoodDoor 类和IronDoor 类的定义不变。增加产品窗户的生产的相关类和接口。
Window接口：门生产的标准规范接口

interface Window{
    void make();
}

WoodWindow 类：生产木窗的类

class WoodWindow implements Window{

    @Override
    public void make() {
        System.out.println("生产一个木窗");
    }
}

IronWindow 类：生产铁窗的类

class IronWindow implements Window{

    @Override
    public void make() {
        System.out.println("生产一个铁窗");
    }
}

下面需要修改工厂相关的类的定义：
AbstractFactory类：增加窗户产品制造接口

interface AbstractFactory{
    public Door makeDoor();
    public Window makeWindow();
}

WoodFactory类：增加木质窗户的制造

class WoodFactory implements AbstractFactory{

    @Override
    public Door makeDoor() {
        return new WoodDoor();
    }

    @Override
    public Window makeWindow() {
        return new WoodWindow();
    }
}

IronFactory 类：增加铁质窗户的制造

class IronFactory implements AbstractFactory{

    @Override
    public Door makeDoor() {
        return new IronDoor();
    }

    @Override
    public Window makeWindow() {
        return new IronWindow();
    }
}

演示：

public class test {
    public static void main(String[] args) {
        AbstractFactory wdf = new WoodFactory();
        AbstractFactory idf = new IronFactory();
        
        Door wooddoor = wdf.makeDoor();
        Door irondoor = idf.makeDoor();
        wooddoor.make();//生产一扇木门
        irondoor.make();//生产一扇铁门
        
        Window woodwindow = wdf.makeWindow();
        Window ironwindow = idf.makeWindow();
        woodwindow.make();//生产一个木窗
        ironwindow.make();//生产一个铁窗
    }
}

总结

上面介绍的三种工厂模式有各自的应用场景，实际应用时能解决问题满足需求即可，可灵活变通，无所谓高级与低级。

参考文章：
https://www.cnblogs.com/yssjun/p/11102162.html
https://csp1999.blog.csdn.net/article/details/117635224