【简单理解什么是简单工厂、工厂方法与抽象工厂模式】

一、简单工厂模式

1.简单工厂模式 通过一个工厂类集中管理对象的创建 ,通过参数决定具体创建哪个对象。

#适合对象类型较少且变化不频繁的场景,缺点是违反开闭原则(新增产品需修改工厂类)

开闭原则(对扩展开放‌+对修改关闭‌) :当有新的需求或变化时,可以通过增加新的模块或功能来扩展软件实体的行为,而不需要修改现有的代码。;软件实体一旦被创建并投入使用,其内部实现应该保持稳定,不应轻易修改。

  1. 实现步骤:
    定义产品接口------>实现具体产品类------>创建工厂类------>通过参数控制对象创建

示例代码:

java 复制代码
// 1. 定义产品接口
interface Car {
    void drive();
}

// 2. 具体产品实现
class Tesla implements Car {
    @Override
    public void drive() {
        System.out.println("Driving Tesla!");
    }
}

class BMW implements Car {
    @Override
    public void drive() {
        System.out.println("Driving BMW!");
    }
}

// 3. 使用枚举优化参数
enum CarType {
    TESLA, BMW
}

class CarFactory {
    public static Car createCar(CarType type) {
        switch (type) {
            case TESLA:
                return new Tesla();
            case BMW:
                return new BMW();
            default:
                throw new IllegalArgumentException("Unknown car type!");
        }
    }
}

// 4. 使用
public class Main {
    public static void main(String[] args) {
        Car tesla = CarFactory.createCar(CarType.TESLA);
        tesla.drive(); // Driving Tesla!
        Car bmw = CarFactory.createCar(CarType.BMW);
        bmw.drive(); // Driving BMW!
    }
}

二、工厂方法模式

  1. 工厂方法模式通过定义一个抽象工厂接口,由子类(具体工厂)决定创建哪个具体产品。符合开闭原则,新增产品只需新增工厂类,无需修改原有代码。
  2. 扩展性强,新增产品类型时只需添加新工厂和产品类。解耦客户端与具体产品,客户端只需依赖抽象工厂接口。
  3. 工厂方法模式的实现步骤:定义产品接口------>定义产品的具体实现类,让其实现"产品接口"并重写"产品接口方法"------>定义产品的工厂接口------>定义产品具体的工厂类,让其实"现工厂接口"并重写"工厂接口方法"------>在使用的时候需要创建不同产品的工厂类对象,然后调用他们重写后的接口方法来创建对象。

示例代码

java 复制代码
// 1. 定义产品接口
interface Phone {
    void call();
}

// 2. 具体产品实现
class iPhone implements Phone {
    @Override
    public void call() {
        System.out.println("Calling with iPhone!");
    }
}

class Samsung implements Phone {
    @Override
    public void call() {
        System.out.println("Calling with Samsung!");
    }
}

// 3. 定义工厂接口
interface PhoneFactory {
    Phone createPhone();
}

// 4. 具体工厂实现
class iPhoneFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new iPhone();
    }
}

class SamsungFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new Samsung();
    }
}

// 5. 使用
public class Main {
    public static void main(String[] args) {
        PhoneFactory iphoneFactory = new iPhoneFactory();
        Phone iphone = iphoneFactory.createPhone();
        iphone.call(); // Calling with iPhone!
        
        PhoneFactory samsungFactory = new SamsungFactory();
        Phone samsung = samsungFactory.createPhone();
        samsung.call(); // Calling with Samsung!
    }
}

三、抽象工厂模式

  1. 抽象工厂模式用于创建一组相关或依赖的对象(如不同品牌的手机 + 耳机)。适用于产品族的创建,而不是单个产品。

  2. 定义与特点
    定义 :抽象工厂模式用于创建一组相关或依赖的对象(如不同品牌的手机 + 耳机)。
    适用场景 :需要创建"产品族"的场景(如苹果全家桶、三星全家桶)。
    核心思想:抽象工厂接口定义多个工厂方法,每个方法对应一个产品类型。

  3. 实现步骤

    定义产品族接口(如Phone和Earphones)------>实现具体产品类(分属不同产品族)------>定义抽象工厂接口,包含多个工厂方法------> 实现具体工厂类,为每个产品族提供创建逻辑

示例代码:

java 复制代码
// 1. 定义产品族接口
interface Phone {
    void call();
}

interface Earphones {
    void listen();
}

// 2. 具体产品实现(苹果产品族)
class iPhone implements Phone {
    @Override
    public void call() {
        System.out.println("Calling with iPhone!");
    }
}

class AirPods implements Earphones {
    @Override
    public void listen() {
        System.out.println("Listening with AirPods!");
    }
}

// 3. 具体产品实现(三星产品族)
class SamsungPhone implements Phone {
    @Override
    public void call() {
        System.out.println("Calling with Samsung!");
    }
}

class SamsungEarphones implements Earphones {
    @Override
    public void listen() {
        System.out.println("Listening with Samsung Earphones!");
    }
}

// 4. 定义抽象工厂接口
interface TechFactory {
    Phone createPhone();
    Earphones createEarphones();
}

// 5. 具体工厂实现(苹果工厂)
class AppleFactory implements TechFactory {
    @Override
    public Phone createPhone() {
        return new iPhone();
    }

    @Override
    public Earphones createEarphones() {
        return new AirPods();
    }
}

// 6. 具体工厂实现(三星工厂)
class SamsungFactory implements TechFactory {
    @Override
    public Phone createPhone() {
        return new SamsungPhone();
    }

    @Override
    public Earphones createEarphones() {
        return new SamsungEarphones();
    }
}

// 7. 使用
public class Main {
    public static void main(String[] args) {
        TechFactory appleFactory = new AppleFactory();
        appleFactory.createPhone().call();      // Calling with iPhone!
        appleFactory.createEarphones().listen(); // Listening with AirPods!
        
        TechFactory samsungFactory = new SamsungFactory();
        samsungFactory.createPhone().call();      // Calling with Samsung!
        samsungFactory.createEarphones().listen(); // Listening with Samsung Earphones!
    }
}

四、模式对比与疑问解答

  1. 工厂方法模式中选择接口而非抽象类的原因
    答案:
    灵活性更高:接口支持多实现,Java 不支持多继承,但类可实现多个接口。抽象类可能包含默认实现,限制子类灵活性。
    符合开闭原则:新增产品(如 Xiaomi)只需添加新具体产品类和对应工厂类,无需修改原有代码。
    设计意图契合:工厂方法模式的核心是定义"创建对象的接口",而接口仅定义方法签名,不提供具体实现。
  2. 三种模式的核心区别
特性 简单工厂模式 工厂方法模式 抽象工厂模式
创建对象类型 单一产品的不同实现(不同汽车) 单一产品的不同实现(不同手机) 一组相关产品(手机 + 耳机)
工厂结构 单一工厂类(静态方法) 抽象工厂接口 + 具体工厂类 抽象工厂接口 + 具体工厂类
工厂方法数量 1 个(createCar) 1 个(createPhone) 多个(如 createPhone 和 createEarphones)
扩展性 新增产品需修改工厂类 新增产品只需添加新工厂类 新增产品族需添加新工厂类
是否符合开闭原则 不符合 符合 符合
相关推荐
小杜-coding23 分钟前
黑马点评day01(基于Redis)
java·数据库·spring boot·redis·spring·缓存·mybatis
普通young man27 分钟前
QT | 常用控件
开发语言·前端·qt
twodragon&primy1 小时前
CSS布局
开发语言·前端·css·算法·html5
Code哈哈笑1 小时前
【图书管理系统】环境介绍、设计数据库和表、配置文件、引入依赖
java·数据库·spring boot·后端·mybatis
星沁城1 小时前
133. 克隆图
java·数据结构·算法·leetcode
老胖闲聊1 小时前
Python PyTorch库【机器学习框架】全面深入讲解与实践 入选【全站综合热榜第四】【领域内容榜第一】
开发语言·python
燃星cro1 小时前
关于MindVault项目测试报告
java·开发语言·测试工具·spring
努力学习的小廉2 小时前
【C++】 —— 笔试刷题day_25
开发语言·c++·动态规划
Bin Watson2 小时前
解决 Builroot 系统编译 perl 编译报错问题
开发语言·scala·perl
LDM>W<2 小时前
Easy云盘总结篇-文件上传01
java·spring boot·学习·ffmpeg