工厂设计模式

1. 工厂设计模式

举例：某天，某同学去买电脑，一款电脑是Mac，一款是Lenovo

interface Computer{
    void printComputer();
}

class MacComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("这是Mac电脑");
    }
}

class LenovoComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("这是lenovo电脑");
    }
}
public class Client {
    public void buyComputer(Computer computer){
        computer.printComputer();
    }

    public static void main(String[] args){
        Client client = new Client();
        //每次都要修改客户端的代码
        client.buyComputer(new MacComputer());
        client.buyComputer(new LenovoComputer());
    }
}
/*
这是Mac电脑
这是lenovo电脑
*/

如果某同学又看上另外一台电脑，那么就要返回客户端修改代码。所以，要将实例化具体类的代码从客户端中抽离，或者封装起来，不会干扰其他应用部分

1.1 简单工厂模式

• 简单工厂模式：专门定义一个类用来创建其他类的实例，被创建的实例通常具有共同的父类
• 创建一个生产电脑的工厂，客户需要购买什么样的电脑，只要输入类型编号就可以获取
  举例如下：

interface Computer{
    void printComputer();
}

class MacComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("这是Mac电脑");
    }
}

class LenovoComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("这是lenovo电脑");
    }
}
class ComputerFactory{
    public static Computer getInstance(String type){
        if(type.equals("Mac")){
            return new MacComputer();
        }
        else if(type.equals("Lenovo")){
            return new LenovoComputer();
        }
        else{
            return null;
        }
    }
}
public class Client1 {
    public void buyComputer(Computer computer) {
        computer.printComputer();
    }

    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入电脑型号");
        String type = scanner.nextLine();

        Client1 client1 = new Client1();
        Computer computer = ComputerFactory.getInstance(type);
        if(computer == null){
            System.out.println("没有该电脑");
        }
        else{
            client1.buyComputer(computer);
        }
    }
}
/*
请输入电脑型号
Mac
这是Mac电脑
*/

简单工厂模式：

1. 一个抽象类
2. 具体产品类
   3.一个工厂

优点：

• 简单易于实现
• 把类的实例化交给工厂，易于解耦
  缺点：
• 添加具体产品需要修改工厂，违反了OCP开闭原则

1.2 工厂方法模式

• 工厂方法模式：定义一个创建对象的接口，让子类决定实例化哪一个类，让子类决定实例化延迟到子类
• 针对每个产品提供一个工厂类，在客户端中判断使用哪个工厂类去创建对象
  举例：

interface Computer{
    void printComputer();
}

class MacComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("这是Mac电脑");
    }
}

class LenovoComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("这是lenovo电脑");
    }
}
interface ComputerFactory2{
    Computer creatComputer();
}

class MacFactory implements ComputerFactory2{
    @Override
    public Computer creatComputer() {
        return new MacComputer();
    }
}

class LenovoFactory implements ComputerFactory2{
    @Override
    public Computer creatComputer() {
        return new LenovoComputer();
    }
}
public class Client2 {
    public void buyComputer(Computer computer){
        computer.printComputer();
    }

    public static void main(String[] args){
        ComputerFactory2 computerFactory2 = new MacFactory();
        Computer computer = computerFactory2.creatComputer();

        Client2 client2 = new Client2();
        client2.buyComputer(computer);
    }
}

工厂方法模式是针对每个产品提供一个工厂类，在客户端中判断使用哪个工厂类去创建对象

概要

1. 一个抽象产品类
2. 多个具体产品类
3. 一个抽象工厂
4. 多个具体工厂- 每一个具体产品对应一个具体工厂

优点：

• 降低了代码耦合度，对象的生成交给子类去完成
• 实现了开放封闭原则-每次添加子产品，不需要修改原有代码

缺点：

• 增加了代码量，每个具体产品都需要一个具体工厂
• 当增加抽象产品，也就是添加一个其他产品族，需要修改工厂违背OCP

1.3 抽象工厂模式

• 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类
• 当工厂只生产一个产品时，即为工厂方法模式；而工厂如果生产两个或以上的商品即为抽象工厂模式
  举例如下：

interface Computer{
    void printComputer();
}

class MacComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("这是Mac电脑");
    }
}

class LenovoComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("这是lenovo电脑");
    }
}
interface OperatingSystem{
    void printSystem();
}

class MacSystem implements OperatingSystem{
    @Override
    public void printSystem() {
        System.out.println("这是Mac OS");
    }
}

class WindowsSystem implements OperatingSystem{
    @Override
    public void printSystem() {
        System.out.println("这是Windows OS");
    }
}

interface ComputerFactory3{
    Computer creatComputer();
    OperatingSystem creatSystem();
}

class MacFactory3 implements ComputerFactory3{
    @Override
    public Computer creatComputer() {
        return new MacComputer();
    }

    public OperatingSystem creatSystem(){

        return new MacSystem() ;
    }
}

class LenovoFactory3 implements ComputerFactory3{
    @Override
    public Computer creatComputer() {
        return new LenovoComputer();
    }

    @Override
    public OperatingSystem creatSystem() {
        return new WindowsSystem();
    }
}
public class Client3 {
    public void buyComputer(Computer computer, OperatingSystem system){
        computer.printComputer();
        system.printSystem();
    }
    public static void main(String[] args){
        ComputerFactory3 computerFactory3 = new MacFactory3();
        Computer computer = computerFactory3.creatComputer();
        OperatingSystem system = computerFactory3.creatSystem();

        Client3 client3 = new Client3();
        client3.buyComputer(computer, system);
    }
}
/*
这是Mac电脑
这是Mac OS
*/

概念：

1. 多个抽象产品类
2. 具体产品类
3. 抽象工厂类-声明（一组）返回抽象产品的方法
4. 具体工厂类-生成（一组）具体产品

优点：

• 代码解耦
• 实现多个产品族（相关联产品组成的家族），而工厂方法模式的单个产品，可以满足更多的生产需求
• 很好的满足OCP开放封闭原则
• 抽象工厂模式中可以定义实现不止一个接口，一个工厂也可以生成不止一个产品类，对于复杂产品扩展更灵活
  缺点：
• 扩展产品族相当麻烦，而且扩展产品族会违反OCP，修改所有的工厂