设计模式之工厂方法模式

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

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);
    }
}

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