Java学习：设计模式(抽象工厂)

Java学习:工厂模式(抽象工厂)

1. 定义

抽象工厂模式，即Abstract Factory Pattern，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。

2. 主要作用

允许使用抽象的接口来创建一组相关产品，而不需要知道或关心实际生产出的具体产品是什么，这样就可以从具体产品中被解耦。

3. 基本组成

同样从UML类图开始分析:

AbstractProduct: 抽象产品族(抽象产品的父类),描述抽象产品的公共接口;

**Product:**抽象产品(具体产品的父类),描述具体产品的公共接口;

**Concrete Product:**具体产品(抽象产品的子类),描述生产的具体产品

**AbstractFactory:**抽象工厂(具体工厂的父类),描述具体工厂的公共接口

**Factory:**具体工厂(抽象工厂的子类),实现工厂方法创建产品的实例

4. 实现步骤

• 创建抽象产品族类;
• 创建抽象工厂类;
• 创建抽象产品类 (继承抽象产品族类);
• 创建具体产品类(继承抽象产品类);
• 创建具体工厂类(继承抽象工厂类);
• 通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例.

5. 实例

假如我有两个游戏工厂，A厂做线上游戏，B厂做单机游戏，现在因为没资金建新厂，客户要求A厂同时也做单机游戏，B厂同时也做线上游戏

• 第一步，创建抽象产品族类

public abstract class AbstractProduct {
    public abstract void Game();
}

• 第二步，创建抽象工厂类

public abstract class AbstractFactory {
    public abstract AbstractOnlineGame OnlineGameFactory();
    public abstract AbstractSingerPlayerGame SingerPlayerGameFactory();
}

• 第三步，创建抽象产品类 (继承抽象产品族类)

// 线上游戏
public abstract class AbstractOnlineGame extends  AbstractProduct {
    public abstract void Game();
}

// 单机游戏
public abstract class AbstractSingerPlayerGame extends AbstractProduct {
    public abstract void Game();
}

• 第四步，创建具体产品类(继承抽象产品类)

// A厂游戏
public class OnlineGameA extends AbstractOnlineGame {
    @Override
    public void Game() {
        System.out.println("线上游戏A发行！");
    }
}

public class SingerPlayerGameA extends AbstractSingerPlayerGame {
    @Override
    public void Game() {
        System.out.println("单机游戏A发行！");
    }
}

// B厂游戏
public class OnlineGameB extends AbstractOnlineGame {
    @Override
    public void Game() {
        System.out.println("线上游戏B发行！");
    }
}

public class SingerPlayerGameB extends AbstractSingerPlayerGame {
    @Override
    public void Game() {
        System.out.println("单机游戏B发行！");
    }
}

• 第五步，创建具体工厂类(继承抽象工厂类)

// A厂
public class FactoryA extends AbstractFactory {
    @Override
    public AbstractOnlineGame OnlineGameFactory() {
        return new OnlineGameA();
    }

    @Override
    public AbstractSingerPlayerGame SingerPlayerGameFactory() {
        return new SingerPlayerGameA();
    }
}

// B厂
public class FactoryB extends AbstractFactory {
    @Override
    public AbstractOnlineGame OnlineGameFactory() {
        return new OnlineGameB();
    }

    @Override
    public AbstractSingerPlayerGame SingerPlayerGameFactory() {
        return new SingerPlayerGameB();
    }
}

• 通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例.(测试类)

public class TestAbstractFactory {
    public static void main(String[] args) {
        FactoryA A = new FactoryA();
        A.OnlineGameFactory().Game();
        A.SingerPlayerGameFactory().Game();

        FactoryB B = new FactoryB();
        B.OnlineGameFactory().Game();
        B.SingerPlayerGameFactory().Game();
    }
}

结果如下:

小结

• 抽象工厂模式将具体产品的创建延迟到具体工厂的子类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而使系统耦合度低，这样更有利于后期的维护和扩展；
• 每个具体工厂类只负责创建对应的产品;
• 对于新的产品族符合开-闭原则；对于新的产品种类不符合开-闭原则.