设计模式：工厂方法模式与抽象工厂模式

一、工厂方法模式

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

1、工厂方法的主要角色

• 抽象产品（Product）：定义具体产品的公共接口
• 具体产品（ConcreteProduct）：继承抽象产品类并定义生产的具体产品
• 抽象工厂（Creator）：定义具体工厂的公共接口
• 具体工厂（ConcreteCreator）：继承抽象工厂类并定义创建对应具体产品实例的方法

2、实现工厂方法

//抽象产品类
public abstract class Product {
    //产品类的公共方法
    public void method() {
        //业务逻辑处理
    }

    //抽象方法
    public abstract void method2();
}

//具体产品类
public class ConcreteProduct1 extends Product {
    @Override
    public void method2() {
        //业务逻辑
    }
}

//具体产品类
public class ConcreteProduct2 extends Product {
    @Override
    public void method2() {
        //业务逻辑
    }
}

//抽象工厂类
public abstract class Creator {
    public abstract <T extends Product> T createProduct(Class<T> c);
}

//具体工厂类
public class ConcreteCreator extends Creator {
    @Override
    public <T extends Product> T createProduct(Class<T> c) {
        Product product = null;
        try {
            product = (Product) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            //异常处理
            e.printStackTrace();
        }
        return (T) product;
    }
}

public class Client {
    public static void main(String[] args) {
        Creator creator = new ConcreteCreator();
        Product product = creator.createProduct(ConcreteProduct1.class);
        //业务逻辑
    }
}

3、缩小为简单工厂模式

//抽象产品类
public abstract class BMW {
    public BMW() {
    }
}

//具体产品类
public class BMW320 extends BMW {
    public BMW320() {
        System.out.println("制造BMW320...");
    }
}

//具体产品类
public class BMW523 extends BMW {
    public BMW523() {
        System.out.println("制造BMW523...");
    }
}

//工厂类
public class Creator {
    public static <T extends BMW> T createBMW(Class<T> c) {
        BMW bmw = null;
        try {
            bmw = (BMW) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            //异常处理
            e.printStackTrace();
        }
        return (T) bmw;
    }
}

public class Client {
    public static void main(String[] args) {
        BMW bmw320 = Creator.createBMW(BMW320.class);
        BMW bmw523 = Creator.createBMW(BMW523.class);
    }
}

执行结果如下：

制造BMW320...
制造BMW523...

简单工厂模式也称为静态工厂模式，缺点是工厂类的扩展比较困难，但是仍然非常实用

主要角色如下：

• 工厂类角色：用来创建产品
• 抽象产品角色：定义具体产品的公共接口
• 具体产品角色：继承抽象产品类并定义生产的具体产品

二、抽象工厂模式

抽象工厂模式为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式来产生需要的对象

两个产品族的类图如下：

public abstract class AbstractProductA {
    //每个产品共有的方法
    public void shareMethod() {

    }

    //每个产品相同方法，不同实现
    public abstract void doSomething();
}

public class ProductA1 extends AbstractProductA {
    @Override
    public void doSomething() {
        System.out.println("产品A1的实现方法");
    }
}

public class ProductA2 extends AbstractProductA {
    @Override
    public void doSomething() {
        System.out.println("产品A2的实现方法");
    }
}

产品B与此类似

//抽象工厂类AbstractCreator的职责是定义每个工厂要实现的功能
public abstract class AbstractCreator {
    //创建A产品家族
    public abstract AbstractProductA createProductA();
    
    //创建B产品家族
    public abstract AbstractProductB createProductB();
}

//产品等级1的实现类
public class Creator1 extends AbstractCreator {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

//产品等级2的实现类
public class Creator2 extends AbstractCreator {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

有M个产品等级就应该有M个实现工厂类，在每个实现工厂中，实现不同产品族的生产任务

public class Client {
    public static void main(String[] args) {
        AbstractCreator creator1 = new Creator1();
        AbstractCreator creator2 = new Creator2();
        AbstractProductA a1 = creator1.createProductA();
        a1.doSomething();
        AbstractProductA a2 = creator2.createProductA();
        a2.doSomething();
        AbstractProductB b1 = creator1.createProductB();
        b1.doSomething();
        AbstractProductB b2 = creator2.createProductB();
        b2.doSomething();
    }
}

抽象工厂模式的缺点就是产品族扩展相对困难

三、工厂方法和抽象工厂的区别

工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类

一个抽象工厂类，可以派生出多个具体工厂类

每个具体工厂类只能创建一个具体产品类的实例

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类

一个抽象工厂类，可以派生出多个具体工厂类

每个具体工厂类可以创建多个具体产品类的实例

区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个

工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个