精华内容
下载资源
问答
  • 抽象工厂模式定义
    2022-03-13 16:36:04

    1. 抽象工厂模式的动机与定义

    1.1 抽象工厂模式的动机

    在工厂方法模式中具体的工厂负责生产具体的产品,每一个产品对应一个工厂,工厂方法也具有唯一性,一般情况下,一个具体的工厂只有一个工厂方法或一组重载的工厂方法。但是有时候我们并不希望一个工厂只生产一种单一产品,比如电视设备工厂,希望它能够生产电视机、电冰箱、空调等设备,而不是生产某种类型的电器。

    1.2 抽象工厂模式的定义

    抽象工厂模式定义:提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。抽象工厂模式又称Kit模式,属于对象创建型模式

    2. 抽象工厂模式结构与分析

    2.1 抽象工厂模式结构

    抽象工厂模式结构图

    • AbstractFactory(抽象工厂)

    抽象工厂用于声明生产抽象产品的方法,在一个抽象成工厂中可以定义一组方法,每一个方法对应一个产品等级结构

    • ConcreateFactory(具体工厂)

    具体工厂实现了抽象工厂声明的生成抽象产品的方法,生产一组具体产品,这些产品构成了一个产品族。每一个产品都位于某一个产品等级结构中

    • AbstractProduct(抽象产品)

    抽象产品为每种产品声明接口,在抽象产品中定义了产品的抽象业务方法

    • ConcreateProduct(具体产品)

    具体产品定义具体工厂生产的具体产品对象,实现抽象产品接口中定义的业务方法

    2.2 抽象工厂模式分析

    抽象工厂模式最早的应用是用来创建在不同操作系统的图形环境下都能够运行的系统例如Windows与Linux系统下都有图形环境的构件,在每一个操作系统下,都有一个图形构件组成的构件家族,可以通过一个抽象角色给出功能定义,而由具体子类给出不同操作系统下的实现。

    更多相关内容
  • 本文实例讲述了JavaScript设计模式之工厂模式和抽象工厂模式定义与用法。分享给大家供大家参考,具体如下: 1、工厂模式: 虽然Object构造函数和对象字面量都可以用来创建单个对象,但这个方式有个明显的缺点:使用...
  • 主要介绍了Java使用抽象工厂模式实现的肯德基消费案例,较为详细的分析了抽象工厂模式定义、原理并结合实例形式分析了Java使用抽象工厂模式实现肯德基消费案例的步骤与相关操作技巧,需要的朋友可以参考下
  • 抽象工厂模式(通俗易懂)

    万次阅读 多人点赞 2020-11-25 00:09:11
    抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 理解产品族和产品等级 产品族...

    抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

    理解产品族和产品等级

    产品族:一个品牌下面的所有产品;例如华为下面的手机,路由器,电脑 称为华为的产品族;

    产品等级:多个品牌下面的同种产品;例如华为和小米下面的手 称为一个产品等级;

    image20200826105220926.png

    类图分析:

    以下图为例,有手机和路由器两种产品,有华为和小米两种品牌,两种品牌都可以生产手机和路由器;

    1. 有手机和路由器两种产品,定义两个接口;
    2. 小米和华为都可以生产这两种产品,所以有4个实现类;
    3. 现在需要创建华为和小米的工厂类,先将工厂类进行抽象,里面有创建两个产品的方法,返回的是产品的接口类;
    4. 创建华为和小米的工厂实现类,继承工厂类接口,实现创建各自产品的方法;
    5. 客户端调用时,直接用工厂接口类创建需要的工厂,拿到对应的产品;

    在这里插入图片描述

    代码实现

    1. 手机产品接口和路由器产品接口
    //手机产品接口
    public interface IPhoneProduct {
        //开机
        void start();
        //关机
        void shutdown();
        //打电话
        void callup();
        //发邮件
        void sendSMS();
    }
    
    //路由器产品接口
    public interface IRouterProduct {
        //开机
        void start();
        //关机
        void shutdown();
        //打开wifi
        void openwifi();
        //设置
        void setting();
    }
    
    
    1. 华为和小米的产品的4个实现类
    //华为手机实现类
    public class HuaweiPhone implements IPhoneProduct {
    
        @Override
        public void start() {
    	System.out.println("开启华为手机");
        }
    
        @Override
        public void shutdown() {
    	System.out.println("关闭华为手机");
        }
    
        @Override
        public void callup() {
    	System.out.println("华为手机打电话");
        }
    
        @Override
        public void sendSMS() {
    	System.out.println("华为手机发邮件");
        }
    }
    
    //华为路由器实现类
    public class HuaweiRouter implements IRouterProduct {
    
        @Override
        public void start() {
            System.out.println("开启华为路由器");
        }
    
        @Override
        public void shutdown() {
    	System.out.println("关闭华为路由器");
        }
    
        @Override
            public void openwifi() {
    	System.out.println("打开华为wifi");
        }
    
        @Override
        public void setting() {
    	System.out.println("设置华为路由器");
        }
    }
    
    //小米手机实现类
    public class XiaomiPhone implements IPhoneProduct {
    
        @Override
        public void start() {
    	System.out.println("开启小米手机");
        }
    
        @Override
        public void shutdown() {
    	System.out.println("关闭小米手机");
        }
    
        @Override
        public void callup() {
    	System.out.println("小米手机打电话");
        }
    
        @Override
        public void sendSMS() {
    	System.out.println("小米手机发邮件");
        }
    }
    
    //小米路由器实现类
    public class XiaomiRouter implements IRouterProduct {
    
        @Override
        public void start() {
    	System.out.println("开启小米路由器");
        }
    
        @Override
        public void shutdown() {
    	System.out.println("关闭小米路由器");
        }
    
        @Override
        public void openwifi() {
    	System.out.println("打开小米wifi");
        }
    
        @Override
        public void setting() {
    	System.out.println("设置小米路由器");
        }
    }
    
    1. 工厂接口类;
    //产品工厂接口
    public interface IProductFactory {
    
        //生产手机
        IPhoneProduct phoneProduct();
    
        //生成路由器
        IRouterProduct routerProduct();
    }
    
    1. 华为和小米工厂实现类,继承工厂接口
    //华为工厂实现类
    public class HuaweiFactory implements IProductFactory {
    
        @Override
        public IPhoneProduct phoneProduct() {
    	return new HuaweiPhone();
        }
    
        @Override
        public IRouterProduct routerProduct() {
    	return new HuaweiRouter();
        }
    }
    
    //小米工厂实现类
    public class XiaomiFactory implements IProductFactory {
    
        @Override
        public IPhoneProduct phoneProduct() {
        	return new XiaomiPhone();
        }
    
        @Override
        public IRouterProduct routerProduct() {
    	return new XiaomiRouter();
        }
    }
    
    1. 客户端,通过 IProductFactory 创建各自的工厂,通过工厂拿到对应的产品
    public class Client {
        
        public static void main(String[] args) {
            
    	System.out.println("============小米产品============");
    	//创建小米工厂
    	IProductFactory xiaomiFactory = new XiaomiFactory();
    
    	//生产小米手机
    	IPhoneProduct xiaomiPhone = xiaomiFactory.phoneProduct();
    	xiaomiPhone.start();
    	xiaomiPhone.sendSMS();
    
    	//生产小米路由器
    	IRouterProduct xiaomiRouter = xiaomiFactory.routerProduct();
    	xiaomiRouter.openwifi();
    	xiaomiRouter.setting();
    
    	System.out.println("============华为产品============");
    	//创建华为工厂
    	IProductFactory huaweiFactory = new HuaweiFactory();
    
    	//生产华为手机
    	IPhoneProduct huaweiPhone = huaweiFactory.phoneProduct();
    	huaweiPhone.start();
    	huaweiPhone.sendSMS();
    
    	//生产华为路由器
    	IRouterProduct huaweiRouter = huaweiFactory.routerProduct();
    	huaweiRouter.openwifi();
    	huaweiRouter.setting();
        }
    }
    

    抽象工厂模式的实现就是这样,还记得前面讲的产品族和产品等级的概念吗,如果新增一个产品族或产品等级会怎样?

    拓展一个产品族

    我们会发现,拓展一个产品族是非常困难的,例如产品族中新增一个笔记本电脑,也就是说华为和小米现在可以生产电脑了,如下图所示(黄色字体为新增一个产品族需要做的事),对顶层的工厂接口类也要修改,这是非常麻烦的;

    在这里插入图片描述

    拓展一个产品等级

    如果扩展一个产品等级,例如新增一个手机,也就是说新增一个品牌来生产手机,如下图所示(黄色字体为新增一个产品等级需要做的事),新增一个产品等级不用修改原来的代码,符合OCP原则,这是非常舒服的;

    在这里插入图片描述

    所以抽象工厂模式的优缺点

    优点:一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象(将一个系列的产品统一一起创建);

    缺点:

    • 产品族扩展非常困难,要增加一个系列的某一产品,既要修改工厂抽象类里加代码,又修改具体的实现类里面加代码;
    • 增加了系统的抽象性和理解难度;

    适用场景

    • 一系列相关产品对象(属于同一产品族)一起创建时需要大量的重复代码;
    • 提供一个产品类的库,所有的产品以同样的接口出现,从而使得客户端不依赖于具体的实现;

    抽象工厂模式符合依赖抽象原则

    • 创建对象实例时,不要直接 new一个对象, 而是把创建对象的动作放在一个工厂的方法中;
    • 不要让类继承具体类,而是继承抽象类或者是实现接口;
    • 不要覆盖基类中已经实现的方法;
    展开全文
  • 主要介绍了Java设计模式之抽象工厂模式,结合实例形式分析了抽象工厂模式的概念、功能、定义与使用方法,需要的朋友可以参考下
  • 主要介绍了Java设计模式编程中的工厂方法模式和抽象工厂模式,设计模式的建立有利于团队协作时代码的共同维护,需要的朋友可以参考下
  • Java实现抽象工厂模式

    千次阅读 2022-02-24 23:23:54
    抽象工厂模式提供一个创建一系列相关或者相互依赖对象的接口。

    什么是抽象工厂模式

    定义:抽象工厂模式提供一个创建一系列相关或者相互依赖对象的接口。

    对比 简单工厂、工厂方法、抽象工厂

    模式优点缺点
    简单工厂将创建对象的逻辑封装在一个静态方法中,外部人员不需要关注内部实现逻辑创建对象的逻辑存在一个静态方法中不方便扩展、不能被继承、违背开闭原则
    工厂方法通过提供多个工厂类来创建不同对象,解决了简单工厂模式中职责过重问题,方便扩展、可以被继承、符合开闭原则对象太多的时候就会创建很多工厂类
    抽象工厂通过提供多个工厂类来创建同一产品族对象,方便扩展、可以被继承、符合开闭原则,并且减少了工厂类数量实现起来比较复杂,不如简单工厂模式使用简单,产品族需要划分

    下面通过一个例子来实现抽象工厂模式。

    需求描述

    宝马品牌车有宝马X1、X3、X5等系列,每个系列车又配有各自的系列车标X1、X3、X5(车标只能由自己工厂创建),这三个系列车和车标分别由三个工厂创建,下面通过抽象工厂模式来实现该例子。

    UML图
    在这里插入图片描述IBMWFactory接口定义了createCar(生产车)和createLogo(生产车标)方法,X1Factory、X3Factory、X5Factory造车工厂实现该接口,同时提供生产车型和车标的方法。

    X1Car、X3Car、X5Car都实现实体BMWCar接口,并实现run方法。

    代码实现

    创建系列车类

    创建IBMWCar接口,并定义run方法。

    public interface IBMWCar {
        void run();
    }
    

    创建宝马X1车类,并实现IBMWCar接口,实现run方法。

    public class X1Car implements IBMWCar {
        @Override
        public void run() {
            System.out.println("X1Car run");
        }
    }
    

    创建宝马X3车类,并实现IBMWCar接口,实现run方法。

    public class X3Car implements IBMWCar {
        @Override
        public void run() {
            System.out.println("X3Car run");
        }
    }
    

    创建宝马X5类,并实现IBMWCar接口,实现run方法。

    public class X5Car implements IBMWCar {
        @Override
        public void run() {
            System.out.println("X5Car run");
        }
    }
    

    创建Logo车标类

    创建ILogo接口,并定义create方法。

    public interface ILogo {
        void create();
    }
    

    创建宝马X1Logo车标类,并实现ILogo接口,实现create方法。

    public class X1Logo implements ILogo {
        @Override
        public void create() {
            System.out.println("创建X1Logo");
        }
    }
    

    创建宝马X3Logo车标类,并实现ILogo接口,实现create方法。

    public class X3Logo implements ILogo {
        @Override
        public void create() {
            System.out.println("创建X3Logo");
        }
    }
    

    创建宝马X5Logo车标类,并实现ILogo接口,实现create方法。

    public class X5Logo implements ILogo {
        @Override
        public void create() {
            System.out.println("创建X5Logo");
        }
    }
    

    创建工厂接口和工厂子类

    创建工厂接口,定义createCar方法。

    public interface IBMWFactory {
        public IBMWCar createCar();
    }
    

    创建X1工厂类,并实现工厂接口,实现createCar方法,创建X1Car对象,实现createLogo方法创建X1车标对象。

    public class X1Factory implements IBMWFactory {
    
        @Override
        public IBMWCar createCar() {
            return new X1Car();
        }
    
        @Override
        public ILogo createLogo() {
            return new X1Logo();
        }
    }
    

    创建X3工厂类,并实现工厂接口,实现createCar方法,创建X3Car对象,实现createLogo方法创建X3车标对象。

    public class X3Factory implements IBMWFactory {
    
        @Override
        public IBMWCar createCar() {
            return new X3Car();
        }
    
        @Override
        public ILogo createLogo() {
            return new X3Logo();
        }
    }
    

    创建X5工厂类,并实现工厂接口,实现createCar方法,创建X5Car对象,实现createLogo方法创建X5车标对象。

    public class X5Factory implements IBMWFactory {
    
        @Override
        public IBMWCar createCar() {
            return new X5Car();
        }
    
        @Override
        public ILogo createLogo() {
            return new X5Logo();
        }
    }
    

    测试

    public class Test {
    
        public static void main(String[] args) {
            // 创建X1工厂类,并创建X1车和X1车标
            X1Factory x1Factory = new X1Factory();
            IBMWCar carX1 = x1Factory.createCar();
            carX1.run();
            ILogo logo1 = x1Factory.createLogo();
            logo1.create();
    
            // 创建X3工厂类,并创建X3车和X3车标
            X3Factory x3Factory = new X3Factory();
            IBMWCar carX3 = x3Factory.createCar();
            carX3.run();
            ILogo logo3 = x3Factory.createLogo();
            logo3.create();
    
            // 创建X5工厂类,并创建X5车和X5车标
            X5Factory x5Factory = new X5Factory();
            IBMWCar carX5 = x5Factory.createCar();
            carX5.run();
            ILogo logo5 = x5Factory.createLogo();
            logo5.create();
        }
    }
    

    运行结果:

    X1Car run
    创建X1Logo
    X3Car run
    创建X3Logo
    X5Car run
    创建X5Logo
    

    以上便是抽象工厂模式的原理和代码实现,相比工厂方法模式,多了车标产品,所以可以把品牌和车标统称为一系列产品族,这种场景便可以使用抽象工厂模式来实现。

    示例代码:abstract_factory

    开源库示例

    Mybatis库做Java服务开发的都不陌生,在Mybatis库中创建SqlSession时就是使用了抽象工厂模式,类路径:org.apache.ibatis.session.SqlSessionFactory

    public interface SqlSessionFactory {
      SqlSession openSession();
      SqlSession openSession(boolean autoCommit);
      SqlSession openSession(Connection connection);
      SqlSession openSession(TransactionIsolationLevel level);
      SqlSession openSession(ExecutorType execType);
      SqlSession openSession(ExecutorType execType, boolean autoCommit);
      SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
      SqlSession openSession(ExecutorType execType, Connection connection);
      Configuration getConfiguration();
    }
    

    它的子类有SqlSessionManagerSqlSessionManager都提供了打开Session的方法和getConfiguration方法。

    创建的对象是SqlSession和Configuration两个相关对象,Configuration为相关配置信息,SqlSession类路径为:org.apache.ibatis.session.SqlSession,源码如下:

    public interface SqlSession extends Closeable {
      <T> T selectOne(String statement);
      <T> T selectOne(String statement, Object parameter);
      <E> List<E> selectList(String statement);
      <E> List<E> selectList(String statement, Object parameter);
      ......
    }
    

    这里提供了常用的sql执行接口。SqlSession的子类有:DefaultSqlSession、SqlSessionManager、SqlSessionTemplate,子类在创建后会提供对应的Sql执行接口。

    个人公众号,喜欢的可以关注一下:
    在这里插入图片描述

    展开全文
  • 这里首先以一个生活中抽象工厂的例子来实现一个抽象工厂,然后再给出抽象工厂的定义和UML图来帮助大家更好地掌握抽象工厂模式,同时大家在理解的时候,可以对照抽象工厂生活中例子的实现和它的定义来加深抽象工厂的...
  • 主要介绍了javascript设计模式 – 抽象工厂模式,结合实例形式分析了javascript抽象工厂模式相关概念、原理、定义、应用场景及操作注意事项,需要的朋友可以参考下
  • 主要介绍了Java设计模式编程中简单工厂与抽象工厂模式的使用实例,简单工厂与抽象工厂都可以归类于设计模式中的创建型模式,需要的朋友可以参考下
  • 主要介绍了解析iOS应用开发中对设计模式中的抽象工厂模式的实现,示例代码为传统的Objective-C,需要的朋友可以参考下
  • 工厂系列 定义: 工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离...GOF 在《设计模式》一书中将工厂模式分为两类:工厂方法模式(Factory Method)与抽象工厂模式(Abstract Factory)。将简

    工厂系列

    定义:

    • 工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的。
    • 在这里插入图片描述

    分类:

    工厂模式在《Java 与模式》中分为三类:这三种模式从上到下逐步抽象,并且更具一般性

    1. 简单工厂模式(Simple Factory)
    2. 工厂方法模式(Factory Method)
    3. 抽象工厂模式(Abstract Factory)

    GOF 在《设计模式》一书中将工厂模式分为两类:工厂方法模式(Factory Method)与抽象工厂模式(Abstract Factory)。将简单工厂模式(Simple Factory)看为工厂方法模式的一种特例,两者归为一类。

    在这里插入图片描述

    简单工厂模式

    • 简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存 在的目的很简单:定义一个用于创建对象的接口。

    组成:

    在这里插入图片描述
    在这里插入图片描述

    案例:

    抽象产品角色 Car

    public interface Car {
        void drive();
    }
    

    具体产品角色

    • 奔驰
    public class Benz implements Car{
        @Override
        public void drive() {
            System.out.println("Driving Benz ");
        }
    }
    
    • 宝马
    public class Bmw  implements Car{
        @Override
        public void drive() {
            System.out.println("Driving Bmw ");
        }
    }
    

    工厂类角色 SimpleFactory

    public class SimpleFactory {
    
        //工厂方法.注意返回类型为抽象产品角色
        public static Car driverCar(String s) throws Exception {
    
            if (s.equalsIgnoreCase("Benz")) {
                return new Benz();
            } else if (s.equalsIgnoreCase("Bmw")) {
                return new Bmw();
            }else {
                throw  new Exception();
            }
        }
    }
    

    测试类 Main

    public class Main {
        public static void main(String[] args) throws Exception {
    
            Car car = SimpleFactory.driverCar("benz");
    
            car.drive();
        }
    }
    

    在这里插入图片描述
    在这里插入图片描述

    简单工厂模式适用场景

    • 简单工厂适用于工厂类负责创建的对象较少的场景,且客户端只需要传入工厂类的参数,对于如何创建对象的逻辑不需要关心

    简单工厂模式缺点

    • 假如每种产品创建不仅仅只是实例化一个对象,还有其他逻辑需要处理,那么我们无法直接使用一句反射,避免不了写很多if(亦或者用switch循环),这样的话每新增一个产品我们都需要修改工厂实现类,随着产品链越来越丰富,工厂的职责会变得越来越多,久而久之会越来越难以维护。

    工厂方法模式

    • 工厂方法模式是指定义一个创建对象的接口,但让实现这个接口的类来决定实例化哪个对象,工厂方法让类的实例化推迟到子类中进行,
    • 在工厂方法模式中用户只需要关心所需产品对应的工厂,无须关心创建细节,而且加入新的产品符合开闭原则。

    组成:

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    案例:

    抽象工厂角色 CarFactory

    public interface CarFactory {
        Car driverCar();
    }
    

    具体工厂角色 BenzFactory,BmwFactory

    public class BenzFactory implements CarFactory{
        @Override
        public Car driverCar() {
            return new Benz();
        }
    }
    
    public class BmwFactory implements CarFactory{
        @Override
        public Car driverCar() {
            return new Bmw();
        }
    }
    
    

    抽象产品角色 Car

    public interface Car {
        void drive();
    }
    

    具体产品角色

    • 奔驰
    public class Benz implements Car{
        @Override
        public void drive() {
            System.out.println("Driving Benz ");
        }
    }
    
    • 宝马
    public class Bmw  implements Car{
        @Override
        public void drive() {
            System.out.println("Driving Bmw ");
        }
    }
    

    测试类 Main

    public class Main {
        public static void main(String[] args) throws Exception {
    
            // Car car = SimpleFactory.driverCar("benz");
    
            CarFactory factory = new BmwFactory();
            Car car = factory.driverCar();
            car.drive();
        }
    }
    

    在这里插入图片描述
    看完这个例子家应该很明白工厂方法和简单工厂的区别了,简单工厂就是所有产品都由一个工厂类一个方法来创建,而工厂方法将工厂的职责也进行细化了,每种产品都由自己特定的工厂来生产,这也是单一职责原则的体现。

    工厂方法模式适用场景

    1. 当客户程序不需要知道要使用对象的创建过程。
    2. 客户程序使用的对象存在变动的可能,或者根本就不知道使用哪一个具体的对象。

    工厂模式优点

    1. 工厂方法克服了简单工厂违背开放-封闭原则的缺点,又保持了封装对象创建过程的优点。
    2. 封装了对象的创建,使得要更换对象时,不需要做大的改动就可实现,降低了客户程序与产品对象的耦合
    3. 工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性,工厂方法模式保持了简单工厂模式的优点,而且克服了它的缺点。

    工厂方法模式缺点

    1. 类的个数容易过多,增加复杂度。
    2. 增加了系统的抽象性和理解难度

    抽象工厂

    产品族

    产品族: 位于不同产品等级结构中,功能相关联的产品组成的家族。

    假设BmwFactory,BenzFactory不但造汽车,还制造飞机 坦克.

    • 那么Bmw厂家的car ,plane ,tank就是一族.
    • 同样Benz厂家的car ,plane ,tank也是一族.

    而BmwFactory 和BenzFactory 就是两个产品树(产品层次结构);

    在这里插入图片描述

    在这里插入图片描述

    使用抽象工厂模式还要满足一下条件:

    1. 系统中有多个产品族,而系统一次只可能消费其中一族产品。
    2. 同属于同一个产品族的产品以其使用

    组成;

    抽象工厂模式的各个角色(和工厂方法的如出一辙):
    在这里插入图片描述
    在这里插入图片描述

    案例:

    抽象工厂角色 AbstractFactory

    public interface AbstractFactory {
        //制造汽车
        abstract Car driverCar();
    
        //制造飞机
        abstract plane driverPlane();
    
        //制造坦克
        abstract tank driverTank();
    
    }
    

    具体工厂角色 BenzFactory,BmwFactory

    • 奔驰工厂
    public class BenzFactory implements AbstractFactory {
        @Override
        public Car driverCar() {
            return new BenzCar();
        }
    
        @Override
        public plane driverPlane() {
            return new BenzPlane();
        }
    
        @Override
        public tank driverTank() {
            return new BenzTank();
        }
    }
    
    
    • 宝马工厂
    public class BmwFactory implements AbstractFactory {
        @Override
        public Car driverCar() {
            return new BmwCar();
        }
    
        @Override
        public plane driverPlane() {
            return new BmwPlane();
        }
    
        @Override
        public tank driverTank() {
            return new BmwTank();
        }
    }
    

    测试类 main

    public class Main {
        public static void main(String[] args) throws Exception {
    
            AbstractFactory factory = new BmwFactory();
    
            Car car = factory.driverCar();
            plane plane = factory.driverPlane();
            tank tank = factory.driverTank();
    
            car.drive();
            plane.drive();
            tank.drive();
        }
    }
    
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    抽象工厂模式为创建一组对象提供了一种解决方案。 与工厂方法模式相比, 抽象工厂模式中的具体工厂不只是创建一种具体对象,它负责创建一组(族)具体对象。

    抽象工厂使用场景:

    当我们有一系列产品(如上面的car,tank,plane)。而这一系列产品每种产品又需要具有不同的创建方法

    抽象工厂优点:

    1. 抽象工厂模式隔离了具体类的生成, 使得客户并不需要知道什么被创建。 由于这种隔离,更换一个具体工厂就变得相对容易,
      所有的具体工厂都实现了抽象工厂中定义的那些公共接口, 因此只需改变具体工厂的实例, 就可以在某种程度上改变整个软件系统的行为。
    2. 当一个族中的多个对象被设计成一起工作时, 它能够保证客户端始终只使用同一个族中的对象。
    3. 增加新的族很方便, 无须修改已有系统, 符合“开闭原则”。

    抽象工厂缺点:

    1. 规定了所有可能被创建的产品集合,产品族中扩展新的产品困难,需要修改抽象工厂 的接口。
    2. 增加了系统的抽象性和理解难度。

    抽象工厂模式在spring源码中的应用

    在 Spring 中,BeanFactory 是用于管理 Bean 的一个工厂,所有工厂都是 BeanFactory 的子类。这样我们可以通过 IOC 容器来管理访问 Bean,根据不同的策略调用 getBean() 方法,从而获得具体对象。

    在这里插入图片描述

    BeanFactory 的子类主要有 ClassPathXmlApplicationContext、XmlWebApplicationContext、StaticWebApplicationContext、StaticApplicationContext。

    在 Spring 中,DefaultListableBeanFactory 实现了所有工厂的公共逻辑

    在这里插入图片描述
    详情看Spring源码–01–Spring IOC简述

    在这里插入图片描述

    展开全文
  • 主要为大家详细介绍了Java设计模式之抽象工厂模式的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 抽象工厂模式的详解

    千次阅读 2020-11-06 00:47:40
    1.为什么需要抽象工厂模式? 虽然工厂方法模式引入...2.抽象工厂模式定义 抽象工厂模式: 是一种为用户类提供一个创建一组相关或相互依赖的对象的接口,而且用户类无需指定他们的具体类就能得到同族的不同等级的产
  • 学习设计模式之抽象工厂模式

    千次阅读 2022-04-13 21:32:39
    抽象工厂模式生产的是多个不同类型的不同产品,所以必须将共同点抽象出来,例如戴尔CPU,苹果CPU,抽象的接口就是CPU。(再比如:戴尔GPU,苹果GPU,抽象的接口就是GPU)。 这是为了遵守面向对象的原则之一,面向...
  • 工厂模式与抽象工厂模式

    万次阅读 2020-12-25 21:34:30
    抽象工厂模式 核心本质:  实例化对象不使用new,用工厂方法代替  将选择实现类,创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。 三种模式: ◆简单工厂模式  用来生产同一等级结构中的任意产品(对于...
  • 主要介绍了实例解析Java单例模式编程中对抽象工厂模式的运用,抽象工厂模式可以看作是工厂方法模式的升级版,本需要的朋友可以参考下
  • 主要介绍了Android编程设计模式之抽象工厂模式,结合实例形式详细分析了Android抽象工厂模式的概念、原理、使用方法及相关注意事项,需要的朋友可以参考下
  • 抽象工厂模式(详解版)

    千次阅读 2021-02-28 18:12:40
    前面介绍的工厂方法模式中考虑的是一类产品的生产,如畜牧场只养动物、电视机厂只生产电视机、计算机软件学院只培养计算机软件专业的学生等。同种类称为同等级,也就是说...本节要介绍的抽象工厂模式将考虑多等级产...
  • 文章目录定义举个栗子抽象工厂模式的优点抽象工厂模式的缺点简单工厂、工厂模式、抽象工厂小结简单工厂工厂方法模式抽象工厂模式 Provide an interface for creating families of related or dependent objects ...
  • 抽象工厂模式:提供一个创建一系列相关或者相互依赖的接口,而无需指定它们具体的类。 (1)AbstractFactory(抽象工厂):它声明了一组用于创建一族产品的方法,每一个方法对应一种产品。 (2)ConcreateFactory...
  • 第15章:抽象工厂模式 抽象工厂模式 工厂方法模式(factory method):定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。 抽象工厂模式(abstract factory):提供一...
  • java中的抽象工厂模式

    2021-12-06 13:50:59
    设计模式之抽象工厂模式(FactoryMethod Pattern) 相关定义:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 工厂方法的实现主要是通过以下步骤: 创建一个或多个抽像工厂(代码里面为...
  • C++设计模式:抽象工厂模式

    千次阅读 多人点赞 2021-12-11 20:20:47
    抽象工厂模式是一种创建型设计模式, 它能创建一系列相关的对象, 而无需指定其具体类。
  • 但是在实际应用中,一个工厂类只创建单个产品的情况很少,一般一个工厂类会负责创建一系列相关的产品,如果我们要设计这样的系统,工厂方法模式显然不能满足应用的需求,本章要介绍的抽象工厂模式,可以很好地解决一...
  • 抽象工厂是一种创建型设计模式,它能创建一系列相关的对象,而无需指定其具体类。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 130,736
精华内容 52,294
关键字:

抽象工厂模式定义