java设计模式（二）——工厂方法模式、抽象工厂模式

一、工厂方法模式

工厂模式分为简单工厂模式、工厂方法模式、抽象工厂模式。简单工厂模式就是将所有对象的创建放在一个类里面，由外面传的参数，用if else或者是switch语句来判断是创建何种对象，过于简单，这里就不赘述了。

工厂方法模式：简单来说就是一类产品用一个工厂类来创建。

产品父类：

public class Product {
    public void showMsg(){}
}

产品A类：

public class ProductA extends Product{
    @Override
    public void showMsg(){
        System.out.println("生产了A产品");
    }
}

产品B类：

public class ProductB extends Product{
    @Override
    public void showMsg(){
        System.out.println("生产了B产品");
    }
}

抽象工厂类：

public abstract class Factory {
    public abstract Product makeProduct();
}

A工厂类

public class FactoryA extends Factory{
    @Override
    public Product makeProduct() {
        return new ProductA();
    }
}

B工厂类

public class FactoryB extends Factory {
    @Override
    public Product makeProduct() {
        return new ProductB();
    }
}

测试类：

public class MyClass {

    public static void main(String[] args) {
        FactoryA factoryA = new FactoryA();
        factoryA.makeProduct().showMsg();

        FactoryB factoryB = new FactoryB();
        factoryB.makeProduct().showMsg();
    }

}

输出结果

生产了A产品
生产了B产品

工厂方法模式相对于简单工厂模式，将产品创建进行了很好的封装，少了较长的switch或者if else语句，但会多很多工厂类。一个工厂只能创建一类产品。

针对上述缺点，对代码做了以下改善

修改了Factory 类，创建产品时需要传入想生产的实现类的类名

public abstract class Factory {
    public abstract<T extends Product> T makeProduct(Class<T> tClass);
}

工厂实现类，通过传入的产品实现类，用反射生产出实际的产品，然后返回。

public class FactoryImp extends Factory{

    @Override
    public <T extends Product> T makeProduct(Class<T> tClass) {
        Product product = null;
        try {
            product = (Product)Class.forName(tClass.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) product;
    }
}

测试类，生产产品时，只需要传入想要生产的class类即可。

public class MyClass {

    public static void main(String[] args) {
        FactoryImp factory = new FactoryImp();
        factory.makeProduct(ProductA.class).showMsg();
        factory.makeProduct(ProductB.class).showMsg();
    }

}

优化后的代码，只需要创建一个工厂实现类，是代码简洁了许多。也易维护了。

二、抽象工厂模式

定义：为创建一组相关或者相互依赖的对象提供一个接口，而不需要指定他们的具体类。
使用场景：一组对象，具有相同的约束条件，可以抽象成一类对象，这类对象的创建就可以用抽象工厂模式。
如产品的生产和产品包装纸箱的生产，都属于一条生产线上的。

看看代码的实现方式
产品的工厂类

public abstract class ProductFactory {
	//包含产品的生产和包装两个方法
    public abstract Product makeProduct();

    public abstract ProductPacking makeProductPacking();

}

产品包装抽象类

public abstract class ProductPacking {
    public abstract void showMsg();
}

产品B包装类

public class ProductBPacking extends ProductPacking {
    @Override
    public void showMsg() {
        System.out.println("产品B包装好了");
    }
}

产品B的工厂类：

public class FactoryB extends ProductFactory {
    @Override
    public Product makeProduct() {
        return new ProductB();//产品B类的代码同上
    }

    @Override
    public ProductPacking makeProductPacking() {
        return new ProductBPacking();
    }
}

测试代码

public class MyClass {

    public static void main(String[] args) {
        FactoryB factoryB = new FactoryB();
        factoryB.makeProduct().showMsg();
        factoryB.makeProductPacking().showMsg();
    }

}

输出结果：

生产了B产品
产品B包装好了

通过抽象工厂模式，可以将一个产品线上的所有产品生产完。