该篇文章主要是工厂方法模式。

定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

产品类

1.产品抽象类

public abstract class Product {
    public abstract void doSomething();
}

2.实现类A

public class ProductA extends Product {
    @Override
    public void doSomething() {
        System.out.println("ProductA do something");
    }
}

3.实现类B

public class ProductB extends Product {
    @Override
    public void doSomething() {
        System.out.println("ProductB do something");
    }
}

方法工厂

1.抽象方法工厂

public abstract class AbstractFactory {
    abstract <T extends Product> T create(Class<T> t ) throws ClassNotFoundException, IllegalAccessException, InstantiationException;
}

2.抽象方法工厂实现类

public class ProductFactory extends AbstractFactory {
    @Override
    <T extends Product> T create(Class<T> t) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        return (T) Class.forName(t.getName()).newInstance();
    }
}

运行

运行工厂方法

 public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        AbstractFactory factory = new ProductFactory();
        ProductA productA = factory.create(ProductA.class);
        productA.doSomething();
        ProductB productB = factory.create(ProductB.class);
        productB.doSomething();
    }

结果如下：

ProductA do something
ProductB do something


工厂方法模式的优点

1. 良好的封装性，代码结构清秀。
2. 工厂方法模式的扩展性非常优秀。在增加产品类的情况下，只要适当的修改具体的工厂类或扩展一个工厂类，就可以完成扩展。
3. 屏蔽产品类。产品类的实现如何变化，调用者可以不用关心，只需要关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。
4. 工厂方法时典型的解耦框架。高层模块只需要知道产品类的抽象类，其他的实现类都不用关心。

扩展

简单工厂模式

静态方法，不需要继承抽象类：

   public static <T extends Product> T instance(Class<T> t) {
        Product product = null;
        try {
             product = (Product) Class.forName(t.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) product;
    }