精华内容
下载资源
问答
  • 抽象工厂模式抽象类
    千次阅读
    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执行接口。

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

    更多相关内容
  • 浅析JS抽象工厂模式

    2020-11-26 11:32:25
    以下就是作者学习中遇到的问题以及代码实例,最后还给大家关于JS抽象工厂模式的学习做了总结。 抽象工厂模式(Abstract Factory)就是通过的抽象使得业务适用于一个产品簇的创建,而不负责某一产品的实例。 JS中...
  •  抽象工厂模式为一个产品家族提供了统一的创建接口。当需要这个产品家族的某一系列的时候,可以从抽象工厂中选出相对应的系列来创建一个具体的工厂类别。 2. 抽象工厂模式中的角色  2.1 抽象工厂(Abstract...
  • 2. 如何解决:就要用到抽象工厂模式,就是对功能单独创建工厂,这样就不必修改之前的代码,又扩展了功能。   3. 工厂模式其实就是对 实现同一接口的 实现 的 统一 工厂方式创建调用,但 javascript 没有接口...
  • 工厂模式在一些设计模式的书中分为简单工厂模式,工厂方法模式和抽象工厂模式。也有把工厂方法模式划分到抽象工厂模式的,认为工厂方法是抽象工厂模式的特例的一种,就是只有一个要实现的产品接口。
  • 抽象工厂模式(Abstact Factory)是一种常见的软件设计模式。该模式为一个产品族提供了统一的创建接口。当需要这个产品族的某一系列的时候,可以为此系列的产品族创建一个 具体的工厂。 【意图】 抽象工厂模式提供...
  • 抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们的 下面是一个抽象工厂的demo: #!/usr/bin/env python # -*- coding:utf-8 -*- __author__ = 'Andy' 大话...
  • 抽象工厂模式代码

    2017-08-31 09:11:04
    提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的。 通过主板和cpu组装电脑。这里主板的CPU插槽数要和CPU的针脚数相等,也就是说CPU对象和主板对象是有关联的,同时CPU种类和主板的种类也有很多...
  • 主要介绍了Java使用抽象工厂模式实现的肯德基消费案例,较为详细的分析了抽象工厂模式的定义、原理并结合实例形式分析了Java使用抽象工厂模式实现肯德基消费案例的步骤与相关操作技巧,需要的朋友可以参考下
  • 主要介绍了Java设计模式之工厂模式,结合实例形式分析了简单工厂、工厂方法、抽象工厂等相关功能、实现与使用方法,需要的朋友可以参考下
  • 这就是我们要说的抽象工厂模式。提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的。逻辑模型:物理模型:抽象工厂的目的是要提供一个创建一系列相关或相互依赖对象的接口,而不需要指定它们具体...
  • 文章目录前言一、产品等级结构与产品族二、抽象工厂模式概述三、抽象工厂模式结构与实现结构实现抽象工厂模式应用实例抽象工厂模式的缺点 前言 抽象工厂模式比工厂方法模式的抽象程度更高。在工厂方法模式中每一个...

    前言

    抽象工厂模式比工厂方法模式的抽象程度更高。在工厂方法模式中每一个具体工厂只需要生成一种具体的产品,但是在抽象工厂模式中每一个具体工厂只可以生产一组相关的具体产品,这样的一组产品称为产品族,产品族中的每一个产品都分属于某一个产品继承等级结构。

    一、产品等级结构与产品族

    产品等级结构:产品灯具结构即产品的继承结构,例如一个抽象类时电视机,其子类包括海尔电视机、海信电视机、TCL电视机,则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构,抽象电视机是父类,而具体品牌的电视机是其子类。
    产品族:在抽象工厂模式中,产品族是指由同一个工厂生产的位于不同产品等级结构中的一组产品,例如海尔电器工厂生产的海尔电视机、海尔冰箱,海尔电视机位于电视机产品等级结构中,海尔冰箱位于冰箱产品的等级结构中,海尔电视机、海尔冰箱构成了一个产品族。

    二、抽象工厂模式概述

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

    抽象工厂模式与工厂方法模式最大的区别在于,工厂方法模式针对的是一个产品等级结构,而抽象工厂模式需要面对多个产品等级结构,一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时,抽象工厂模式比工厂方法模式更为简单、更有效率。与工厂方法模式相比,抽象工厂模式中的具体工厂不只是创建一种产品,它负责创建一族产品。

    三、抽象工厂模式结构与实现

    结构

    在这里插入图片描述
    抽象工厂模式包含以下4个角色:

    1. AbstractFactory(抽象工厂):它声明了一组用于创建一族产品的方法,每一个方法对应一种产品。
    2. ConcreteFactory(具体工厂):它实现了在抽象工厂中声明的创建产品的方法,生成一组具体产品,这些产品构成了一个产品族,每一个产品都位于某个产品等级结构中。
    3. AbstractProduct(抽象产品):它为每中产品声明接口,在抽象产品中声明了产品所具有的业务方法。
    4. ConcreteProduct(具体产品):它定义具体工厂生产的具体产品对象,实现抽象产品接口中声明的业务方法。

    实现

    抽象工厂中声明了多个工厂方法,用于创建不同类型的产品,抽象工厂可以时接口,也可以时抽象类或者具体类。其典型代码如下:

    public interface AbstractFactory(){
    	public AbstractProductA createProductA();
    	public AbstractProductB createProductB();
    

    具体工厂实现了抽象工厂,每一个具体的工厂方法可以返回一个特定的产品对象,而同一个具体工厂所创建的产品对象构成了一个产品族。对于每一个具体工厂类,其典型代码如下

    public class ConcreteFactory1 extends AbstractFactory(){
    	//工厂方法一
    	public AbstractProudctA createProductA(){
    	return new ConcreteProductA1();
    	}
    	public class ConcreteFactory1 extends AbstractFactory(){
    	//工厂方法一
    	public AbstractProudctB createProductB(){
    	return new ConcreteProductB1();
    	}
    }
    

    抽象工厂模式应用实例

    实例说明

    则结构图

    在上图中,SkinFactory接口充当抽象工厂,其子类SpringSkinFactory和SummerSkinFactory充当具体工厂,接口Button、TextField和ComboBox充当抽象产品,其子类SpringButton、SpringTextField、SpringComboBox和SummerButton、SummerTextField、SummerComboBox充当具体产品。

    抽象工厂模式的缺点

    例如上面例子,如果在设计之初因为考虑不全面,忘记为某种类型的界面组件(比如一个单选按钮RadioButton)提供不同皮肤下的风格化显示,那么在往系统中增加单选按钮时将发现非常麻烦,无法在满足开闭原则的前提下增加单选按钮,原因是抽象工厂SkinFactory中根本没有提供创建单选按钮的方法,如果需要增加单选按钮,首先需要修改抽象工厂接口SkinFactory,在其中新增声明创建单选按钮的方法,然后逐个修改具体工厂类,增加相应方法以实现在不同的皮肤库中创建单选按钮此外还需要修改客户端,否则单选按钮无法应用于现有系统。即抽象工厂模式如果要增加新的产品等级结构十分麻烦。

    展开全文
  • 主要介绍了PHP设计模式之抽象工厂模式,结合实例形式分析了php抽象工厂模式的概念、原理、使用方法及相关操作注意事项,需要的朋友可以参考下
  • 主要介绍了Java设计模式之抽象工厂模式,结合实例形式分析了抽象工厂模式的概念、功能、定义与使用方法,需要的朋友可以参考下
  • 主要介绍了Java设计模式编程中的工厂方法模式和抽象工厂模式,设计模式的建立有利于团队协作时代码的共同维护,需要的朋友可以参考下
  • 抽象工厂模式

    2017-06-29 17:25:09
    Qt实现的抽象工厂模式,抽象工厂,提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的。对于工厂方法来说,抽象工厂可实现一系列产品的生产,抽象工厂更注重产品的组合。
  • 2. 如何解决:就要用到抽象工厂模式,就是对功能单独创建工厂,这样就不必修改之前的代码,又扩展了功能。 3. 工厂模式其实就是对 实现同一接口的 实现 的 统一 工厂方式创建调用,但 javascript 没有接口这号...
  • 文章目录一、工厂方法1、工厂法法模式结构图:2、工厂方法模式的优缺点二、抽象工厂模式1、抽象工厂模式结构图2、抽象工厂模式的优缺点 一、工厂方法 工厂方法定义:定义一个用于创建对象的接口,让子类决定实例化哪...

    一、工厂方法

    工厂方法定义:定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类。

    1、工厂法法模式结构图:

    在这里插入图片描述
    工厂方法抽象出一个工厂接口,这个接口只有一个方法,就是创建抽象产品的工厂方法,所有要生产具体类的工厂就去实现这个接口。当需要创建新对象的工厂时,就不需要更改原有的工厂类,只需要增加相应的工厂类。

    产品抽象类 Product

    public abstract class Product {
        protected String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    

    具体产品类 ConcreteProductA

    public class ConcreteProductA extends Product{
    
        public ConcreteProductA(){
            super();
            this.name = "具体产品 A";
        }
    }
    

    具体产品类 ConcreteProductB

    public class ConcreteProductB extends Product{
    
        public ConcreteProductB(){
            super();
            this.name = "具体产品 B";
        }
    }
    

    抽象工厂接口 Factory

    public interface Factory {
        public Product createProduct();
    }
    

    创建 ConcreteProductA 的工厂类 ConcreteProductAFactory

    public class ConcreteProductAFactory implements Factory{
        @Override
        public Product createProduct() {
            return new ConcreteProductA();
        }
    }
    

    创建 ConcreteProductB 的工厂类 ConcreteProductBFactory

    public class ConcreteProductBFactory implements Factory{
        @Override
        public Product createProduct() {
            return new ConcreteProductB();
        }
    }
    

    效果测试类

    public class FactoryMethodTest {
        public static void main(String[] args) {
            Factory factoryA = new ConcreteProductAFactory();
            Factory factoryB = new ConcreteProductBFactory();
            Product productA = factoryA.createProduct();
            Product productB = factoryB.createProduct();
    
            System.out.println(productA.getName());
            System.out.println(productB.getName());
        }
    }
    

    2、工厂方法模式的优缺点

    工厂方法模式具有良好的封装性,代码结构清晰。如果一个调用者需要一个具体的产品对象,只要知道这个产品的类名,不用知道创建对象的艰辛过程,降低模块间的耦合,并且拓展性好。但缺点也是相对的,每增加一个产品,就需要加一个产品的工厂类,增加了额外的开发量。

    二、抽象工厂模式

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

    1、抽象工厂模式结构图

    在这里插入图片描述
    AbstractProductA 和 AbstractProductB 是两个抽象产品,而ProductA1和ProductA2、ProductB1、ProductB2就是对两个抽象产品的具体实现。

    AbstractFactory是一个抽象工厂接口,它里面包含所有产品创建的抽象方法。而ConcreteFactory1 和ConcreteFactory2就是具体的工厂了。

    抽象产品类 AbstractProductA

    public abstract class AbstractProductA {
        protected String type = "A型产品";
    
        protected String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        /** 每个产品具体实现该方法 */
        public abstract void doSomething();
    }
    

    抽象产品类 AbstractProductB

    public abstract class AbstractProductB {
        protected String type = "B型产品";
    
        protected String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        /** 每个产品具体实现该方法 */
        public abstract void doSomething();
    }
    

    A型具体产品 ProductA1

    public class ProductA1 extends AbstractProductA{
    
        public ProductA1(){
            super();
            this.name = "产品A1";
        }
        @Override
        public void doSomething() {
            System.out.println(this.name + " doSomething");
        }
    }
    

    A型具体产品 ProductA2

    public class ProductA2 extends AbstractProductA{
    
        public ProductA2(){
            super();
            this.name = "产品A2";
        }
        @Override
        public void doSomething() {
            System.out.println(this.name + " doSomething");
        }
    }
    
    

    B型具体产品 ProductB1

    public class ProductB1 extends AbstractProductB{
    
        public ProductB1(){
            super();
            this.name = "产品B1";
        }
        @Override
        public void doSomething() {
            System.out.println(this.name + " doSomething");
        }
    }
    

    B型具体产品 ProductB2

    public class ProductB2 extends AbstractProductB{
    
        public ProductB2(){
            super();
            this.name = "产品B2";
        }
        @Override
        public void doSomething() {
            System.out.println(this.name + " doSomething");
        }
    }
    
    

    抽象工厂接口 AbstractFactory

    public interface AbstractFactory {
    
        public AbstractProductA createProductA();
    
        public AbstractProductB createProductB();
    }
    
    

    创建1系列产品的工厂类 ConcreteFactory1

    public class ConcreteFactory1 implements AbstractFactory{
        @Override
        public AbstractProductA createProductA() {
            return new ProductA1();
        }
    
        @Override
        public AbstractProductB createProductB() {
            return new ProductB1();
        }
    }
    

    创建2系列产品的工厂类 ConcreteFactory2

    public class ConcreteFactory2 implements AbstractFactory{
        @Override
        public AbstractProductA createProductA() {
            return new ProductA2();
        }
    
        @Override
        public AbstractProductB createProductB() {
            return new ProductB2();
        }
    }
    
    

    效果测试类

    public class AbstractFactoryTest {
        public static void main(String[] args) {
            AbstractFactory factory = new ConcreteFactory1();
    
            AbstractProductA productA = factory.createProductA();
            AbstractProductB productB = factory.createProductB();
            productA.doSomething();
            productB.doSomething();
    
            System.out.println("=========切换产品系列工厂=========");
    
            factory = new ConcreteFactory2();
            productA = factory.createProductA();
            productB = factory.createProductB();
            productA.doSomething();
            productB.doSomething();
        }
    
    }
    

    输出:
    产品A1 doSomething
    产品B1 doSomething
    =切换产品系列工厂=
    产品A2 doSomething
    产品B2 doSomething

    由此可见,切换工厂类,即可对获取的产品系列进行切换

    2、抽象工厂模式的优缺点

    抽象工厂最大的好处是便于切换产品系列,其次是它让具体的创建实例过程与客户端分离,客户端是通过抽象接口获取实例,依赖的产品也是抽象的,而不是具体的产品类。

    抽象工厂的缺点是产品族的拓展非常困难,如果增加了一个产品,抽象工厂类中需要增加创建该产品的抽象方法,具体工厂类中也得去实现,涉及到的改动多。

    展开全文
  • 文章目录前言一、认识抽象工厂模式二、实现抽象工厂模式2.1、代码实现2.2、分析说明总结参考资料 前言 本篇博客是关于抽象工厂...抽象工厂模式也是工厂模式的一种,相对于简单工厂模式、工厂方法模式考虑的是一产品的

    前言

    本篇博客是关于抽象工厂的实现,若文章中出现相关问题,请指出!

    对应代码地址:Gitee(demo-exer/ java-Lear23designpatterns)Github(java-demo/ java-Lear23designpatterns)

    所有博客文件目录索引:博客目录索引(持续更新)


    一、认识抽象工厂模式

    抽象工厂模式也是工厂模式的一种,相对于简单工厂模式、工厂方法模式考虑的是一类产品的生产,而抽象工厂模式则是考虑多个产品族的创建。在抽象工厂模式中,有一个抽象工厂,该抽象工厂中提供了产生不同抽象产品的方法。其中抽象工厂是可以创建工厂的工厂!

    定义:抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口无需指定它们具体的类。

    应用场景

    1. 提供一个产品类的工厂,所有的产品以同样的接口出现,使用者不依赖于具体的实现。
    2. 强调一些列相关的产品对象(如下面示例的产品族),一起使用创建对象需要大量重复的代码。

    结构:抽象工厂、具体工厂;抽象产品、具体产品。

    优缺点

    • 优点:获取具体系列产品只需要通过具体系列工厂获取,无序关心创建的细节;
    • 缺点:规定了所有可能被创建的产品集合,若是出现某一个系列出现新的产品就会导致所有的系列都会创建指定的接口!扩展新产品困难,增加了系统的抽象性与复杂度。

    引用 C语言中文网—抽象工厂模式

    image-20210316194435890


    二、实现抽象工厂模式

    2.1、代码实现

    Abstract目录下的是抽象工厂模式代码:

    image-20210316191516433

    抽象产品IphoneRouter

    //手机接口
    public interface Iphone {
        void start();
        void music();
        void ring();
        void stop();
    }
    
    //路由器接口
    public interface Router {
        void start();
        void stop();
        void work();
    }
    
    • 抽象工厂解决的是一个产品族的创建,品牌可以有多个,一个品牌也会生产不同的产品,其不同品牌的相同产品我们就可以将其进行抽象,由于我们注重的并不是一个产品的创建而是一个产品族,所以我们还需要抽象一个品牌接口即相当于是一个抽象工厂,该抽象工厂可以创建具体的工厂(实现其接口)。

    抽象工厂Brand

    //品牌接口(可根据不同的品牌获取不同的产品)
    public interface Brand {
        Iphone getPhone();
        Router getRouter();
    }
    

    具体产品HuaWeiPhoneLianXiangPhoneHuaWeiRouterLianXiangRouter

    //手机的实现类
    //华为牌手机
    public class HuaWeiPhone implements Iphone {
        @Override
        public void start() {
            System.out.println("华为手机启动中...");
        }
    
        @Override
        public void music() {
            System.out.println("华为手机播放音乐中...");
        }
    
        @Override
        public void ring() {
            System.out.println("华为手机开启闹铃中...");
        }
    
        @Override
        public void stop() {
            System.out.println("华为手机关机中...");
        }
    }
    
    //联想牌手机
    public class LianXiangPhone implements Iphone {
        @Override
        public void start() {
            System.out.println("联想手机正在启动...");
        }
    
        @Override
        public void music() {
            System.out.println("联想手机播放音乐中...");
        }
    
        @Override
        public void ring() {
            System.out.println("联想手机开启闹铃...");
        }
    
        @Override
        public void stop() {
            System.out.println("联想手机关机中...");
        }
    }
    
    //路由器的实现类
    //华为路由器
    public class HuaWeiRouter implements Router{
        @Override
        public void start() {
            System.out.println("华为路由器正在启动...");
        }
    
        @Override
        public void stop() {
            System.out.println("华为路由器正在关机...");
        }
    
        @Override
        public void work() {
            System.out.println("华为路由器开始工作...");
        }
    }
    
    //联想路由器
    public class LianXiangRouter implements Router{
        @Override
        public void start() {
            System.out.println("联想路由器正在启动...");
        }
    
        @Override
        public void stop() {
            System.out.println("联想路由器正在关机...");
        }
    
        @Override
        public void work() {
            System.out.println("联想路由器开始工作...");
        }
    }
    
    

    具体工厂:既然产品有了,那我们一定是从指定工厂中来获取产品,接着我们通过抽象工厂来创建工厂类

    //华为工厂(提供华为手机、华为路由器)
    public class HuaWeiFactory implements Brand{
        @Override
        public Iphone getPhone() {
            return new HuaWeiPhone();
        }
    
        @Override
        public Router getRouter() {
            return new HuaWeiRouter();
        }
    }
    
    //联想工厂(提供联想手机、联想路由器)
    public class LianXiangFactory implements Brand{
        @Override
        public Iphone getPhone() {
            return new LianXiangPhone();
        }
    
        @Override
        public Router getRouter() {
            return new LianXiangRouter();
        }
    }
    

    最终我们来创建一个顾客类Customer,获取不同品牌的产品并且使用产品:

    public class Customer {
    
        public static void main(String[] args) {
            //获取华为工厂
            Brand huawei = new HuaWeiFactory();
            Iphone phone = huawei.getPhone();//华为工厂获取华为手机
            phone.start();
            phone.music();
            phone.ring();
            phone.stop();
            Router router = huawei.getRouter();//华为工厂获取华为路由器
            router.start();
            router.work();
            router.stop();
            //----------------------
            System.out.println();
            Brand lianxiang = new LianXiangFactory();
            Iphone phone1 = lianxiang.getPhone();//华为工厂获取华为手机
            phone1.start();
            phone1.music();
            phone1.ring();
            phone1.stop();
            Router router1 = lianxiang.getRouter();//华为工厂获取华为路由器
            router1.start();
            router1.work();
            router1.stop();
        }
    }
    

    image-20210316193848990



    2.2、分析说明

    在上面顾客类中的测试方法里,我们通过不同的工厂来获取到不同品牌的产品,具体的产品进行了代码的隔离,无需关心创建过程中的细节!

    我们看下上面整体代码的依赖图

    image-20210316195312012

    • 将具体产品类型进行抽象,将具体生产商抽象成一个工厂并提供获取抽象产品的接口。
    • 当我们需要具体的产品时只需要通过具体的工厂的方法即可获取,而不用再去管其中的细节。

    若是我们要添加其他品牌如小米,我们只需要实现Brand接口创建一个工厂,分别实现其接口即可,符合开闭原则;若是新增一个产品A,那么就需要在Brand中添加获取A的接口,那么其所有实现该接口的工厂类都需要修改,这就不符合开闭原则。


    总结

    1、抽象工厂由四个部分组成:抽象工厂、具体工厂;抽象产品、具体产品。

    2、添加新的产品族时只需要实现抽象工厂接口创建一个工厂并实现其中的方法即可,符合了开闭原则;而对于添加某个新产品则需要添加抽象工厂的接口,即造成所有抽象工厂的实现类都要进行修改,这就违反了开闭原则。

    3、针对于抽象工厂模式不可以增加产品,可以增加产品族!(一旦增加产品就会造成大量修改)。

    4、对于抽象工厂模式针对于的是产品族!



    参考资料

    视频:狂神说Java—抽象工厂模式

    [1]. 抽象工厂模式(详解版)


    我是长路,感谢你的耐心阅读。如有问题请指出,我会积极采纳!
    欢迎关注我的公众号【长路Java】,分享Java学习文章及相关资料
    Q群:851968786 我们可以一起探讨学习
    注明:转载可,需要附带上文章链接

    展开全文
  • 抽象工厂模式比其它工厂模式更加抽象,抽象工厂模式适用与多个抽象类的情况下,通过工厂返回多个抽象类中你需要得到的具体子类实例。 抽象工厂模式比其它工厂模式更加抽象,抽象工厂模式适用与多个抽象类的情况下,...
  • 主要介绍了javascript设计模式 – 抽象工厂模式,结合实例形式分析了javascript抽象工厂模式相关概念、原理、定义、应用场景及操作注意事项,需要的朋友可以参考下
  • 如果代码需要与多个不同系列的相关产品交互, 但是由于无法提前获取相关信息, 或者出于对未来扩展性的考虑, 你不希望代码基于产品的具体进行构建, 在这种情况下, 你可以使用抽象工厂...
  • 主要介绍了Java设计模式编程中简单工厂与抽象工厂模式的使用实例,简单工厂与抽象工厂都可以归类于设计模式中的创建型模式,需要的朋友可以参考下
  • 抽象工厂模式(Abstact Factory)是一种常见的软件设计模式。该模式为一个产品族提供了统一的创建接口。当需要这个产品族的某一系列的时候,可以为此系列的产品族创建一个具体的工厂。 一、意图 抽象工厂模式提供...
  • 本篇博客给大家介绍常用设计模式中的抽象工厂模式。本节要介绍的抽象工厂模式将考虑多等级产品的生产,将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族。
  • 抽象工厂模式(Abstract Factory Pattern)是围绕一个超级...在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的。每个生成的工厂都能按照工厂模式提供对象。 抽象工厂模式java demo用于学习
  • Spring常用设计模式--抽象工厂模式

    千次阅读 2022-03-15 16:54:45
      抽象工厂模式是指提供一个创建一系列相关或相互依赖对象的接口,无需指定他们的具体。客户端(应用层)不依赖于产品实体如何被创建、如何被实现等细节,强调的是一系列相关的产品对象(属于同一产品族)一起...
  • (1)抽象工厂模式结构与工厂方法模式结构类似,不同之处在于,一个具体工厂可以生产多种同类相关的产品。 抽象工厂模式的优点: 工厂方法用于创建客户所需产品,同时向客户隐藏某个具体产品将被实例化的细节,...
  • 抽象工厂模式 - Unity

    2022-05-06 15:06:21
    抽象工厂模式能创建一系列相关的产品,而无需指定具体。 抽象工厂所生产的不是某一产品,而是一系列,相当于一个组合套装,这些产品是捆绑的。 比方说,买装台式机,我们可以选择 显卡,CPU,主板,内存条等。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 175,510
精华内容 70,204
关键字:

抽象工厂模式抽象类