设计模式：简单工厂模式、工厂方法模式和抽象工厂模式

1.工厂模式

工厂模式本质上是创建逻辑的管理工具，通过封装、解耦、抽象，解决了直接 new对象带来的耦合，扩展、维护等问题，最终实现：

更高的可维护性：修改创建逻辑只需改工厂类，无需修改客户端；
更强的可扩展性：新增产品只需扩展工厂，符合开闭原则；
更好的可读性：客户端代码更简洁，专注于业务逻辑而非创建细节；
更低的修改风险：解耦后，修改具体产品不影响客户端；
更符合设计原则：体现依赖导致、开闭原则等核心式设计思想。

总之，当对象创建逻辑复杂、产品类型多变、需要统一管理或保证一致性时，工厂模式是解决问题的最佳实践。

（1）简单工厂模式

定义

不属于GoF23种设计模式，是工厂模式的简化：通过一个统一的工厂类，根据输入参数创建不同类型的产品实例。

结构

产品接口：定义产品的公共方法；
具体产品：实现产品接口的具体类；

工厂类：核心，根据参数创建并返回具体产品实例。

java 复制代码

package DesignPatterns;

//产品接口
interface Phone {
    void brand();
    
}
//具体产品
class iphone implements Phone{
    @Override
    public void brand(){
    System.out.println("Iphone");
    }
}
//具体产品
class Huawei implements Phone{
    @Override
    public void brand(){
        System.out.println("Huawei");
    }
}

//简单工厂类
class PhoneFactory{
    public static Phone creaPhone(String type){
        switch(type){
            case "Iphone":
                return new iphone();
            case "Huawei":
                return new Huawei();
            default:
                throw new IllegalArgumentException("未知");
        
      }
    }
}
//客户端调用
public class SimpleFactory {
    public static void main(String[] args) {
        Phone ip = new PhoneFactory().creaPhone("Iphone");
        ip.brand();
        Phone hua = new PhoneFactory().creaPhone("Huawei");
        hua.brand();
    }
}

优点	缺点
实现简单，客户端无需关心产品创建细节	违反开闭原则：新增产品需修改工厂类的switch逻辑；
降低客户端与具体产品的耦合	工厂类职责过重，所有产品创建逻辑集中在一个类中；
适合产品类型较少的场景	扩展性差，产品类型增多时工厂类会变得臃肿

（2）工厂方法模式

定义

GoF23种设计模式之一：定义一个创建产品的接口，让子类决定实例化哪个产品类，工厂方法将产品创建延迟到子类，符合开闭原则。

结构

产品接口：定义产品的公共方法；
具体产品：实现产品接口的具体类
工厂接口：定义创建产品的抽象方法；

具体工厂：实现工厂接口，创建对应具体产品。

java 复制代码

package DesignPatterns;
//产品接口
interface Phone {
    void brand();
    
}
//具体产品
class Iphone implements Phone{
    public void brand(){
        System.out.println("Iphone");
    }
}
//具体产品
class Huawei implements Phone{
    public void brand(){
        System.out.println("Huawei");
    }
}
//工厂接口
interface PhoneFactory{
    Phone createPhone();
}
//具体工厂
class IphoneFactory implements PhoneFactory{
    @Override
    public Phone createPhone(){
        return new Iphone();
    }
}
//具体工厂
class HuaweiFactory implements PhoneFactory{
    @Override
    public Phone createPhone(){
        return new Huawei();
    }
}



//客户端调用
public class FactoryMethod {
    public static void main(String[] args) {

        Phone ip = new IphoneFactory().createPhone();
        ip.brand();
        Phone hua = new HuaweiFactory().createPhone();
        hua.brand();
    }
}

优点	缺点
符合开闭原则：新增产品只需添加具体产品和对应工厂，无需修改现有代码	类数量增多：每新增一个产品，需新增一个具体产品类和一个具体工厂类
降低耦合：客户端仅依赖抽象工厂和产品接口	系统复杂度增加：抽象层次多，理解成本高（相比简单工厂，工厂方法对工厂又进行了一次抽象）
扩展性好：支持产品类型的灵活扩展	不适合产品族（相关联的多个产品）的创建

（3）抽象工厂模式

GoF23种设计模式之一：提供一个创建一系列相关或相互依赖对象的接口，无需指定具体类。用于创建"产品族"。

结构

产品族接口：定义一组相关产品的公共方法（如手机、耳机）；
具体产品：实现产品族接口的具体类；
抽象工厂：定义创建产品族中所有产品的抽象方法；
具体工厂：实现抽象工厂，创建对应品牌的产品族实例。

java 复制代码

package DesignPatterns;
//产品族接口
interface Phone {
    void brand();
    
}
interface EarPhone{
    void link();
}

//具体产品
class Iphone implements Phone{
    @Override
    public void brand(){
        System.out.println("Iphone");

    }
 



}
class Huawei implements Phone{
    @Override
    public void brand(){
        System.out.println("huawei");
    }
}
class Airpods implements EarPhone{
    @Override
    public void link(){
        System.out.println("Airpods");
    }
}
class Freebuds implements EarPhone{
    @Override
    public void link(){
        System.out.println("Freebuds");
    }
}
//抽象工厂
interface ProductFactory{
    Phone createPhone();
    EarPhone createEarPhone();
}

//具体工厂

class IphoneProductFactory implements ProductFactory{
    @Override
    public Iphone createPhone(){
        return new Iphone();
    }
    @Override
    public EarPhone createEarPhone(){
        return new Airpods();
    }
}
class HuaweiProductFactory implements ProductFactory{
    @Override
    public Huawei createPhone(){
        return new Huawei();
    }
    @Override
    public EarPhone createEarPhone(){
        return new Freebuds();
    }
}
public class AbstracttFactory {
    public static void main(String[] args) {
        IphoneProductFactory ipf = new IphoneProductFactory();

        Phone ip = ipf.createPhone();
        ip.brand();
        EarPhone ipe = ipf.createEarPhone();
        ipe.link();
        HuaweiProductFactory hwf = new HuaweiProductFactory();

        Phone hw = hwf.createPhone();
        hw.brand();
        EarPhone hwe = hwf.createEarPhone();
        hwe.link();

    }
}

复制代码

优点	缺点
保证产品族的一致性：同一工厂生产的产品自动匹配	扩展产品等级结构困难：若新增产品，需修改抽象工厂和所有具体工厂
符合开闭原则：新增产品族只需添加具体工厂和对应产品	系统复杂度高
隔离具体类的创建：客户端无需关心产品族的具体表现	产品族内的产品数量固定，不适合频繁变化的产品结构

2.三种模式的核心特征对比

维度	简单工厂模式	工厂方法模式	抽象工厂模式
工厂数量	1个（唯一的工厂类）	N个（每个产品对应1个工厂）	M个（每个产品族对应1个工厂）
工厂职责	生产所有产品（通过参数判断）	生产单一产品（每个工厂只造一种产品）	生产产品族（每个工厂造一组相关产品）
产品结构	单一产品等级（如上面的例子仅仅生产手机）	单一产品等级	多个产品等级（产品族，如[手机+耳机]）
开闭原则	违反（新增产品需修改工厂类的switch/if）	符合（新增产品只需新增工厂，无需修改现有代码）	符合（新增产品族只需新增工厂，无需修改现有代码）
核心思想	一个工厂造所有	一个工厂造一个	一个工厂造一族
典型代码结构	静态工厂方法	抽象工厂接口+具体工厂实现（每个工厂重写createProduct()）	抽象工厂接口定义多个创建方法（如createPhone()\createEarphone()