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

简单工厂模式

• 定义：一种创建型设计模式，将对象的创建过程封装在一个工厂类中，用户不必关系创建过程，只需要要向工厂类传递不同的参数来创建不同类型的对象。

• 类图如下：
  

• 代码如下：

interface Product { }
class ProductA implements Product {}
class ProductB implements Product {}
class ProductC implements Product {}
class Factory{
    public static Product getProduct(String type){
        if("A".equals(type)){
            return new ProductA();
        };
        if("B".equals(type)){
            return new ProductB();
        };
        if("C".equals(type)){
            return new ProductC();
        };
        return null;
    }
}

public class 简单工厂 {
    public static void main(String[] args) {
        Product producta = Factory.getProduct("A");
        Product productb = Factory.getProduct("B");
        System.out.println(producta.getClass());//ProductA
        System.out.println(productb.getClass());//ProductB
    }
}

• 不足：
  1. 增加产品时，要修改工厂类Factory的源码，才能使用新产品，不符合开闭原则
  2. 工厂类Factory负责创建多个不同类型的产品，违反单一职责原则
  3. 可扩展性低

工厂方法模式

• 定义：一种创建型设计模式，它定义了一个工厂接口，工厂类实现这个接口来创建对象，不同的工厂子类可以创建不同类型的对象。每个具体的产品都有对应的工厂类。

• 类图如下：
  

• 代码如下：

interface Product { }
class ProductA implements Product {}
class ProductB implements Product {}
class ProductC implements Product {}
interface Factory{
    Product getProduct();
}
class FactoryA implements Factory{
    @Override
    public Product getProduct() {
        return new ProductA();
    }
}
class FactoryB implements Factory{
    @Override
    public Product getProduct() {
        return new ProductB();
    }
}
class FactoryC implements Factory{
    @Override
    public Product getProduct() {
        return new ProductC();
    }
}
public class 工厂方法 {
    public static void main(String[] args) {
        Factory factory1=new FactoryA();
        Product product1=factory1.getProduct();
        System.out.println(product1);//ProductA
        Factory factory2=new FactoryB();
        Product product2=factory2.getProduct();
        System.out.println(product2);//ProductB
    }
}

抽象工厂模式

• 定义：一种创建型设计模式，提供了一种创建一组相关或相互依赖对象的方式，无需指定其具体类的方法。抽象工厂定义了一组工厂方法，每个工厂方法可以创建一个不同类型的对象，而每个工厂方法的实现由具体的工厂子类完成。

• 类图如下：
  

• 代码如下：

interface ProductOne { }
class ProductOneA implements ProductOne {}
class ProductOneB implements ProductOne {}
interface ProductTwo { }
class ProductTowA implements ProductTwo {}
class ProductTowB implements ProductTwo {}
interface Factory{
    ProductOne getProductOne();
    ProductTwo getProductTwo();
}
class Factory1 implements Factory{
    @Override
    public ProductOne getProductOne() {
        return new ProductOneB();
    }
    @Override
    public ProductTwo getProductTwo() {
        return new ProductTowA();
    }
}
class Factory2 implements Factory{
    @Override
    public ProductOne getProductOne() {
        return new ProductOneA();
    }
    @Override
    public ProductTwo getProductTwo() {
        return new ProductTowA();
    }
}
public class 抽象工厂 {
    public static void main(String[] args) {
        Factory factory1=new Factory1();
        ProductOne pO1 = factory1.getProductOne();
        ProductTwo pT1 = factory1.getProductTwo();
        System.out.println(pO1);//ProductOneB
        System.out.println(pT1);//ProductTowA
        Factory factory2=new Factory2();
        ProductOne pO2 = factory2.getProductOne();
        ProductTwo pT2 = factory2.getProductTwo();
        System.out.println(pO2);//ProductOneA
        System.out.println(pT2);//ProductTowA
    }
}

总结：

• 简单工厂模式封装了对象的创建过程，通过传递参数来获得不同类型的对象。
• 工厂方法模式将对象的创建委托给不同的工厂类，每个工厂类负责创建一种类型的对象。
• 抽象工厂模式提供了一种创建一组相关或相互依赖对象的方式，通过定义一组工厂方法和工厂接口，每个工厂可以创建多个对象，而每个工厂方法可以创建不同类型的对象。