Java设计模式学习之工厂模式

工厂模式


Java中的工厂模式(Factory Pattern)是一种创建型设计模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。这种模式的核心思想是将对象的创建与使用解耦,即客户端不直接通过new关键字来创建对象,而是通过调用一个共同的接口来得到所需的对象实例。

工厂模式主要有三种类型:简单工厂模式(Simple Factory Pattern)、工厂方法模式(Factory Method Pattern)和抽象工厂模式(Abstract Factory Pattern)。

1. 简单工厂模式(Simple Factory Pattern)

简单工厂模式并不属于GOF的23种设计模式之一,但它作为工厂模式的入门,通常被首先介绍。简单工厂模式通过定义一个工厂类,根据传入的参数决定创建哪一种类的实例。

优点

  • 客户端不需要知道所创建的具体产品类的类名,只需要知道对应产品的工厂。
  • 如果要增加新产品,只需要修改工厂类即可,不需要修改客户端代码,符合开闭原则。

缺点

  • 工厂类集中了所有产品的创建逻辑,如果产品类非常多,那么工厂类会非常庞大,违背了单一职责原则。
  • 一旦添加新产品就需要修改工厂类,违背了开闭原则的“对扩展开放,对修改关闭”。
复制代码
// 产品接口  
interface Product {  
    void use();  
}  
  
// 具体产品A  
class ConcreteProductA implements Product {  
    @Override  
    public void use() {  
        System.out.println("Using ConcreteProductA");  
    }  
}  
  
// 具体产品B  
class ConcreteProductB implements Product {  
    @Override  
    public void use() {  
        System.out.println("Using ConcreteProductB");  
    }  
}  
  
// 简单工厂类  
class SimpleFactory {  
    public static Product createProduct(String type) {  
        if ("A".equals(type)) {  
            return new ConcreteProductA();  
        } else if ("B".equals(type)) {  
            return new ConcreteProductB();  
        }  
        return null;  
    }  
}  
  
// 客户端  
public class SimpleFactoryDemo {  
    public static void main(String[] args) {  
        Product productA = SimpleFactory.createProduct("A");  
        productA.use();  
  
        Product productB = SimpleFactory.createProduct("B");  
        productB.use();  
    }  
}

2. 工厂方法模式(Factory Method Pattern)

工厂方法模式定义了一个创建对象的接口,但由子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类中进行。

优点

  • 用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程。
  • 系统在增加新的产品时只需要添加具体产品类和对应的具体工厂类,无须对原工厂接口和抽象工厂类做任何修改,满足开闭原则。

缺点

  • 系统中类的个数将成对增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖。
复制代码
// 产品接口  
interface Product {  
    void use();  
}  
  
// 具体产品A  
class ConcreteProductA implements Product {  
    @Override  
    public void use() {  
        System.out.println("Using ConcreteProductA");  
    }  
}  
  
// 具体产品B  
class ConcreteProductB implements Product {  
    @Override  
    public void use() {  
        System.out.println("Using ConcreteProductB");  
    }  
}  
  
// 工厂接口  
interface Creator {  
    Product factoryMethod();  
}  
  
// 具体工厂A  
class ConcreteCreatorA implements Creator {  
    @Override  
    public Product factoryMethod() {  
        return new ConcreteProductA();  
    }  
}  
  
// 具体工厂B  
class ConcreteCreatorB implements Creator {  
    @Override  
    public Product factoryMethod() {  
        return new ConcreteProductB();  
    }  
}  
  
// 客户端  
public class FactoryMethodDemo {  
    public static void main(String[] args) {  
        Creator creatorA = new ConcreteCreatorA();  
        Product productA = creatorA.factoryMethod();  
        productA.use();  
  
        Creator creatorB = new ConcreteCreatorB();  
        Product productB = creatorB.factoryMethod();  
        productB.use();  
    }  
}

3. 抽象工厂模式(Abstract Factory Pattern)

抽象工厂模式提供一个接口,用于创建相关或依赖对象的家族,而不需要明确指定具体类。

优点

  • 当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
  • 增加新的产品族很方便,无须修改已有系统,符合开闭原则。

缺点

  • 产品族扩展困难,要增加一个新的产品族,则必须修改抽象工厂接口,增加新的抽象生产方法,这样就涉及到抽象工厂类及其所有子类的改变,代价较高。
  • 难以支持新种类的产品。
复制代码
// 抽象产品A  
interface AbstractProductA {  
    void use();  
}  
  
// 抽象产品B  
interface AbstractProductB {  
    void use();  
}  
  
// 具体产品A1  
class ConcreteProductA1 implements AbstractProductA {  
    @Override  
    public void use() {  
        System.out.println("Using ConcreteProductA1");  
    }  
}  
  
// 具体产品B1  
class ConcreteProductB1 implements AbstractProductB {  
    @Override  
    public void use() {  
        System.out.println("Using ConcreteProductB1");  
    }  
}  
  
// 具体产品A2  
class ConcreteProductA2 implements AbstractProductA {  
    @Override  
    public void use() {  
        System.out.println("Using ConcreteProductA2");  
    }  
}  
  
// 具体产品B2  
class ConcreteProductB2 implements AbstractProductB {  
    @Override  
    public void use() {  
        System.out.println("Using ConcreteProductB2");  
    }  
}  
  
// 抽象工厂  
interface AbstractFactory {  
    AbstractProductA createProductA();  
    AbstractProductB createProductB();  
}  
  
// 具体工厂1  
class ConcreteFactory1 implements AbstractFactory {  
    @Override  
    public AbstractProductA createProductA() {  
        return new ConcreteProductA1();  
    }  
  
    @Override  
    public AbstractProductB createProductB() {  
        return new ConcreteProductB1();  
    }  
}  
  
// 具体工厂2  
class ConcreteFactory2 implements AbstractFactory {  
    @Override  
    public AbstractProductA createProductA() {  
        return new ConcreteProductA2();  
    }  
  
    @Override  
    public AbstractProductB createProductB() {  
        return new ConcreteProductB2();  
    }  
}  
  
// 客户端  
public class AbstractFactoryDemo {  
    public static void main(String[] args) {  
        AbstractFactory factory1 = new ConcreteFactory1();  
        AbstractProductA productA1 = factory1.createProductA();  
        AbstractProductB productB1 = factory1.createProductB();  
  
        productA1.use();  
        productB1.use();  
  
        AbstractFactory factory2 = new ConcreteFactory2();  
        AbstractProductA productA2 = factory2.createProductA();  
        AbstractProductB productB2 = factory2.createProductB();  
  
        productA2.use();  
        productB2.use();  
    }  
}

总的来说,工厂模式的主要作用是解耦对象的创建与使用,使得系统更加灵活,易于扩展和维护。在具体使用时,应根据实际场景和需求选择合适的工厂模式类型。

posted @   BingBing爱化学-04044  阅读(5)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
· 上周热点回顾(2.17-2.23)
点击右上角即可分享
微信分享提示