4、设计模式之抽象工厂模式

定义

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

抽象工厂模式与工厂方法模式最大的区别：抽象工厂中每个工厂可以创建多种类的产品；而工厂方法每个工厂只能创建一类

先看一个需求

要求生产两类产品蛋糕和披萨，每类产品有两种口味：蛋糕有奶油蛋糕和水果蛋糕，披萨有奶酪披萨和火腿披萨。
如果用工厂方法模式实现的话，由于工厂方法每个工厂只能创建一个类，那么久需要创建四个工厂，不利于扩展。今天就用一种新的模式去实现：抽象工厂模式。

步骤

1. 创建抽象产品类
2. 创建具体抽象产品类，继承抽象产品类
3. 创建具体产品类，继承具体抽象产品类
4. 创建抽象工厂类
5. 创建具体工厂类,继承抽象工厂类

思路

工厂A生产奶酪披萨和奶油蛋糕;工厂B生产火腿披萨和水果蛋糕

代码实现

抽象产品类

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

具体抽象产品类，继承抽象产品类

public abstract class Cake extends AbstractProduct{
    
    
    @Override
    public abstract void make();
}

public abstract class Pizza extends AbstractProduct {
    
    
    @Override
    public abstract void make();
}

具体产品类，继承具体抽象产品类

//奶酪披萨
public class CheesePizza extends Pizza {
    
    
    private String factoryName;
    public CheesePizza(String factoryName){
    
    
        this.factoryName=factoryName;
    }


    @Override
    public void make() {
    
    
        System.out.println(factoryName+"：制作【奶酪披萨】");
    }
}

//奶油蛋糕
public class CreamCake extends Cake {
    
    
    private String factoryName;
    public CreamCake(String factoryName) {
    
    
        this.factoryName = factoryName;
    }

    @Override
    public void make() {
    
    
        System.out.println(factoryName+"：制作【奶油蛋糕】");
    }
}

//水果蛋糕
public class FruitCake extends Cake {
    
    
    private String factoryName;
    public FruitCake(String factoryName) {
    
    
        this.factoryName = factoryName;
    }
    @Override
    public void make() {
    
    
        System.out.println(factoryName+"：制作【水果蛋糕】");
    }
}

//火腿披萨
public class HamPizza extends Pizza {
    
    
    private String factoryName;
    public HamPizza(String factoryName) {
    
    
        this.factoryName = factoryName;
    }
    @Override
    public void make() {
    
    
        System.out.println(factoryName+"：制作【火腿披萨】");
    }
}

抽象工厂类

public abstract class Factory {
    
    
    //生产披萨
    public abstract Pizza createPizza();
    //生产蛋糕
    public abstract Cake createCake();
}

具体工厂类,继承抽象工厂类

//工厂A生产奶酪披萨和奶油蛋糕
public class FactoryA extends Factory {
    
    
    @Override
    public Pizza createPizza() {
    
    
        return new CheesePizza("FactoryA");
    }

    @Override
    public Cake createCake() {
    
    
        return new CreamCake("FactoryA");
    }
}

//工厂B生产火腿披萨和水果蛋糕
public class FactoryB extends Factory{
    
    
    @Override
    public Pizza createPizza() {
    
    
        return new HamPizza("FactoryB");
    }

    @Override
    public Cake createCake() {
    
    
        return new FruitCake("FactoryB");
    }
}

主函数

public class Story {
    
    
    public static void main(String[] args) {
    
    
        FactoryA factoryA = new FactoryA();
        factoryA.createCake().make();
        factoryA.createPizza().make();

        FactoryB factoryB = new FactoryB();
        factoryB.createCake().make();
        factoryB.createPizza().make();
    }
}

总结：当新增产品种类时，只需新增对应的产品类和工厂类即可，降低了耦合度。但是当新增某类产品的口味时就需要修改工厂代码了。对于新增产品种类符合开闭原则，对于新增口味不符合开闭原则