设计模式学习笔记------抽象工厂模式

　　　　　　　　　　　　　　抽象工厂模式

一、实例代码

/**
 * 抽象产品A的接口
 * @author abc
 *
 */
public interface AbstractProductA {
    //定义抽象产品A相关的操作
}

/**
 * 抽象产品B的接口
 * @author abc
 *
 */
public interface AbstractProductB {
    //定义抽象产品B相关的操作
}

/**
 * 产品A的具体实现
 */
public class ProductA1 implements AbstractProductA {
    //实现产品A的接口中定义的操作
}

/**
 * 产品A的具体实现
 */
public class ProductA2 implements AbstractProductA {
    //实现产品A的接口中定义的操作
}

/**
 * 产品B的具体实现
 */
public class ProductB1 implements AbstractProductB {
    //实现产品B的接口中定义的操作
}

/**
 * 产品A的具体实现
 */
public class ProductB2 implements AbstractProductB {
    //实现产品B的接口中定义的操作
}
    
/**
 * 抽象工厂的接口，声明创建抽象产品对象的操作
 * @author abc
 *
 */
public interface AbstractFactory {
    /**
     * 实例方法，创建抽象产品A的对象
     * @return 抽象产品A的对象
     */
    public AbstractProductA createProductA();
    
    /**
     * 实例方法，创建抽象产品B的对象
     * @return 抽象产品B的对象
     */
    public AbstractProductB createProductB();
}

/**
 * 具体的工厂实现对象，实现创建具体的产品对象的操作
 */
public class ConcreateFactory1 implements AbstractFactory {

    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

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

/**
 * 具体的工厂实现对象，实现创建具体的产品对象的操作
 */
public class ConcreteFactory2 implements AbstractFactory {

    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

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

public class Client {
    public static void main(String[] args) {
        //创建抽象工厂对象
        AbstractFactory af = new ConcreateFactory1();
        //通过抽象工厂来获取一系列的对象，如产品A和产品B
        af.createProductA();
        af.createProductB()
    }
}