【JAVA总结】工厂设计模式

场景引入：某同学去商城买电脑，有两款特别喜欢，一款MacBook Pro，另一款Surface pro.

---

类图

创建 Computer 接口

interface Computer {
    void printComputer();
}

创建 Client.java 

通过类实现接口（需重写printComputer（）方法）

class MacbookProComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("MacbookProComputer");
    }
}

class SurfaceBookComputer implements Computer{

    @Override
    public void printComputer() {
        System.out.println("SurfacebookComputer");
    }
}

客户端

public class Client {
    public void buyComputer(Computer computer){
        computer.printComputer();
    }

    public static void main(String[] args) {
        Client client = new Client();
        client.buyComputer(new MacbookProComputer());
        client.buyComputer(new SurfaceBookComputer());
    }
}

运行结果：

我们可以看出，此代码存在缺陷，如果某同学又看上一款电脑，就不得不返回客户端修改代码。

所以需要对代码优化：即实例化具体类从客户端中分离出来。

一、简单工厂模式

专门定义一个类创建其他类实例

将类的实例化交给工厂

增加ComputerFactory类

概要：1、一个抽象产品类 2、具体产品类 3、一个工厂

ComputerFacyory类

class ComputerFactory {
    public static Computer getInstance(String type) {
        Computer computer = null;
        if (type.equals("macbook")) {
            computer = new MacbookProComputer();
        } else if (type.equals("surface")) {
            computer = new SurfaceBookComputer();
        }
        return computer;
    }
}

main函数

public static void main(String[] args) {
        Client client = new Client();

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你想要的电脑类型：");
        String type = scanner.nextLine();

        Computer computer = ComputerFactory.getInstance(type);
        client.buyComputer(computer);
       
    }

二、工厂方法模式 

定义一个用于创建对象的接口，通过子类决定实例化哪个类

针对每个产品提供一个工厂类，在客户端中判断使用哪个工厂类去实现该接口。

概要：1、一个抽象产品类 2、多个具体产品类 3、一个抽象工厂 4、多个具体工厂

电脑工厂接口

interface ComputerFactory {
    Computer createComputer();
}

MsFactory、AppleFactory类实现电脑工厂接口（需重写createComputer方法）

class MsFactory implements ComputerFactory{

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

class AppleFactory implements ComputerFactory{

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

main函数

public static void main(String[] args) {
        Client client = new Client();
        ComputerFactory factory = new AppleFactory();
        client.buyComputer(factory.createComputer());
}

运行结果:

三、抽象工厂模式

提供创建一系列相关或相互依赖对象的接口（无需指定类）

概要：1、多个抽象产品类  2、具体产品类  3、抽象工厂类，声明返回抽象产品的方法  4、具体工厂类，生成具体产品。

创建 OperatingSystem 接口

interface OperatingSystem {
    void printSystem();
}

通过类MacOSSystem、Windows10System实现OperatingSystem （需对printSystem方法重写）

class MacOsSystem implements OperatingSystem{

    @Override
    public void printSystem() {
        System.out.println("This is mac os");
    }
}

class Windows10System implements OperatingSystem{

    @Override
    public void printSystem() {
        System.out.println("This is  windows 10");
    }
}

创建ProductionFactory接口 

interface ProductionFactory {
    Computer createComputer();
    OperatingSystem createSystem();
}

通过类AppleFactory、MsFactory实现ProductionFactory （需对createComputer、createSystem方法重写）

class MsFactory implements ProductionFactory{

    @Override
    public Computer createComputer() {
        return new SurfaceBookComputer();
    }
    @Override
    public OperatingSystem createSystem(){
        return new Windows10System();
    }
}

class AppleFactory implements ProductionFactory{
    @Override
    public Computer createComputer() {
        return new MacbookProComputer();
    }
     @Override
    public OperatingSystem createSystem(){
        return new MacOsSystem();
    }
}

客户端

buyComputer 、 use函数

public void buyComputer(Computer computer){
        computer.printComputer();
    }

public void use(OperatingSystem s){
        s.printSystem();
    }

 main函数

public static void main(String[] args) {
        Client client = new Client();
        //ProductionFactory factory = new AppleFactory();
        ProductionFactory factory = new MsFactory();
        Computer computer = factory.createComputer();
        OperatingSystem system = factory.createSystem();
        client.buyComputer(computer);
        client.use(system);
}

运行结果：

比较简单工厂模式、工厂方法模式、抽象工厂模式

区别	简单工厂模式	工厂方法模式	抽象工厂模式
优点	1.简单易于实现 2.将类的实例化交给工厂，易于解耦	1.降低代码耦合度，由子类完成对象的生成 2.实现了开放封闭原则，添加子类不需要修改源代码	1.代码解耦 2.实现了多个产品的生产，可以满足更多产品需求 3.满足开放封闭原则 4.可以定义实现多个接口，一个工厂可以生成多个产品，所以对复杂对象生产十分灵活
缺点	添加具体产品必须修改工厂，违反开闭原则	1.增加了代码量，每个具体产品都需要一个工厂 2.增加抽象产品，需要修改工厂，违背开闭原则	1.扩展产品簇麻烦，且会违反开闭原则 2.代码量大，很笨重