java设计模式--工厂设计模式（工厂类）

工厂设计模式（工厂，代理 ***，单例）：将客户端的new操作解耦到第三方（工厂类）

OCP（开闭原则）

• 简单工厂设计模式（应用场景：产品个数小，没有家族）

        1. 抽象产品类（接口）

        2. 多个具体产品类 - MacBookPro，SurfaceBooK

        3. 一个工厂（new 操作在此工厂中进行）-- 客户端通过工厂类获取具体实例。

有一天，刘同学准备去买笔记本，他到商城发现有两款电脑他特别喜欢, 一款是 Macbook Pro, 另一款是 Surface Pro。

实例：这里我们相当于是创建生产电脑的工厂，客户需要购买什么样的电脑，只要输入类型编号就可以获取该电脑。将类的实例化交给工厂,易于解耦

类图如下：

代码如下：

import java.util.Scanner;
//抽象产品类
interface Computer{
    void printComputer();
}
//具体产品类
class MacbookPorComputer implements Computer{
    public void printComputer(){
        System.out.println("This is a MacbookPor!");
    }
}
//具体产品类
class SurfaceBookComputer implements Computer{
    public void printComputer(){
        System.out.println("This is a SurfaceBook!");
    }
}
//具体工厂类
class ComputerFactory{
    public static Computer getInstance (String type){
        Computer computer=null;
        if(type.equals("MacbookPro")){
            computer=new MacbookPorComputer();
        }
        else if(type.equals("SurfaceBooK")){
            computer=new SurfaceBookComputer();
        }
        return computer;
    }
}
//场景类
public class Test{
    public void buyComputer(Computer computer){
        computer.printComputer();
    }
    public static void main(String[] args) {
        Test client=new Test();
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入您想要的电脑型号...");
        String Type=scanner.nextLine();
        Computer computer=ComputerFactory.getInstance(Type);
        client.buyComputer(computer);
    }
}

简单工厂模式优点：

1. 简单易于实现
2. 将类的实例化交给工厂，易于解耦

缺点：添加具体产品需要修改工厂 违反OCP开放封闭原则

• 工厂方法模式（横向扩展方便，典型的解耦框架）-- 应用场景：每个产品有自己家族，家族下有多个产品

        定义一个用来创建对象的接口，让子类决定实例化哪一个类。

        针对每个产品（产品类）提供一个工厂类，客户端需要判断使用哪个工厂

1. 一个抽象产品类
2. 多个具体产品类
3. 一个抽象工厂（针对抽象产品类）
4. 多个具体工厂（每个产品家族拥有自己的工厂）

实例：

import java.util.Scanner;

//抽象产品类
interface Computer{
    void printComputer();
}
//具体产品类
class MacbookPorComputer implements Computer{
    public void printComputer(){
        System.out.println("This is a MacbookPor!");
    }
}
//具体产品类
class SurfaceBookComputer implements Computer{
    public void printComputer(){
        System.out.println("This is a SurfaceBook!");
    }
}
//抽象工厂类
interface ComputerFactory{
    Computer creatComputer();
}
//微软家族工厂类
class MsFactory implements ComputerFactory{
    public Computer creatComputer(){
        return new SurfaceBookComputer();
    }
}
//苹果家族工厂类
class AppleFactory implements ComputerFactory{
    public Computer creatComputer(){
        return new MacbookPorComputer();
    }
}
//场景类
public class Test{
    public void buyComputer(Computer computer){
    computer.printComputer();
    }
    public static void main(String[] args) {
        Test client=new Test();
        ComputerFactory factory=new AppleFactory();
        client.buyComputer(factory.creatComputer());
    }
}

优点：

1. 降低了代码耦合度，对象的生成交给子类去完成
2. 实现了开放封闭原则 - 每次添加子产品 不需要修改原有代码
3. 良好的封装性，代码结构清晰

缺点：

1. 增加了代码量，每个具体产品都需要一个具体工厂
2. 当增加抽象产品也就是添加一个其他产品族需要建立一个相应的工厂类，增加扩展难度，违背OCP原则

• 抽象工厂模式（了解）-- 多个产品线混合