Java设计模式-抽象工厂模式Abstract Factory

简介

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
主要解决：主要解决接口选择的问题。
何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
如何解决：在一个产品族里面，定义多个产品。
关键代码：在一个工厂里聚合多个同类产品。

抽象工厂模式

具体的UML图如下：

接口类computer

/**
 * 创建电脑的接口
 */
public interface Computer {
    //生产电脑
    void build();
    //装饰电脑
    void decorate();
    //销售电脑
    void sold();
}
1
2
3
4
5
6
7
8
9
10
11

抽象dell电脑工厂类

public abstract class AbstractDellFactory implements Computer{
    @Override
    public void build() {
        System.out.println("生产Dell电脑");
    }

    @Override
    public void decorate() {
        System.out.println("装饰Dell电脑");
    }

    @Override
    public void sold() {
        System.out.println("销售Dell电脑");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

抽象联想电脑工厂类

public abstract class AbstrctLenoFactory implements Computer{
    @Override
    public void build() {
        System.out.println("生产联想电脑");
    }

    @Override
    public void decorate() {
        System.out.println("装饰联想电脑");
    }

    @Override
    public void sold() {
        System.out.println("销售联想电脑");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

抽象华为电脑工厂类

public abstract class AbstractHuaweiFactory implements Computer{
    @Override
    public void build() {
        System.out.println("生产Huawei电脑");
    }

    @Override
    public void decorate() {
        System.out.println("装饰Huawei电脑");
    }

    @Override
    public void sold() {
        System.out.println("销售Huawei电脑");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Dell具体类

/**
 * dell
 */
public class DellInspironComputer extends AbstractDellFactory {

    public void build() {
        System.out.println("生产DellInspiron电脑");
    }
}
/**
 * dell G游戏本
 */
public class DellGComputer extends AbstractDellFactory {

    public void build() {
        System.out.println("生产DellG电脑");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

联想和华为实现类就不列举了。

电脑工厂类

/**
 * 电脑工厂类
 */
public interface ComputerFactory  {
    //制造dell电脑
    Computer createDellComputer();
    //制造华为电脑
    Computer createHuaweiComputer();
    //制造联想电脑
    Computer createLenoComputer();
}
1
2
3
4
5
6
7
8
9
10
11

抽象电脑工厂类

/**
 * 抽象工厂进行创建具体的类
 */
public abstract class AbstractComputerFactory implements ComputerFactory{
    /*
     * 使用抽象工厂进行创建一个具体的电脑实例
     */
    protected Computer createComputer(ComputerEnum computerEnum) {
        Computer computer = null;
        //如果传递进来不是一个Enum中具体的一个Element的话，则不处理
        if (!computerEnum.getComputername().equals("")) {
            try {
                //直接产生一个实例
                computer = (Computer)
                        Class.forName(computerEnum.getComputername()).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return computer;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

枚举类

/**
 * 枚举类进行列出所有具体的实例
 */
public enum ComputerEnum {

    DELLG("bulid.abstractfactory.DellGComputer"),
    DELLINSPIR("bulid.abstractfactory.DellInspironComputer"),
    HUAWEIPRO("bulid.abstractfactory.HuaweiProComputer"),
    HUAWEIMATEE("bulid.abstractfactory.HuaweiMateComputer"),
    LENOR7("bulid.abstractfactory.LenovoR7Computer"),
    LENOR9("bulid.abstractfactory.LenovoR9Computer");
    private String computername;

    ComputerEnum(String computername) {
        this.computername = computername;
    }
    public String getComputername() {
        return computername;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

java中的抽象类

总结

工厂模式符合面向对象设计的开闭原则，抽象工厂模式，还有一个非常大的有点，高内聚，低耦合。