工厂方法模式和抽象工厂模式

工厂方法模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类。 在工厂里面可以对对象的创建做严格的定义，client端直接通过工厂创建出来就可以使用了。

public abstract class Product {  //产品抽象类
    public abstract void method(); 
}
public class ConcreteProductA extends Product { //具体A产品
    @Override
    public void method() {
        System.out.println("产品A");
    }
}
public class ConcreteProductB extends Product {  //具体B产品
    @Override
    public void method() {
        System.out.println("产品B");
    }
}

public abstract class Factory {  //工厂抽象类
    public abstract Product createProduct();
}

public class ConcreteFactory extends Factory {  //具体工厂
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class Client {  //客户端使用
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product product = factory.createProduct();
        product.method();
    }
}

//也可以通过反射的方式

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

public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product product = factory.createProduct(ConcreteProductB.class);
        product.method();
    }
}

拥有多个工厂的方式我们称为多工厂方法模式，如果只有一个工厂我们可以去掉抽象类直接定义一个static（用static修饰可以不用初始化工厂直接返回产品，也可以不用static）的方法返回对象，这种叫做简单工厂或者静态工厂模式

优点和缺点是一样的：新加一个产品需要相应的产品类和一个工厂子类。

抽象工厂模式

为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定他们的具体实现类。
例如：
Q3和Q7有不同的轮胎、发动机、制动系统。虽然生产的零件不同，型号不同。但是根本上都有共同的约束，就是轮胎、发动机、制动系统。设计如下：

1. 需要一个抽象工厂，里面有三个接口分别为生产轮胎、发动机、制动系统，抽象类
2. 需要三个抽象产品分别为轮胎、发动机、制动系统，抽象接口
3. 需要实现上面的三个抽象接口，定义出每个接口不通的对象，比如：普通轮胎和越野轮胎
4. 需要两个具体类继承自上面的抽象类，实现具体的工厂，比如：生产Q3的工厂和生产Q7的工厂
5. 在客户端new出对应的具体工厂并调用对应的生产方法

//1.抽象工厂
public abstract class CarFactory {
    /**
     * 生产轮胎
     * 
     * @return 轮胎
     * */
    public abstract ITire createTire();

    /**
     * 生产发动机
     * 
     * @return 发动机
     * */
    public abstract IEngine createEngine();

    /**
     * 生产制动系统
     * 
     * @return 制动系统
     * */
    public abstract IBrake createBrake();

}

//2.三个产品抽象接口
public interface ITire {
    /**
     * 轮胎 
     */
    void tire();
}

public interface IEngine {
    /**
     *发动机 
     */
    void engine();
}

public interface IBrake {
    /**
     *制动系统 
     */
    void brake();
}

//3.根据抽象接口定义不同的对象
public class NormalBrake implements IBrake{
    @Override
    public void brake() {
        System.out.println("普通制动");
    }
}
public class SeniorBrake implements IBrake{
    @Override
    public void brake() {
        System.out.println("高级制动");
    }
}  //后面的定义省略。。。。。。。。。。。。。

//4.实现具体的工厂类
public class Q3Factory extends CarFactory{

    @Override
    public ITire createTire() {
        return new NormalTire();
    }

    @Override
    public IEngine createEngine() {
        return new DomesticEngine();
    }

    @Override
    public IBrake createBrake() {
        return new NormalBrake();
    }
}

//5.客户端使用
public class Client {
    public static void main(String[] args) {
        //A车厂
        CarFactory factoryQ3 = new Q3Factory();
        factoryQ3.createTire().tire();
        factoryQ3.createEngine().engine();
        factoryQ3.createBrake().brake();
        System.out.println("---------------");
    }
}

//输出
普通轮胎
国产发动机
普通制动
------------------

区别

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

参考 《Android源码设计模式解析与实战》 — 何红辉 关爱民