抽象工厂模式

工厂模式（二） 抽象工厂模式

定义 为创建一组相关或者是相互依赖的对象提供一个接口。而不需要指定他们的具体类。

抽象工厂模式的类繁多分为4类：
（1）抽象工厂角色  他声明了一组用于创建一种产品的方法，每一个方法对应一种产品。
（2） 具体工厂角色  他实现了在抽象工厂中定义的创建产品的方法，生成一组具体产品这些产品构成一个产品种类
（3） 抽象产品角色  他为每种产品声明接口
（4） 具体产品角色  他定义具体工厂生产的具体产品对象实现抽象产品中声明的业务方法


下面来一个抽象工厂模式的简单实现

//先把抽象产品类写出来

public interface IBrake {
    void brake();
}   

public interface IEngine {
    void engine();
}

public interface ITire {
    void tire();
}

//抽象工厂类

public abstract class CarFactory {

    public abstract ITire creatTire();

    public abstract IEngine createEngine();

    public abstract IBrake createBrake();
}

//具体产品类 有点多

public class SUVTire implements ITire {
    @Override
    public void tire() {
        System.out.println("我是SUV轮胎");
    }
}

public class NormalTire implements ITire {
    @Override
    public void tire() {
        System.out.println("我是正常轮胎");
    }
}

public class SeniorBrake implements IBrake {
    @Override
    public void brake() {
        System.out.println("高级制动");
    }
}

public class NormalBrake implements IBrake {
    @Override
    public void brake() {
        System.out.println("我是普通刹车系统");
    }
}

public class DomestEngine implements IEngine {
    @Override
    public void engine() {
        System.out.println("我是国产发动机");
    }
}

public class ImportEngine implements IEngine {
@Override
    public void engine() {
        System.out.println("我是进口发动机");
    }
}

//Q3工厂类

public class Q3Factory extends CarFactory {
    @Override
    public ITire creatTire() {
        return new NormalTire();
    }

    @Override
    public IEngine createEngine() {
        return new DomestEngine();
    }

    @Override
    public IBrake createBrake() {
        return new NormalBrake();
    }
}   

//Q7工厂类

public class Q7Factory extends CarFactory {
    @Override
    public ITire creatTire() {
        return new SUVTire();
    }

    @Override
    public IEngine createEngine() {
        return new ImportEngine();
    }

    @Override
    public IBrake createBrake() {
        return new SeniorBrake();
    }
}

//客户端实现

public class Client {
    public static void main(String[] args){
        CarFactory carQ3 = new Q3Factory();
        carQ3.createBrake().brake();
        carQ3.createEngine().engine();
        carQ3.creatTire().tire();

        CarFactory carQ7 = new Q7Factory();
        carQ7.createBrake().brake();
        carQ7.createEngine().engine();
        carQ7.creatTire().tire();
    }
}

代码中可以看出来 Q3和Q7使用的零件是不相同的。
我们只是模拟了Q3Q7的生产工厂要是再加一个Q5呢 那么我们对应的轮胎  发动机  刹车系统又要增加  这里
可以看出抽象工厂模式的一个弊端，就是类的陡增，如果工厂类过多 势必会导致文件非常多  多以在开发中一定要权衡利弊使用

总结一下  
抽象工厂模式的优点：
    一个显著的优点是分离接口与实现。客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体实现是谁
    客户端只是面向产品的接口编程而已，使其从具体的产品实现中解耦。同时基于接口与实现的分离，使用抽象工厂模式在切换
    产品类时更加灵活、容易
抽象工厂模式的缺点：
    上面我们也说了，一是对类文件的爆炸性增加，二是不太容易扩展新的产品类，因为我们增加一个产品类就需要修改抽象工厂
    那么所有的具体工厂都要被修改。