工厂模式

*概述：

• 在创建一个对象时，不向客户端暴露内部细节，并提供一个创建对象的通用接口

1. 简单工厂

• 把实例化的操作单独放到一个类中，整个类就成为简单工厂类，让简单工厂决定应该使用哪个具体子类来实例化
• 优点：客户并不需要直到子类的细节以及应当实例化哪个，而当子类发生修改时，也并不需要客户进行修改

public class SimpleFactory {

    public Product createProduct(int type) {
        if (type == 1) {
            return new ConcreteProduct1();
        } else if (type == 2) {
            return new ConcreteProduct2();
        }
        return new ConcreteProduct();
    }
}
public class Client {

    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        Product product = simpleFactory.createProduct(1);
        // do something with the product
    }
}

 

2. 工厂方法

• 定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法将类的实例化延迟到其之类
• 与简单工厂模式的区别：
  • 简单工厂模式在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了具体产品的依赖。
  • 但是需要增加新功能时，需要修改原有的类，违背了开放-封闭原则。

public abstract class Factory {
    abstract public Product factoryMethod();
    public void doSomething() {
        Product product = factoryMethod();
        // do something with the product
    }
}
public class ConcreteFactory1 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct1();
    }
}
public class ConcreteFactory2 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct2();
    }
}
public class ConcreteFactory3 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct3();
    }
}

 

3. 抽象工厂

• 提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类
• 继承父类工厂的不同子类，分别新建不同的实例，当实例不同的子类时，就可以new不同的类了

public class AbstractProductA {
}
public class AbstractProductB {
}
public class ProductA1 extends AbstractProductA {
}
public class ProductA2 extends AbstractProductA {
}
public class ProductB1 extends AbstractProductB {
}
public class ProductB2 extends AbstractProductB {
}
public abstract class AbstractFactory {
    abstract AbstractProductA createProductA();
    abstract AbstractProductB createProductB();
}
public class ConcreteFactory1 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA1();
    }

    AbstractProductB createProductB() {
        return new ProductB1();
    }
}
public class ConcreteFactory2 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA2();
    }

    AbstractProductB createProductB() {
        return new ProductB2();
    }
}
public class Client {
    public static void main(String[] args) {
        AbstractFactory abstractFactory = new ConcreteFactory1();
        AbstractProductA productA = abstractFactory.createProductA();
        AbstractProductB productB = abstractFactory.createProductB();
        // do something with productA and productB
    }
}