设计模式之工厂方法模式

工厂方法模式是创建型设计模式之一。
定义一个用于创建对象的接口，让子类决定实例化哪个类，或者子类根据传入的参数不同而创建不同的类。

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

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

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

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

public class MakeFactory extends Factory {    //工厂类的实现类，在这只生产A产品    @Override    public Product createProduct() {        return new ProductA();    }}

public class Client {    public static void main(String[] args){        MakeFactory factory = new MakeFactory();        ProductA productA = (ProductA) factory.createProduct();    }}

通过以上方法可以产生一个ProductA对象，但是，不能产生ProductB对象。
我们可以这样做：

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

public class MakeFactory extends Factory {    @Override    public Product createProduct(String product) {        Product product1=null;        switch (product){            case "productA":product1 = new ProductA();                break;            case "productB":product1 = new ProductB();                break;        }        return product1;    }}

public class Client {    public static void main(String[] args){        MakeFactory factory = new MakeFactory();        ProductA productA = (ProductA) factory.createProduct("productA");    }}

这样，我们就可以根据传入的参数不同，创建不同的对象。但是，当我们需要生产的对象比较多时，我们是不是需要switch case许多次？我们是不是需要改原来的代码？Java中类的加载可以更好地解决这个问题。

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

public class MakeFactory extends Factory {    @Override    public <T extends Product> T createProduct(Class<T> tClass) {        Product p = null;        try {            p= (Product) Class.forName(tClass.getName()).newInstance();        } catch (InstantiationException e) {            e.printStackTrace();        } catch (IllegalAccessException e) {            e.printStackTrace();        } catch (ClassNotFoundException e) {            e.printStackTrace();        }        return (T) p;    }}

public class Client {    public static void main(String[] args){        MakeFactory factory = new MakeFactory();        ProductA productA = (ProductA) factory.createProduct(ProductA.class);    }}

此时，无论我们的产品有多少，都是可以产生的。
代码有许多不足之处，需要改进，请谅解。