java设计模式之抽象工厂方法

        抽象工厂模式相对与工厂方法模式来说，每个具体工厂可以生产一族产品（即多种产品）；而工厂模式方法是具体工厂生产相应的具体产品，只能生产一种产品。

       当产品族中只有一种产品的时候抽象工厂模式退化成工厂方法模式

       为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类

      区别在于产品，如果产品单一，最适合使用工厂模式，但是如果有多个业务品种、业务分类时，通过抽象工厂模式生产需要的对象是一种非常好的解决方式。

     再通俗深化理解下：工厂模式针对的是一个产品等级结构，抽象工厂模式针对的是面向多个产品等级结构的。

   接下来，我们通过例子来了解下：

//抽象工厂：AbstractFactory接口
//抽象工厂，定义了生产族产品的方法；
interface AbstractFactory {
    public abstract ProductA factoryA();
    public abstract ProductB factoryB();
}

//抽象产品：ProductA接口
抽象产品B定义了产品的公共方法，产品A和B属于一个产品族
interface ProductA{
    public void method1();
    public void method2();
}

抽象产品B定义了产品的公共方法，产品A和B属于一个产品族
interface ProductB {
    public void method1();
    public void method2();
}

//具体产品（等级为1的A产品）：ConcreteProductA1类
class ConcreateProductA1 implements ProductA{

    @Override
    public void method1() {
        System.out.println("等级为1的产品A的method1()");
    }

    @Override
    public void method2() {
        System.out.println("等级为1的产品A的method2()");
    }
}

//具体产品（等级为2的A产品）：ConcreteProductA2类
class ConcreateProductA2 implements ProductA{

    @Override
    public void method1() {
        System.out.println("等级为2的产品A的method1()");
    }

    @Override
    public void method2() {
        System.out.println("等级为2的产品A的method2()");
    }
}

//具体产品（等级为1的B产品）：ConcreteProductB1类
class ConcreateProductB1 implements ProductB{

    @Override
    public void method1() {
        System.out.println("等级为1的产品B的method1()");
    }

    @Override
    public void method2() {
        System.out.println("等级为1的产品B的method2()");
    }
}

//具体产品（等级为2的B产品）：ConcreteProductB2类
class ConcreateProductB2 implements ProductB{

    @Override
    public void method1() {
        System.out.println("等级为2的产品B的method1()");
    }

    @Override
    public void method2() {
        System.out.println("等级为2的产品B的method2()");
    }
}

//具体工厂（生产等级为1的族产品）：ConcreteFactory1类
//ConcreateFactory1是用来生产等级为1的产品A，B；
class ConcreateFactory1 implements AbstractFactory{

    @Override
    public ProductA factoryA() {
        return new ConcreateProductA1();
    }

    @Override
    public ProductB factoryB() {
        return new ConcreateProductB1();
    }
}
//具体工厂（生产等级为2的族产品）：ConcreteFactory2类
class ConcreteFactory2 implements AbstractFactory{

    @Override
    public ProductA factoryA() {
        return new ConcreateProductA2();
    }

    @Override
    public ProductB factoryB() {
        return new ConcreateProductB2();
    }
}

public class AbstractFactoryDemo {
    public static void main(String[] args){
        ProductA productA=new ConcreateFactory1().factoryA();
        productA.method1();
        productA.method2();
        ProductB productA1=new ConcreateFactory1().factoryB();
        productA1.method1();
        productA1.method2();
    }
}

     抽象工厂：如果产品单一则适合使用的是简单工厂，但是当产品比较多的时候，则使用的是抽象工厂，生产产品族，这是先定义一个接口，这个接口中定义的是生产每个产品的类，所以我们也得定义生产产品的抽象类，定义一些公共方法。然后可以定义具体产品，这个类实现所对应的产品抽象类。然后定义具体的工厂用于生产具体的产品。这个类实现工厂接口