抽象工厂模式

文章目录

• 抽象工厂模式
• • 案例
  • 代码
  • • 定义多个产品以及多个实现类
    • 定义抽象工厂以及多个的子类工厂
    • 客户端使用
    • 输出结果

抽象工厂模式

定义个抽象父类，抽象父类中定义一个抽象的创建对象的方法，然后由子类来创建一系列相关的产品或者依赖簇，不同于工厂方法适用于单个产品。

案例

代码

定义多个产品以及多个实现类

/**
 * 抽象产品：ProductA
 * 
 */
public interface ProductA {

    void use();
}



/**
 * 具体产品 ProductA1
 *
 * @author: Hui
 **/
public class ProductA1 implements ProductA{
    @Override
    public void use() {
        System.out.println("ProductA1 use ~~~ ");
    }
}


/**
 * 具体产品 ProductA2
 *
 * @author: Hui
 **/
public class ProductA2 implements ProductA{
    @Override
    public void use() {
        System.out.println("ProductA2 use ~~ ");
    }
}

/**
 * 抽象产品：ProductB
 * 
 */
public interface ProductB {

    void use();
}


/**
 * 具体产品 ProductB1
 *
 * @author: Hui
 **/
public class ProductB1 implements ProductB{
    @Override
    public void use() {
        System.out.println("ProductB1 use ~~~ ");
    }
}

/**
 * 具体产品 ProductB2
 *
 * @author: Hui
 **/
public class ProductB2 implements ProductB{
    @Override
    public void use() {
        System.out.println("ProductB2 use ~~~ ");
    }
}

定义抽象工厂以及多个的子类工厂

/**
 *  抽象工厂
 *
 * @author: Hui
 **/
public abstract class AbsFactory {

    public abstract ProductA createProductA();
    public abstract ProductB createProductB();

}

/**
 * 具体工厂 1
 *
 * @author: Hui
 **/
public class ConcreteFactory1 extends AbsFactory{
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

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


/**
 * 具体工厂 2
 *
 * @author: Hui
 **/
public class ConcreteFactory2 extends AbsFactory{
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

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

客户端使用

/**
 * 客户端
 *
 * @author: Hui
 **/
public class Client {

    public static void main(String[] args) {
        AbsFactory factory = new ConcreteFactory1();
        System.out.println("产品1 ~~~ ");
        factory.createProductA().use();
        factory.createProductB().use();

        factory = new ConcreteFactory2();
        System.out.println("产品2 ~~~ ");
        factory.createProductA().use();
        factory.createProductB().use();


    }
}

输出结果