工厂模式Factory

定义：

定义一个用于建立对象的接口，让子类决定实例化哪一个类。

工厂模式类图：

类图说明：

• Product：抽象产品类
  • 负责定义产品的共性，实现对事物最抽象的定义。
• ConcreteProduct：具体产品类
  • 实现抽象产品的某个具体产品的对象。
• Factory：抽象工厂类
  • 工厂方法模式的核心
• ConcreteFactory：具体工厂类
  • 实现具体的业务逻辑

使用场景：

任何须要生成复杂对象的地方，均可以使用工厂方法模式。复杂对象适合使用工厂模式，用new就能够完成建立的对象无需使用工厂模式。（即须要经过较复杂或动态的方式生成一个对象的时候）

工厂模式的实现方式

/**
 * 抽象产品类
 */
public abstract class Product {
    /**
     * 产品类的抽象方法
     * 由具体的产品类去实现
     */
    public abstract void method();
}

/**
 * 具体产品类A
 */
public class ConcreteProductA extends Product {
    @Override
    public void method() {
        System.out.println("我是具体的产品A");
    }
}

/**
 * 具体产品类B
 */
public class ConcreteProductB extends Product {
    @Override
    public void method() {
        System.out.println("我是具体的产品B");
    }
}

/**
 * 抽象工厂类
 */
public abstract class Factory {
    /**
     * 抽象工厂方法
     * 具体产生什么由子类去实现
     * 
     * @return 具体的产品对象
     */
    public abstract Product createProduct();
}

/**
 * 具体工厂类
 */
public class ConcreteFactory extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

/**
 * 客户类
 */
public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product p = factory.createProduct();
        p.method();
    }
}

其余实现方式

1. 在具体工厂类中写死生成的产品类，如前面的例子，若是须要生成ConcreteProductB，更改ConcreteFactory中的逻辑便可：

/**
 * 具体工厂类
 */
public class ConcreteFactory extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
//      return new ConcreteProductA();
    }
}

2. 利用反射的方式在客户类中决定生成哪一个产品类：

/**
 * 抽象工厂类
 */
public abstract class Factory {
    /**
     * 抽象工厂方法
     * 具体产生什么由子类去实现
     *
     * @param clz 产品对象类类型
     * 
     * @return 具体的产品对象
     */
    public abstract <T extends Product> T createProduct(Class<T> clz);
}

/**
 * 具体工厂类
 */
public class ConcreteFactory extends Factory {
    @Override
    public <T extends Product> T createProduct(Class<T> clz) {
        Product p = null;
        try {
            p = (Product) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        } 
        return (T)p;
    }
}

/**
 * 客户类
 */
public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product p = factory.createProduct(ConcreteProductA.class);
        p.method();
    }
}

3. 多工厂方法模式，为每个产品都定义一个具体的工厂，各司其职：

/**
 * 具体工厂类A
 */
public class ConcreteFactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

/**
 * 具体工厂类B
 */
public class ConcreteFactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

/**
 * 客户类
 */
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.method();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.method();
    }
}

4. 简单工厂模式（静态工厂模式），若是肯定咱们的工厂类只有一个，那么能够简化掉抽象类：

/**
 * 简单工厂类(静态工厂类)
 */
public class Factory {
    /**
     * 抽象工厂方法
     * 具体产生什么由子类去实现
     *
     * @return 具体的产品对象
     */
    public static Product createProduct() {
        return new ConcreteProductA();
    }
}