工厂模式VS抽象工厂模式

工厂模式与抽象工厂模式的核心差别

一、最核心的差别：创建对象的"数量"和"关系"

1. 工厂方法模式：一对一创建

// 工厂方法模式：一个工厂只创建一种产品
abstract class CarFactory {
    public abstract Car createCar(); // 只有一个创建方法
}

class BMWFactory extends CarFactory {
    @Override
    public Car createCar() {
        return new BMW(); // 只创建BMW这一种产品
    }
}

2. 抽象工厂模式：一对多创建

// 抽象工厂模式：一个工厂创建一族相关产品
interface LuxuryCarFactory {
    Car createCar();        // 创建汽车
    Engine createEngine();  // 创建引擎
    Tire createTire();      // 创建轮胎
}

class BMWFactory implements LuxuryCarFactory {
    @Override
    public Car createCar() { return new BMW(); }
    
    @Override
    public Engine createEngine() { return new BMWEngine(); }
    
    @Override
    public Tire createTire() { return new BMWTire(); }
}

二、核心差别对比表

维度	工厂方法模式	抽象工厂模式
创建产品数量	一个工厂创建一种产品	一个工厂创建一族产品
产品间关系	产品之间无关联	产品之间有关联（产品族）
工厂方法数量	一个抽象方法	多个抽象方法
解决的问题	创建单一产品的多种实现	创建相关产品的不同系列
扩展方式	增加产品→增加工厂类	增加产品族→增加工厂类

三、用生活化例子理解核心差别

工厂方法模式：专业化工厂

// 比如：专门的手机工厂
abstract class PhoneFactory {
    public abstract Phone createPhone();
}

class ApplePhoneFactory extends PhoneFactory {
    public Phone createPhone() {
        return new iPhone(); // 只生产iPhone
    }
}

class SamsungPhoneFactory extends PhoneFactory {
    public Phone createPhone() {
        return new GalaxyPhone(); // 只生产Galaxy手机
    }
}

抽象工厂模式：品牌生态工厂

// 比如：苹果生态工厂（生产一整套苹果产品）
interface TechEcosystemFactory {
    Phone createPhone();
    Laptop createLaptop();
    Tablet createTablet();
    Watch createWatch();
}

class AppleEcosystemFactory implements TechEcosystemFactory {
    public Phone createPhone() { return new iPhone(); }
    public Laptop createLaptop() { return new MacBook(); }
    public Tablet createTablet() { return new iPad(); }
    public Watch createWatch() { return new AppleWatch(); }
}

class SamsungEcosystemFactory implements TechEcosystemFactory {
    public Phone createPhone() { return new GalaxyPhone(); }
    public Laptop createLaptop() { return new GalaxyBook(); }
    public Tablet createTablet() { return new GalaxyTab(); }
    public Watch createWatch() { return new GalaxyWatch(); }
}

四、核心差别的实际体现

1. 客户端使用方式的差别

// 工厂方法模式的使用
public class FactoryMethodClient {
    public void useFactory() {
        PhoneFactory factory = new ApplePhoneFactory();
        Phone phone = factory.createPhone(); // 只能创建手机
        phone.call();
    }
}

// 抽象工厂模式的使用
public class AbstractFactoryClient {
    public void useFactory() {
        TechEcosystemFactory factory = new AppleEcosystemFactory();
        
        // 可以创建整套产品
        Phone phone = factory.createPhone();
        Laptop laptop = factory.createLaptop();
        Tablet tablet = factory.createTablet();
        Watch watch = factory.createWatch();
        
        // 这些产品之间可以协同工作
        phone.syncWith(laptop);
        tablet.syncWith(phone);
        watch.syncWith(phone);
    }
}

2. 扩展性的差别

// 工厂方法模式：增加新产品类型
class HuaweiPhoneFactory extends PhoneFactory {
    public Phone createPhone() {
        return new HuaweiPhone(); // 新增华为手机工厂
    }
}

// 抽象工厂模式：增加新产品族
class HuaweiEcosystemFactory implements TechEcosystemFactory {
    public Phone createPhone() { return new HuaweiPhone(); }
    public Laptop createLaptop() { return new MateBook(); }
    public Tablet createTablet() { return new MatePad(); }
    public Watch createWatch() { return new HuaweiWatch(); }
}

五、选择标准：一个简单的判断方法

问自己这个问题：

“我需要创建的是单一产品的不同实现，还是一组相关产品的不同系列？”

// 如果答案是"单一产品的不同实现" → 工厂方法模式
// 例：不同品牌的汽车（都是汽车，但实现不同）
abstract class CarFactory {
    public abstract Car createCar();
}

// 如果答案是"一组相关产品的不同系列" → 抽象工厂模式  
// 例：不同品牌的汽车生态系统（汽车+引擎+轮胎+音响等）
interface CarEcosystemFactory {
    Car createCar();
    Engine createEngine();
    Tire createTire();
    AudioSystem createAudioSystem();
}

六、核心差别总结

工厂方法模式的本质

• 专注于"怎么创建"：关注单一产品的不同创建方式
• 垂直扩展：在同一产品线上增加不同的实现
• 简单直接：一个问题，一个解决方案

抽象工厂模式的本质

• 专注于"创建什么"：关注创建哪一套相关的产品
• 水平扩展：在产品族层面进行扩展
• 系统化思考：考虑产品间的协调和兼容性

记忆口诀

• 工厂方法：一厂一品，专业生产
• 抽象工厂：一厂多品，配套生产

这就是两种模式的核心差别：工厂方法解决"如何创建单一产品"的问题，抽象工厂解决"如何创建产品族"的问题。