一、简单工厂模式
1.简单工厂模式 通过一个工厂类集中管理对象的创建 ，通过参数决定具体创建哪个对象。
#适合对象类型较少且变化不频繁的场景，缺点是违反开闭原则（新增产品需修改工厂类）

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

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

示例代码:

// 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. 工厂方法模式的实现步骤：定义产品接口——>定义产品的具体实现类，让其实现"产品接口"并重写"产品接口方法"——>定义产品的工厂接口——>定义产品具体的工厂类，让其实"现工厂接口"并重写"工厂接口方法"——>在使用的时候需要创建不同产品的工厂类对象，然后调用他们重写后的接口方法来创建对象。

示例代码

// 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）——>实现具体产品类（分属不同产品族）——>定义抽象工厂接口，包含多个工厂方法——> 实现具体工厂类，为每个产品族提供创建逻辑

示例代码:

// 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. 三种模式的核心区别