精华内容
下载资源
问答
  • 抽象工厂模式造车
    2019-01-08 06:22:17

     

    可以用抽象工厂模式来造车。

     

    车的品牌有很多,而且车的属性也不少,比如车的类型、排量、门的数量,等等。可以提炼出有关车的一个抽象类:

     

    
     
        public abstract class Car
    
        {
    
            public string Model { get; set; }
    
            public string Engine { get; set; }
    
            public string Transmission { get; set; }
    
            public string Body { get; set; }
    
            public int Doors { get; set; }
    
            public List<string> Accessores = new List<string>();
    
            public abstract void ShowCarInfo();
    
        }

     

    既然是抽象工厂,提炼出一个造车的接口:

     

    
     
        public interface ICarFactory
    
        {
    
            Car ProduceCar();
    
        }    

     

    写一个Car的派生类:

     

    
     
        public class MyCar : Car
    
        {
    
            public MyCar()
    
            {
    
                Model = "型号001";
    
                Engine = "发动机V";
    
                Transmission = "排量1";
    
                Body = "SUV";
    
                Doors = 4;
    
                Accessores.Add("内饰");
    
                Accessores.Add("外饰");
    
            }
    
    
     
            public override void ShowCarInfo()
    
            {
    
                Console.WriteLine(Model);
    
                Console.WriteLine(Engine);
    
                Console.WriteLine(Body);
    
                Console.WriteLine("门数量:" + Doors);
    
                Console.WriteLine("包括:");
    
                foreach (var accessory in Accessores)
    
                {
    
                    Console.WriteLine("\t{0}", accessory);
    
                }
    
            }
    
        }  
    
     
     

     

    MyCar需要一个对应的具体工厂来造车。写一个具体工厂类,实现ICarFactory接口。

     

    
     
        public class MyFactory : ICarFactory
    
        {
    
            public Car ProduceCar()
    
            {
    
                return new MyCar();
    
            }
    
        }     

     

    在客户端,如果要造车,就找具体工厂就可以了。

     

    
     
            static void Main(string[] args)
    
            {
    
                ICarFactory carFactory = new MyFactory();
    
                carFactory.ProduceCar().ShowCarInfo();
    
                Console.ReadKey();
    
            }

     

    总结:

    1、需要工厂生产对象的抽象类以及派生类
    2、需要一个抽象工厂接口
    3、通过抽象工厂造车,必须把所有的细节都设计在代表车的抽象类中,扩展性不好

    更多相关内容
  • 这就是我们要说的抽象工厂模式。提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。逻辑模型:物理模型:抽象工厂的目的是要提供一个创建一系列相关或相互依赖对象的接口,而不需要指定它们具体...
  • 主要介绍了C#的设计模式编程之抽象工厂模式的应用,注意区分一下简单工厂模式、工厂方法模式和抽象工厂模式概念之间的区别,需要的朋友可以参考下
  • 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执行接口。

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

    展开全文
  • 如果代码需要与多个不同系列的相关产品交互, 但是由于无法提前获取相关信息, 或者出于对未来扩展性的考虑, 你不希望代码基于产品的具体类进行构建, 在这种情况下, 你可以使用抽象工厂...

    废话不多说,直接以实例切入!

    举例理解:

    假如有这样一个需求:某4S店需要订制一批普通轿车和SUV,针对低端客户准备以BYD为主,针对高端用户准备以Porsche为主,以后还可能订制其他品牌的车型;

    这里我们就可以开始思考了,首先BYD和Porsche制造轿车和SUV是不会变得,变的是客户的需求,可能今天要BYD,明天有需要porsche,后面有需要BWM了,所以使用抽象工厂模式;

    1.首先我们先抽象生产车辆的工厂以及车辆

                                                   

     

                                        

    2.创建具体的工厂 -BYD Factory

                      

     3.创建具体的工厂 -Porsche Factory

     

    4.模拟4S店订制车辆 (这里我使用的是winform,以Porsche为例) 

    这样,假如后续4S店需要订制其他品牌的车型,我们就只需要抽象其他品牌的车辆工厂及对应的车辆即可。 

     

     

     

    展开全文
  • 这就是我们要说的抽象工厂模式。 意图 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 模型图 逻辑模型: 物理模型: 生活中的例子 抽象工厂的目的是要提供一个创建一系列相关或相互...
  • 抽象工厂模式

    2019-08-23 00:30:12
    在前面我们讲述了工厂方法模式,以女娲人为例,我们有了黄 黑 白 三个肤色的人,但是正常我们又分为男人和女人。那么怎么改造能让我们能分别制造出黄黑白的男人和女人呢。 接下来是具体代码案例: 人类接口 /**...

    在前面我们讲述了工厂方法模式,以女娲造人为例,我们有了黄 黑 白 三个肤色的人,但是正常我们又分为男人和女人。那么怎么改造能让我们能分别制造出黄黑白的男人和女人呢。
    在这里插入图片描述
    接下来是具体代码案例:

    • 人类接口
    /**
     * 人类接口
     */
    public interface Human {
        void getColor();
    
        void talk();
    
        void getSex();
    }
    
    
    • 然后人类有三个抽象类,分别代表了黑 黄 白种人
    public abstract class AbstractBlackHuman implements Human {
        @Override
        public void getColor() {
            System.out.println("黑色皮肤");
        }
    
        @Override
        public void talk() {
            System.out.println("黑色人会说话");
        }
    }
    
    
    public abstract class AbstractWhiteHuman implements Human {
        @Override
        public void getColor() {
            System.out.println("白色皮肤");
        }
    
        @Override
        public void talk() {
            System.out.println("白色人会说话");
        }
    }
    
    public abstract class AbstractYellowHuman implements Human {
        @Override
        public void getColor() {
            System.out.println("黄色皮肤");
        }
    
        @Override
        public void talk() {
            System.out.println("黄色人会说话");
        }
    }
    
    
    • 然后每个抽象类都有两个实现类,分别对应的男人和女人
    public class FemaleBlackHuman extends AbstractBlackHuman {
        @Override
        public void getSex() {
            System.out.println("黑色女人");
        }
    }
    
    public class MaleBlackHuman extends AbstractBlackHuman {
        @Override
        public void getSex() {
            System.out.println("男性黑人");
        }
    }
    
    
    public class FemaleWhiteHuman extends AbstractWhiteHuman {
        @Override
        public void getSex() {
            System.out.println("女性白人");
        }
    }
    public class MaleWhiteHuman extends AbstractWhiteHuman {
        @Override
        public void getSex() {
            System.out.println("男性白人");
        }
    }
    
    public  class FemaleYellowHuman extends AbstractYellowHuman{
    
        @Override
        public void getSex() {
            System.out.println("黄色女性");
        }
    }
    
    public  class MaleYellowHuman extends AbstractYellowHuman {
    
        @Override
        public void getSex() {
            System.out.println("黄色男性");
        }
    
    }
    
    
    • 接下来就是通过工厂来造人,我们需要两个工厂来分别创建男性和女性
    public interface HumanFactory {
        Human createYellowHuman();
        Human createWhiteHuman();
        Human createBlackHuman();
    }
    
    public class FemaleFactory implements HumanFactory {
        @Override
        public Human createYellowHuman() {
            return new FemaleYellowHuman();
        }
    
        @Override
        public Human createWhiteHuman() {
            return new FemaleWhiteHuman();
        }
    
        @Override`在这里插入代码片`
        public Human createBlackHuman() {
            return new FemaleBlackHuman();
        }
    }
    
    public class MaleFactory implements HumanFactory {
        @Override
        public Human createYellowHuman() {
            return new MaleYellowHuman();
        }
    
        @Override
        public Human createWhiteHuman() {
            return new MaleWhiteHuman();
        }
    
        @Override
        public Human createBlackHuman() {
            return new MaleBlackHuman();
        }
    }
    
    • 最后就是通过工厂开始造人了:
     public static void main(String[] args) {
            MaleFactory factory = new MaleFactory();
            Human blackHuman = factory.createBlackHuman();
            blackHuman.talk();
            blackHuman.getColor();
            blackHuman.getSex();
            Human whiteHuman = factory.createWhiteHuman();
            whiteHuman.talk();
            whiteHuman.getColor();
            whiteHuman.getSex();
            Human yellowHuman = factory.createYellowHuman();
            yellowHuman.talk();
            yellowHuman.getColor();
            yellowHuman.getSex();
    
            FemaleFactory femalFactory = new FemaleFactory();
            Human blackHuman1 = femalFactory.createBlackHuman();
            blackHuman1.talk();
            blackHuman1.getColor();
            blackHuman1.getSex();
            Human whiteHuman1 = femalFactory.createWhiteHuman();
            whiteHuman1.talk();
            whiteHuman1.getColor();
            whiteHuman1.getSex();
            Human yellowHuman1 = femalFactory.createYellowHuman();
            yellowHuman1.talk();
            yellowHuman1.getColor();
            yellowHuman1.getSex();
        }
    
    • 抽象工厂模式的定义
      其定义如下:为创建一组相关或相互依赖的对象提供一个接口,而且无须指定它们 的具体类。
      抽象工厂模式的通用类图如图
      在这里插入图片描述
      抽象工厂模式是工厂方法模式的升级版本,在有多个业务品种、业务分类时,通过抽象 工厂模式产生需要的对象是一种非常好的解决方式。我们来看看抽象工厂的通用源代码,首 先有两个互相影响的产品线(也叫做产品族),例如制造汽车的左侧门和右侧门,这两个应 该是数量相等的——两个对象之间的约束,每个型号的车门都是不一样的,这是产品等级结 构约束的,我们先看看两个产品族的类图
      在这里插入图片描述
      其源代码如下:
    /**
     * 抽象产品类
     */
    public abstract class AbstractProductA {
        public void shareMethod(){
    
        }
    
        public abstract void doSomething();
    }
    
    public abstract class AbstractProductB {
        public void shareMethon() {
            System.out.println("B产品公共方法");
        }
    
        public abstract void doSomething();
    
    }
    

    抽象产品实现类

    public  class ProductA1 extends AbstractProductA{
    
        @Override
        public void doSomething() {
            System.out.println("产品A1实现方法");
        }
    }
    public class ProductA2 extends AbstractProductA {
    
        @Override
        public void doSomething() {
            System.out.println("产品A2实现方法");
        }
    }
    
    public class ProductB1 extends AbstractProductB {
        @Override
        public void doSomething() {
            System.out.println("B1产品实现方法");
        }
    }
    public class ProductB2 extends AbstractProductB {
        @Override
        public void doSomething() {
            System.out.println("B2产品实现方法");
        }
    }
    

    抽象工厂类

    public abstract class AbstractCreator {
    
        abstract AbstractProductA createProductA();
    
        abstract AbstractProductB createProductB();
    
    }
    

    产品等级实现类

    /**
     * 只生产等级为1 的产品
     */
    public class Creator1 extends AbstractCreator {
        @Override
        AbstractProductA createProductA() {
            return new ProductA1();
        }
    
        @Override
        AbstractProductB createProductB() {
            return new ProductB1();
        }
    }
    
    /**
     * 只生产等级为2 的产品
     */
    public class Creator2 extends AbstractCreator {
        @Override
        AbstractProductA createProductA() {
            return new ProductA2();
        }
    
        @Override
        AbstractProductB createProductB() {
            return new ProductB2();
        }
    }
    

    调用方式

    public class Test {
        public static void main(String[] args) {
            Creator1 creator1 = new Creator1();
            creator1.createProductA();
            creator1.createProductB();
    
            Creator2 creator2 = new Creator2();
            creator2.createProductA();
            creator2.createProductB();
        }
    }
    
    • 抽象工厂模式的应用
      优点:封装性、产品族内约束为非公开装备
      缺点:扩展困难,违反了开闭原则。如果增加产品,从产品到工厂都需要增加。
    展开全文
  • 文章目录定义举个栗子抽象工厂模式的优点抽象工厂模式的缺点简单工厂、工厂模式、抽象工厂小结简单工厂工厂方法模式抽象工厂模式 Provide an interface for creating families of related or dependent objects ...
  • 抽象工厂模式(Abstract Factory Pattern):属于创建型模式,它提供了一种创建对象的最佳方式。在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类,每个生成的工厂都能按照工厂模式提供...
  • 工厂系列 定义: 工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离...GOF 在《设计模式》一书中将工厂模式分为两类:工厂方法模式(Factory Method)与抽象工厂模式(Abstract Factory)。将简
  • 抽象工厂简单实现,工厂的工厂
  • php-抽象工厂模式实现

    2021-08-07 18:09:07
    抽象工厂模式(Abstract Factory):抽象工厂模式是对工厂模式的抽象,通俗来说,就是把工厂模式的结构分离出来成为能独立运行的个体。 抽象工厂模式将工厂模式进行抽象,可以使得抽象出来的新结构更加的灵活。例如,...
  • 介绍第三种工厂模式-抽象工厂模式,还是以汽车的制造为例。 例子背景 随着客户的要求越来越高,宝马需要不同配置的空调和发动机等配件。于是这个工厂开始生产空调和发动机,用来组装汽车。这时候工厂有两个系列...
  • 抽象工厂模式
  • 设计模式之抽象工厂模式:如何统一不同代码风格下的代码级别?
  • 相比工厂方法模式,抽象工厂模式生产的是一套对象,工厂方法模式生产的是一个对象,可以给这一套对象加限制 角色 抽象工厂角色:造车工厂类,约束了一个工厂由几个对象创造而来 具体工厂角色:创造不同的车使用不同...
  • 抽象工厂模式其实是工厂方法模式的升级版,其优点其实和工厂方法类似,都是将对象的创建解耦出来,不过抽象工厂模式的工厂能创建的不只是一个产品而是一组产品,这一组产品都有相同的产品类别,同组不同类的产品相互...
  • 一、前期回顾 上一篇《Java设计模式之单例模式》详细介绍了单例模式,介绍了单例...本篇开始介绍单例模式的第二篇,工厂方法模式,以及工厂模式的升级版,抽象工厂模式。 二、工厂方法模式的定义与实践 定义:Def...
  • 类图比较简单,Java典型类图,一个接口,多个抽象类,然后是N个实现类,每个人种都是一个抽象类,性别是在各个实现类中实现的。特别需要说明的是HumanFactory接口,在这个接口中定义了三个方法,分别用来生产三个...
  • 系统开发和现实生活是一样的。在现实生活中一个复杂的商品都...按实际业务场景划分,工厂模式有 3 种不同的实现方式,分别是简单工厂模式、工厂方法模式和抽象工厂模式。 我们把被创建的对象称为“产品”,把创建产..
  • Java中的简单工厂模式 ...女娲人,这就是简单工厂模式的应用。  首先,在这个人的思想里面,有几个重要的角色:女娲本身、抽象的人的概念和女娲所出的一个个具体的人。  1.)女娲是一个工厂类,也就是简单工...
  • 抽象工厂模式实现对产品家族的创建,一个产品家族是这样的一系列产品:具有不同分类维度的产品组合,采用抽象工厂模式则是不需要关系构件过程,只关心什么产品由什么工厂生产即可。而建造者模式则是要求按照指定的...
  • 前面已经介绍过简单工厂模式和工厂方法模式,这里继续介绍第三种工厂模式-抽象工厂模式,还是以汽车的制造为例。例子背景:随着客户的要求越来越高,宝马需要不同配置的空调和发动机等配件。于是这个工厂开始生产...
  • public class BusAccessories implements Accessories { BusAccessories() { this.make(); } @Override public void make() { ...抽象工厂模式(Abstract Factory Pattern)隶属于设计模式中的创建型模式,用..
  • 抽象工厂模式的定义 Provide an Interface for creating families of related or dependent objects without specifying their concrete classes.(为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,713
精华内容 2,285
关键字:

抽象工厂模式造车