抽象工厂模式

Android进阶之设计模式

抽象工厂模式

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

优点: 一个显著的优点就是分离接口与实现,客户端使用抽象工厂来创建需要的对象,而客户端根本就不知道具体实现是谁,客户端只是面向产品的接口编程而已,使其从具体的产品实现中解耦,同时基于接口与实现的分离,使抽象工厂方法模式在切换产品类时更加灵活,容易.

缺点: 类文件的陡增,不太容易扩展新的产品类.每当新增一个产品类就需要修改抽象工厂,那么所有具体工厂类均会被修改.

来看个例子理解一下:

要生产Q3,Q7同一个车系的车,但是他们的零部件差别却比较大.应用抽象工厂模式

public abstract class CarFactory {


    /**
     * 生产轮胎
     * */
    public abstract ITire createTire();

    /**
     * 生产发动机
     * */
    public abstract IEngine createEngine();


    /**
     * 生产刹车
     * */
    public abstract IBrake createBrake();
}

轮胎相关类:

public interface ITire {

    //轮胎
    void tire();
}

public class NormalTire implements ITire {
    @Override
    public void tire() {
        System.out.println("普通轮胎");
    }
}

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

发动机相关类:

public interface IEngine {

    //发动机
    void engine();
}

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


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

制动相关类:

public interface IBrake {

    //制动系统
    void brake();
}


public class NormalBrake implements IBrake {
    @Override
    public void brake() {
        System.out.println("普通制动");
    }
}


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

Q3 工厂类

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

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

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

Q7 工厂类

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

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

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

最后在Client 客户类中模拟

    public static void main(String[] args) {

        CarFactory carFactoryQ3 = new Q3Factory();
        carFactoryQ3.createBrake().brake();
        carFactoryQ3.createEngine().engine();
        carFactoryQ3.createTire().tire();
        System.out.println("------------------");
        CarFactory carFactoryQ7 = new Q7Factory();
        carFactoryQ7.createTire().tire();
        carFactoryQ7.createEngine().engine();
        carFactoryQ7.createBrake().brake();

    }
    

打印的结果是:

高级制动
进口发动机
普通轮胎
------------------
越野轮胎
进口发动机
高级制动

有没有发现,只是模拟了Q3 和Q7 的工厂,如果要在增加 Q5的工厂 对应的类是不是又要增加了, 抽象工厂有一个弊端,就是类的陡增,如果工厂类过多,势必导致类文件非常多,实际开发中要群恒一下了.

以上就是抽象工厂模式,品尝出其中的味道了吗?