【设计模式】抽象工厂模式

前言

Github：https://github.com/yihonglei/java-design-patterns

一 抽象工厂模式作用

提供一个创建一系列相关或相互依赖对象的接口，不需要指定具体的实现类。

二 应用场景

1）一个系统要独立于它的产品创建，组合和表示。

2）一个系统要由多个产品系列中的一个来配置。

3）提供一个产品类库，我们只让用户看到接口，而不想让用户看到具体的实现。

三 UML类图

抽象工厂方法模式静态类图：

 

四 参与对象

1）AbstractFactory

声明一个用于创建抽象产品对象的操作接口。

2）ConcreteFactory

实现创建产品的操作接口，编写具体的产品创建工厂。

3）AbstractProduct

声明一类产品的一个接口。

4）ConcreteProduct

一类产品的具体实现，将要被具体工厂创建的对象。

5）TestClient

测试调用使用AbstractFactory和AbstractProduct，使用者-->ConcreteFactory-->ConcreteProduct-->预期效果。

五 抽象工厂模式实例

实例类结构：

AbstractFactory

package com.jpeony.design.patterns.absfactory;

/**
 * 声明一个用于创建抽象产品对象的操作接口
 *
 * @author yihonglei
 */
public interface IAnimalFactory {

    ICat createCat();

    IDog createDog();

}

ConcreteFactory

package com.jpeony.design.patterns.absfactory;

/**
 * 创建'白色动物'的具体实现工厂
 *
 * @author yihonglei
 */
public class WhiteAnimalFactory implements IAnimalFactory {

    @Override
    public ICat createCat() {
        return new WhiteCat();
    }

    @Override
    public IDog createDog() {
        return new WhiteDog();
    }
}

package com.jpeony.design.patterns.absfactory;

/**
 * 创建'黑色动物'的具体实现工厂
 *
 * @author yihonglei
 */
public class BlackAnimalFactory implements IAnimalFactory {
    @Override
    public ICat createCat() {
        return new BlackCat();
    }

    @Override
    public IDog createDog() {
        return new BlackDog();
    }
}

AbstractProduct

package com.jpeony.design.patterns.absfactory;

/**
 * 猫类产品接口
 *
 * @author yihonglei
 */
public interface ICat {
    void eat();
}

package com.jpeony.design.patterns.absfactory;

/**
 * 狗类产品接口
 *
 * @author yihonglei
 */
public interface IDog {
    void eat();
}

ConcreteProduct

package com.jpeony.design.patterns.absfactory;

/**
 * 猫类产品具体实现--白猫
 *
 * @author yihonglei
 */
public class WhiteCat implements ICat {
    @Override
    public void eat() {
        System.out.println("白猫--吃东西");
    }
}

package com.jpeony.design.patterns.absfactory;

/**
 * 猫类产品具体实现--黑猫
 *
 * @author yihonglei
 */
public class BlackCat implements ICat {
    @Override
    public void eat() {
        System.out.println("黑猫--吃东西");
    }
}

package com.jpeony.design.patterns.absfactory;

/**
 * 狗类产品的具体实现--白狗
 *
 * @author yihonglei
 */
public class WhiteDog implements IDog {
    @Override
    public void eat() {
        System.out.println("白狗--吃东西");
    }
}

package com.jpeony.design.patterns.absfactory;

/**
 * 狗类产品的具体实现--黑狗
 *
 * @author yihonglei
 */
public class BlackDog implements IDog {
    @Override
    public void eat() {
        System.out.println("黑狗--吃东西");
    }
}

TestClient

package com.jpeony.design.patterns.absfactory;

/**
 * 抽象工厂测试类
 *
 * @author yihonglei
 */
public class AbstractFactoryTest {
    public static void main(String[] args) {
        // 白色动物
        IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();
        ICat whiteCat = whiteAnimalFactory.createCat();
        whiteCat.eat();
        IDog whiteDog = whiteAnimalFactory.createDog();
        whiteDog.eat();

        // 黑色动物
        IAnimalFactory blackAnimalFactory = new BlackAnimalFactory();
        ICat blackCat = blackAnimalFactory.createCat();
        blackCat.eat();
        IDog blackDog = blackAnimalFactory.createDog();
        blackDog.eat();

    }
}

运行结果