设计模式-工厂模式-让你彻底搞懂_工厂模式设计-CSDN博客

本文链接：https://blog.csdn.net/qq_29031985/article/details/147504239

一、概述

工厂模式是Java开发中最常用的设计模式之一，核心价值是隔离变化点。通过使用工厂模式，可以将对象的创建逻辑封装在一个工厂类中，而不是在客户端代码中直接实例化对象，这样可以提高代码的可维护性和可扩展性。

二、分类

1. 简单工厂模式

(1) 组成

抽象产品（Abstract Product）：描述某类产品的功能，并定义了该类产品的规范。
具体产品（Concrete Product）：是抽象产品的具体实现，完全遵循抽象产品的规范。
具体工厂（Concrete Factory）：提供了创建产品的方法，调用者通过该方法来获取产品。

(2) 关系图

(3) 类图

(4) 代码

public abstract class Phone {
    public abstract void call();

    public abstract void video();
}

public class HuaWPhone extends Phone {
    @Override
    public void call() {
        System.out.println("Hua wei phone call...");
    }

    @Override
    public void video() {
        System.out.println("Hua wei phone video...");
    }
}

public class XiaoMPhone extends Phone {
    @Override
    public void call() {
        System.out.println("xiao mi phone call...");
    }

    @Override
    public void video() {
        System.out.println("xiao mi phone video...");
    }
}

public class SimplePhoneFactory {
    public Phone creatPhone(String type) {
        Phone phone = null;
        if ("huaw".equals(type)) {
            phone = new HuaWPhone();
        } else {
            phone = new XiaoMPhone();
        }
        return phone;
    }
}

public class Consumer {
    public void usePhone() {
        SimplePhoneFactory factory = new SimplePhoneFactory();
        Phone huawei = factory.creatPhone("huawei");
        huawei.call();
        huawei.video();
    }
}

(5) 优缺点

优点：适合简单场景，实现容易。

缺点：不够灵活，违反了开闭原则。

(6) 适用场景

文件解析，根据不同的文件格式，创建不同的文件解析器。
支付渠道选择，根据不同的支付方式，创建不同的支付实例。

2. 工厂方法模式

(1) 组成

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Abstract Product）：描述产品的功能，并定义了该类产品的规范。
具体产品（Concrete Product）：是抽象产品的具体实现，完全遵循抽象产品的规范。

(2) 关系图

(3) 类图

(4) 代码

public abstract class Phone {
    public abstract void call();
    public abstract void video();
}

public class HuaWPhone extends Phone{
    @Override
    public void call() {
        System.out.println("Hua wei phone call...");
    }

    @Override
    public void video() {
        System.out.println("Hua wei phone video...");
    }
}

public class XiaoMPhone extends Phone{
    @Override
    public void call() {
        System.out.println("xiao mi phone call...");
    }

    @Override
    public void video() {
        System.out.println("xiao mi phone video...");
    }
}

public interface PhoneFactory {
    public Phone creatPhone();
}

public class HuaWPhoneFactory implements PhoneFactory{
    @Override
    public Phone creatPhone() {
        return new HuaWPhone();
    }
}

public class XiaoMPhoneFactory implements PhoneFactory{
    @Override
    public Phone creatPhone() {
        return new XiaoMPhone();
    }
}

public class Consumer {
    private PhoneFactory phoneFactory;

    public Consumer(PhoneFactory phoneFactory) {
        this.phoneFactory = phoneFactory;
    }

    public void usePhone(){
        Phone phone = phoneFactory.creatPhone();
        phone.call();
        phone.video();
    }

}

(5) 优缺点

优点：符合开闭原则，

缺点：产品拓展比较复杂，因为新增一个产品就需要添加具体的产品和具体的工厂。

(6) 使用场景

Java集合框架的迭代器
Spring的BeanFactory

3. 抽象工厂模式

(1) 组成

多类抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
多类具体工厂（Concrete Factory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
多类抽象产品（Abstract Product）：描述产品的功能，并定义了该类产品的规范。
多类具体产品（Concrete Product）：是抽象产品的具体实现，完全遵循抽象产品的规范。

(2) 关系图

(3) 类图

(4) 代码

public interface Phone {
    public void call();

    public void video();
}

public class HuaWPhone implements Phone {
    @Override
    public void call() {
        System.out.println("hua wei phone call");
    }

    @Override
    public void video() {
        System.out.println("hua wei phone video");
    }
}

public class XiaoMPhone implements Phone {
    @Override
    public void call() {
        System.out.println("xiao mi phone call");
    }

    @Override
    public void video() {
        System.out.println("xiao mi phone video");
    }
}

public interface Computer {
    public void network();
}

public class HuaWComputer implements Computer {
    @Override
    public void network() {
        System.out.println("hua wei computer network");
    }
}

public class XiaoMComputer implements Computer {
    @Override
    public void network() {
        System.out.println("xiao mi computer network");
    }
}

public interface ProductFactotry {
    public Phone createPhone();

    public Computer createComputer();
}

public class HuaWFactory implements ProductFactotry {
    @Override
    public Phone createPhone() {
        return new HuaWPhone();
    }

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

public class XiaoMFactory implements ProductFactotry {
    @Override
    public Phone createPhone() {
        return new XiaoMPhone();
    }

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

public class Consumer {
    private ProductFactotry productFactotry;

    public Consumer(ProductFactotry productFactotry) {
        this.productFactotry = productFactotry;
    }

    public void consume() {
        Computer computer = productFactotry.createComputer();
        computer.network();
        Phone phone = productFactotry.createPhone();
        phone.call();
    }
}