设计模式-抽象工厂模式

定义:为创建一组相关或者是相互依赖的对象提供一个接口,而不需要指定它们的具体类。
使用场景:一个对象族有相同的约束时可以使用抽象工厂模式。举个例子,Android、iOS、Window Phone下都有短信软件和拨号软件,两者都属于Software软件的范畴,但是它们所在的操作系统平台不一样,即便是同一家公司出品的软件,其代码实现逻辑也是不同的,这时候就可以考虑使用抽象工厂模式来生产Android、iOS、Window phone下的短信软件和拨号软件。


UML类图




主要分为4类
1、抽象工厂角色,声明了一组用于创建一种产品的方法,每一个方法对应一种产品。
2、具体工厂角色,实现了在抽象工厂中定义的创建产品的方法,生成一组具体产品,这些产品构成了一个产品种类,每一个产品都位于某个产品等级结构中,如上图的ConcreteFactory1和ConcreteFactory2。
3、抽象产品角色,它为每种产品声明接口,比如上图的AbstractProductA和AbstractProductB。
4、具体产品角色,它定义具体工厂生产具体的产品对象,实现抽象产品接口中声明的业务方法。


简单实现
在工厂模式中的例子,Q3 、Q7后来经过改装优化后,无法在一条生产线上继续进行生产,他们之间的差别现在比较大。
主要区别是 发动机:Q3是国产的 Q7是原装进口的;轮胎:Q3是普通的,Q7是全尺寸越野轮胎;制动系统Q3是普通制动,Q7是性能较好的制动系统。Q3、Q7对应的是一系列车,而发动机、轮胎、制动系统对应的是一系列零部件。
这时候将抽象工厂模式应用到其中,首先,汽车工厂要生产轮胎、发动机、制动系统这3种部件。



抽象工厂类
/**
 * 抽象工厂
 */
public abstract class CarFactory {

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

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


    /**
     * 生产制动系统
     *
     * @return
     */
    public abstract IBrake createBrake();
}

具体工厂类

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

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

    @Override
    public IBrake createBrake() {
        return new NormalBrake();
    }
}
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();
    }
}

抽象产品类
/**
 * 抽象轮胎
 */
public interface ITire {

    void tire();
}
/**
 * 抽象发动机
 */
public interface IEngine {

    void engine();
}
/**
 * 抽象制动系统
 */
public interface IBrake {

    void brake();
}

具体产品类

轮胎:
/**
 * 具体 普通轮胎
 */
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 class DomesticEngine implements IEngine {
    @Override
    public void engine() {
        System.out.println("国产发动机");
    }
}
/**
 * 具体 进口发动机
 */
public class ImportEngine implements IEngine {
    @Override
    public void engine() {
        System.out.println("进口发动机");
    }
}

制动系统:
/**
 * 具体 普通制动系统
 */
public class NormalBrake implements IBrake {
    @Override
    public void brake() {
        System.out.println("普通制动系统");
    }
}
/**
 * 具体 高级制动系统
 */
public class SeniorBrake implements IBrake {

    @Override
    public void brake() {
        System.out.println("高级制动系统");
    }
}


客户端调用:
public class Client {
    public static void main(String[] args) {
        //创建一个生产Q3的工厂
        CarFactory factoryQ3 = new Q3Factory();
        factoryQ3.createTire().tire();
        factoryQ3.createEngine().engine();
        factoryQ3.createBrake().brake();

        //创建一个生产Q7的工厂
        CarFactory factoryQ7 = new Q7Factory();
        factoryQ7.createTire().tire();
        factoryQ7.createEngine().engine();
        factoryQ7.createBrake().brake();

    }
}

如果此时Q5系列车又进行了改进,那么又得创建Q5车型的对应的工厂,方便了扩展,但同时有个弊端也体现出来,那就是工厂类过多,导致类文件非常多,实际开发中权衡利弊吧。


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




  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值