抽象工厂（Abstract Factory）模式——Java设计模式（三）

抽象工厂模式简介

抽象工厂模式（Abstract Factory Pattern）：围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

分类：创建型模式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

主要解决：主要解决接口选择的问题。

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

如何解决：在一个产品族里面，定义多个产品。

角色结构

抽象产品类：各种产品的抽象接口或抽象类；
具体产品类：抽象产品接口（抽象类）的实现类；
抽象工厂类：核心，定义用于生成抽象产品的接口；
具体工厂类：继承抽象工厂类，生成一组具体产品（注意是一组，这很重要）。

具体实现

步骤一：创建抽象产品类。

/**
 * 水果类接口
 * @author Administrator
 *
 */
public interface IFruit {
    void printName();
}

/**
 * 蔬类菜接口
 * @author Administrator
 *
 */
public interface IVeggie {
    void printName();
}

步骤二：创建具体产品类。

/**
 * 北方水果。水果类接口的实现类
 * @author Administrator
 *
 */
public class NorthernFruit implements IFruit {
    private String name;

    public NorthernFruit(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public void printName() {
        System.out.println(this.name);
    }
}

/**
 * 南方水果。水果类接口的实现类
 * @author Administrator
 *
 */
public class SouthernFruit implements IFruit {
    private String name;

    public SouthernFruit(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public void printName() {
        System.out.println(this.name);
    }
}

/**
 * 北方蔬菜。蔬菜类接口的实现类
 * @author Administrator
 *
 */
public class NorthernVeggie implements IVeggie {
    private String name;

    public NorthernVeggie(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public void printName() {
        System.out.println(this.name);
    }
}

/**
 * 南方蔬菜。蔬菜类接口的实现类
 * @author Administrator
 *
 */
public class SouthernVeggie implements IVeggie {
    private String name;

    public SouthernVeggie(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public void printName() {
        System.out.println(this.name);
    }
}

步骤三：创建抽象工厂类。

/**
 * 抽象工厂类。有两个具体的工厂，北方工厂和南方工厂
 * @author Administrator
 *
 */
public interface IAbstractFactory {
    public IFruit createFruit(String name);
    public IVeggie createVeggie(String name);
}

步骤四：创建具体工厂类。

/**
 * 北方工厂。抽象工厂的实现类
 * @author Administrator
 *
 */
public class NorthernFactory implements IAbstractFactory {

    @Override
    public IFruit createFruit(String name) {
        return new NorthernFruit(name);
    }

    @Override
    public IVeggie createVeggie(String name) {
        return new NorthernVeggie(name);
    }
}

/**
 * 南方工厂。抽象工厂的实现类
 * @author Administrator
 *
 */
public class SouthernFactory implements IAbstractFactory {

    @Override
    public IFruit createFruit(String name) {
        return new SouthernFruit(name);
    }

    @Override
    public IVeggie createVeggie(String name) {
        return new SouthernVeggie(name);
    }
}

步骤五：测试。

public class Main {
    public static void main(String[] args) {
        IAbstractFactory northernFactory = new NorthernFactory();
        IFruit fruit1 = northernFactory.createFruit("水果1");
        IVeggie veggie1 = northernFactory.createVeggie("蔬菜1");
        fruit1.printName();
        veggie1.printName();

        IAbstractFactory southernFactory = new SouthernFactory();
        IFruit fruit2 = southernFactory.createFruit("水果2");
        IVeggie veggie2 = southernFactory.createVeggie("蔬菜2");
        fruit2.printName();
        veggie2.printName();
    }
}

步骤六：验证输出。

水果1
蔬菜1
水果2
蔬菜2