设计模式之工厂模式

工厂模式实现了创建者和调用者的分离，经典案例：BeanFactory、SessionFactory

简单工厂模式

• 又称静态工厂模式。只有一个工厂，返回某一类的不同实现，用途最为广泛，事实证明结构越简单的设计越常用。通常是预定义好的所有产品，在工厂里编写创建产品的方法（直接创建所有对象或根据指定标识创建）。
• 优点：
  • 结构比较简单
  • 用户只需要和工厂和产品接口交互即可
• 缺点：
  • 扩展新产品有时并不是很容易，但是可以使用Class类对象反射创建同一类对象

public class SimpleFactory {
    // 如果这里不使用Product类对象参数而使用其他标识，那么在增加新的产品时将会比较麻烦，需要修改这个类，就违反了开闭原则
    public Product createProduct(Class<? extends Product> clazz) {
        try {
            return clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

abstract class Product {}
class P1 extends Product {}
class P2 extends Product {}

class Client {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product p1 = factory.createProduct(P1.class);
        Product p2 = factory.createProduct(P2.class);
    }
}   

工厂方法模式

• 概述：定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。
• 顶层工厂创建的是产品的接口，工厂的具体实现创建的是具体的产品实现，一个工厂对应一个产品
• 适用性：
  • 当一个类不知道它所必须创建的对象的类的时候
  • 当一个类希望由它的子类来指定它所创建的对象的时候
  • 当类将创建对象的职责委托给多个帮助子类的某一个，并且你希望将哪一个帮助子类是代理这一信息局部化的时候
  • 便于增加新产品，只需增加产品和产品工厂类并实现相应的接口
• 优点：
  • 便于扩展，只需要增加新的产品和工厂即可。
• 缺点：
  • 代码结构要比简单工厂复杂
  • 用户需要和具体的工厂、工厂实现及产品接口进行交互

public abstract class FactoryMethod {
    public abstract Product createProduct();
}

class P1Factory extends FactoryMethod{
    @Override
    public Product createProduct() {
        return new P1();
    }
}

class P2Factory extends FactoryMethod{
    @Override
    public Product createProduct() {
        return new P2();
    }
}

interface Product{}
class P1 implements Product{}
class P2 implements Product{}

class Client {
    public static void main(String[] args) {
        FactoryMethod factory1 = new P1Factory();
        Product produc1 = factory1.createProduct();
        FactoryMethod factory2 = new P2Factory();
        Product product2 = factory2.createProduct();
    }
}

抽象工厂模式

• 对了便捷切换组合产品而生
• 客户需要看到所有抽象接口和工厂的具体实现
• 优点：
  • 工厂创建的是一整套对象，适用于更改产品系列如换肤等功能
• 缺点：
  • 难以扩展新的产品

public abstract class AbstractFactory {
    public abstract ProductA createProductA();
    public abstract ProductB createProductB();
}

// P1的工厂只创建1型的产品（命名：约定优于配置）
class P1Factory extends AbstractFactory{
    @Override
    public ProductA createProductA() {
        return new A1();
    }
    @Override
    public ProductB createProductB() {
        return new B1();
    }
}
class P2Factory extends AbstractFactory{
    @Override
    public ProductA createProductA() {
        return new A2();
    }
    @Override
    public ProductB createProductB() {
        return new B2();
    }
}

abstract class ProductA{}
class A1 extends ProductA{}
class A2 extends ProductA{}

abstract class ProductB{}
class B1 extends ProductB{}
class B2 extends ProductB{}

class Client{
    public static void main(String[] args) {
        AbstractFactory factory = new P1Factory();
        ProductA productA1 = factory.createProductA();
        ProductB productB1 = factory.createProductB();

        factory = new P2Factory();
        ProductA productA2 = factory.createProductA();
        ProductB productB2 = factory.createProductB();
    }
}

转载于:https://www.cnblogs.com/mabaoqing/p/10691562.html