精华内容
下载资源
问答
  • 抽象工厂模式造车

    2019-08-13 22:20:07
    可以用抽象工厂模式造车。 车的品牌有很多,而且车的属性也不少,比如车的类型、排量、门的数量,等等。可以提炼出有关车的一个抽象类: public abstract class Car { public string Model { get; set; } ...

     

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

     

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

     

    
     
        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、通过抽象工厂造车,必须把所有的细节都设计在代表车的抽象类中,扩展性不好

    转载于:https://www.cnblogs.com/darrenji/p/4619346.html

    展开全文
  • JAVA设计模式之抽象工厂模式

    万次阅读 多人点赞 2015-04-11 08:26:32
    本文属于23种设计模式系列。 继续前面简单工厂模式和工厂方法模式的例子,以汽车配件制造介绍抽象工厂模式
    本文继续介绍23种设计模式系列之抽象工厂模式。
    前面已经介绍过简单工厂模式和工厂方法模式,这里继续介绍第三种工厂模式-抽象工厂模式,还是以汽车的制造为例。

    例子背景:
    随着客户的要求越来越高,宝马车需要不同配置的空调和发动机等配件。于是这个工厂开始生产空调和发动机,用来组装汽车。这时候工厂有两个系列的产品:空调和发动机。 宝马320系列配置A型号空调和A型号发动机,宝马230系列配置B型号空调和B型号发动机。

    概念:
       抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。比如宝马320系列使用空调型号A和发动机型号A,而宝马230系列使用空调型号B和发动机型号B,那么使用抽象工厂模式,在为320系列生产相关配件时,就无需制定配件的型号,它会自动根据车型生产对应的配件型号A。

    针对百度百科上对于抽象工厂模式的简介,结合本例如下:

    当每个抽象产品都有多于一个的具体子类的时候(空调有型号A和B两种,发动机也有型号A和B两种),工厂角色怎么知道实例化哪一个子类呢?比如每个抽象产品角色都有两个具体产品(产品空调有两个具体产品空调A和空调B)。抽象工厂模式提供两个具体工厂角色(宝马320系列工厂和宝马230系列工厂),分别对应于这两个具体产品角色,每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

    抽象工厂模式代码

     产品类: 

    //发动机以及型号  
    public interface Engine {  
    
    }  
    public class EngineA extends Engine{  
        public EngineA(){  
            System.out.println("制造-->EngineA");  
        }  
    }  
    public class EngineBextends Engine{  
        public EngineB(){  
            System.out.println("制造-->EngineB");  
        }  
    }  
    
    //空调以及型号  
    public interface Aircondition {  
    
    }  
    public class AirconditionA extends Aircondition{  
        public AirconditionA(){  
            System.out.println("制造-->AirconditionA");  
        }  
    }  
    public class AirconditionB extends Aircondition{  
        public AirconditionB(){  
            System.out.println("制造-->AirconditionB");  
        }  
    } 


    创建工厂类:

    //创建工厂的接口  
    public interface AbstractFactory {  
        //制造发动机
        public Engine createEngine();
        //制造空调 
        public Aircondition createAircondition(); 
    }  
    
    
    //为宝马320系列生产配件  
    public class FactoryBMW320 implements AbstractFactory{  
          
        @Override  
        public Engine createEngine() {    
            return new EngineA();  
        }  
        @Override  
        public Aircondition createAircondition() {  
            return new AirconditionA();  
        }  
    }  
    //宝马523系列
    public class FactoryBMW523 implements AbstractFactory {  
      
         @Override  
        public Engine createEngine() {    
            return new EngineB();  
        }  
        @Override  
        public Aircondition createAircondition() {  
            return new AirconditionB();  
        }  
    
    
    } 

    客户:

    public class Customer {  
        public static void main(String[] args){  
            //生产宝马320系列配件
            FactoryBMW320 factoryBMW320 = new FactoryBMW320();  
            factoryBMW320.createEngine();
            factoryBMW320.createAircondition();
              
            //生产宝马523系列配件  
            FactoryBMW523 factoryBMW523 = new FactoryBMW523();  
            factoryBMW320.createEngine();
            factoryBMW320.createAircondition();
        }  
    }

    关于抽象工厂模式与工厂方法模式的区别,这里就不说了,感觉多看几遍例子就能理解,还有很多提到的产品族、等级结构等概念,说了反而更难理解。


    抽象工厂模式的起源
    下面引用一段抽象工厂模式的起源:

    抽象工厂模式的起源或者最早的应用,是用于创建分属于不同操作系统的视窗构建。比如:命令按键(Button)与文字框(Text)都是视窗构建,在UNIX操作系统的视窗环境和Windows操作系统的视窗环境中,这两个构建有不同的本地实现,它们的细节有所不同。
    在每一个操作系统中,都有一个视窗构建组成的构建家族。在这里就是Button和Text组成的产品族。而每一个视窗构件都构成自己的等级结构,由一个抽象角色给出抽象的功能描述,而由具体子类给出不同操作系统下的具体实现。

    可以发现在上面的产品类图中,有两个产品的等级结构,分别是Button等级结构和Text等级结构。同时有两个产品族,也就是UNIX产品族和Windows产品族。UNIX产品族由UNIX Button和UNIX Text产品构成;而Windows产品族由Windows Button和Windows Text产品构成。

    系统对产品对象的创建需求由一个工程的等级结构满足,其中有两个具体工程角色,即UnixFactory和WindowsFactory。UnixFactory对象负责创建Unix产品族中的产品,而WindowsFactory对象负责创建Windows产品族中的产品。这就是抽象工厂模式的应用,抽象工厂模式的解决方案如下图:

    显然,一个系统只能够在某一个操作系统的视窗环境下运行,而不能同时在不同的操作系统上运行。所以,系统实际上只能消费属于同一个产品族的产品。
    在现代的应用中,抽象工厂模式的使用范围已经大大扩大了,不再要求系统只能消费某一个产品族了。


    总结:
    无论是简单工厂模式,工厂方法模式,还是抽象工厂模式,他们都属于工厂模式,在形式和特点上也是极为相似的,他们的最终目的都是为了解耦。在使用时,我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式,因为他们之间的演变常常是令人琢磨不透的。经常你会发现,明明使用的工厂方法模式,当新需求来临,稍加修改,加入了一个新方法后,由于类中的产品构成了不同等级结构中的产品族,它就变成抽象工厂模式了;而对于抽象工厂模式,当减少一个方法使的提供的产品不再构成产品族之后,它就演变成了工厂方法模式。
           所以,在使用工厂模式时,只需要关心降低耦合度的目的是否达到了。

    作者:jason0539

    博客:http://blog.csdn.net/jason0539(转载请说明出处)

    扫码关注我微信公众号


    展开全文
  • 抽象工厂模式

    2018-03-06 23:27:12
    抽象工厂模式是工厂模式的升级版,在有多个业务品种、业务分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方式。。比如宝马320系列使用空调型号A和发动机型号A,而宝马230系列使用空调型号B和发动机型号B...

    定义

    创建一组相关或相互依赖的对象提供一个接口,而且无须指定它们的具体类。

    抽象工厂模式是工厂模式的升级版,在有多个业务品种、业务分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方式。。比如宝马320系列使用空调型号A和发动机型号A,而宝马230系列使用空调型号B和发动机型号B,那么使用抽象工厂模式,在为320系列生产相关配件时,就无需制定配件的型号,它会自动根据车型生产对应的配件型号A。

    当每个抽象产品都有多于一个的具体子类的时候(空调有型号A和B两种,发动机也有型号A和B两种),工厂角色怎么知道实例化哪一个子类呢?比如每个抽象产品角色都有两个具体产品(产品空调有两个具体产品空调A和空调B)。抽象工厂模式提供两个具体工厂角色(宝马320系列工厂和宝马230系列工厂),分别对应于这两个具体产品角色,每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
    案例:
    1.先定义产品接口(人类)

    public interface Engine {    
    } 

    2.创建目标子类

    public class EngineA extends Engine{    
        public EngineA(){    
            System.out.println("制造-->EngineA");    
        }    
    } 
    public class EngineBextends Engine{    
        public EngineB(){    
            System.out.println("制造-->EngineB");    
        }    
    } 
    //空调以及型号 
    public interface Aircondition {    
    } 
    public class AirconditionA extends Aircondition{    
        public AirconditionA(){    
            System.out.println("制造-->AirconditionA");    
        }    
    }    
    public class AirconditionB extends Aircondition{    
        public AirconditionB(){    
            System.out.println("制造-->AirconditionB");    
        }    
    }   

    现在我们需要为一种人创建一个工厂类,既然每一个人都有自己的工厂类,那是不是可以抽一个类呢,对的,我们就抽出一个工厂接口来。
    3.创建工厂接口

    //创建工厂的接口    
    public interface AbstractFactory {    
        //制造发动机  
        public Engine createEngine();  
        //制造空调   
        public Aircondition createAircondition();   
    }

    4.实现创建目标子类的具体工厂

    //为宝马320系列生产配件    
    public class FactoryBMW320 implements AbstractFactory{    
    
        @Override    
        public Engine createEngine() {      
            return new EngineA();    
        }    
        @Override    
        public Aircondition createAircondition() {    
            return new AirconditionA();    
        }    
    }    
    //宝马523系列  
    public class FactoryBMW523 implements AbstractFactory {    
    
         @Override    
        public Engine createEngine() {      
            return new EngineB();    
        }    
        @Override    
        public Aircondition createAircondition() {    
            return new AirconditionB();    
        }    
    }   

    6.客户端调用,符合了java的开发与闭包原则。

    public class Client {
        public static void main(String[] args){    
            //生产宝马320系列配件  
            FactoryBMW320 factoryBMW320 = new FactoryBMW320();    
            factoryBMW320.createEngine();  
            factoryBMW320.createAircondition();  
    
            //生产宝马523系列配件    
            FactoryBMW523 factoryBMW523 = new FactoryBMW523();    
            factoryBMW320.createEngine();  
            factoryBMW320.createAircondition();  
        }  
    }
    展开全文
  • 目录抽象工厂模式(Abstract Factory Pattern)抽象工厂模式何时用抽象工厂模式好处抽象工厂模式缺陷抽象工厂模式的代码实现业务需求设计思路代码实现结语 抽象工厂模式(Abstract Factory Pattern) 提供一个创建一...

    抽象工厂模式(Abstract Factory Pattern)

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

    抽象工厂模式何时用

    需要创建产品家族和想让制造的相关产品集体起来时使用。

    抽象工厂模式好处

    1. 易于交换“产品系列”,只要更改相应的工厂即可。

    抽象工厂模式缺陷

    1. 建立产品的时候比较繁琐,需要增加和修改较多东西。

    抽象工厂模式的代码实现

    业务需求

    有一个汽车厂商生产两种车辆,根据用户需求提供不同的车型。用户刚好有两种需求对应这两种车型:

    1. 需求:只买贵的,不买对的
    2. 需求:经济、安全、实用
    3. 假设生产一辆汽车需要车身轮胎两种对象(当然,实际生产中是更多的一系列对象)

    设计思路

    1. 定义车身基类CarBody,土豪车身CarBodyA,普通车身CarBodyB分别继承该基类;
    2. 定义轮胎基类CarTire,土豪轮胎CarTireA,普通轮胎CarTireB分别继承该基类;
    3. 定义生产车身与轮胎的原料工厂基类CarIngredientFactory,土豪原料工厂CarIngredientFactoryA,普通原料工厂CarIngredientFactoryB分别继承该基类;
    4. 定义汽车Car基类,基类中包含车身轮胎对象,土豪车CarA,普通车CarB分别继承自基类Car;
    5. 定义组装汽车的工厂基类CarFactory,土豪车组装厂,普通车组装厂分别继承自基类;
    6. 客户向不同的工厂订车后,工厂就会返回相应原料组成的成品车辆。

    代码实现

    为了实现上述需求,代码如下:

    # -*- coding: utf-8 -*-
    
    class CarBody: # 定义车身基类
    
        def report(self):
            pass
    
    class CarBodyA(CarBody): # 定义土豪车身类
    
        def report(self):
            return 'Expensive Body'
    
    class CarBodyB(CarBody): # 定义普通车身类
    
        def report(self):
            return 'Normal Body'
    
    class CarTire: # 定义车身基类
    
        def report(self):
            pass
    
    class CarTireA(CarTire): # 定义土豪车身类
    
        def report(self):
            return 'Expensive Tire'
    
    class CarTireB(CarTire): # 定义普通车身类
    
        def report(self):
            return 'Normal Tire'
    
    class CarIngredientFactory: # 定义原料抽象工厂类,包含用于生产一系列对象的接口
    
        def create_body(self):
            pass
    
        def create_tire(self):
            pass
    
    class CarIngredientFactoryA(CarIngredientFactory): # 土豪原料生产类
    
        def create_body(self):
            return CarBodyA()
    
        def create_tire(self):
            return CarTireA()
    
    class CarIngredientFactoryB(CarIngredientFactory): # 普通原料生产类
    
        def create_body(self):
            return CarBodyB()
    
        def create_tire(self):
            return CarTireB()
    
    class Car: # 定义汽车基类
    
        carBody = None
        carTire = None
    
        def __init__(self, ingredient_factory): # 接收原料工厂,用于获取不同的汽车配件
            self.ingredientFactory = ingredient_factory
            self.carBody = self.ingredientFactory.create_body() # 生产车身配件
            self.carTire = self.ingredientFactory.create_tire() # 生产轮胎配件
    
        def run(self):
            print('Speed: ' + str(self.speed))
    
        def description(self):
            print('The car are %s & %s.' % (self.carBody.report(), self.carTire.report()))
    
    class CarA(Car):  # 土豪车
    
        def __init__(self, ingredient_factory):
            Car.__init__(self, ingredient_factory)
            self.speed = 200
            print('I am rich. I can run faster.')
    
    
    class CarB(Car): # 普通车
    
        def __init__(self, ingredient_factory):
            Car.__init__(self, ingredient_factory)
            self.speed = 100
            print('I am normal. I can run.')
    
    class CarFactory: # 汽车工厂基类
    
        def get_car(self): # 工厂方法接口
            pass
    
    class CarAFactory(CarFactory):
    
        def get_car(self): # 土豪车 实现工厂方法接口
            return CarA(CarIngredientFactoryA())
    
    class CarBFactory(CarFactory):
    
        def get_car(self): # 普通车 实现工厂方法接口
            return CarB(CarIngredientFactoryB())
    
    if __name__ == '__main__':
    
        factoryA = CarAFactory() # 实例化一个土豪车厂
        factoryB = CarBFactory() # 实例化一个普通车厂
        a = factoryA.get_car()   # 根据车厂类型,获取相应的原料来组装并返回车辆
        a.run()
        a.description()
        b = factoryB.get_car()
        b.run()
        b.description()
    

    结语

    有时工厂方法模式抽象工厂模式很容易混淆,工厂方法模式是在基类中定义一个工厂的抽象接口,然后派生类负责创建具体对象;抽象工厂模式是维护一个产品家族,由基类定义产品被生产的方法,客户根据基类的接口进行开发。而抽象工厂模式中产品家族的具体某个对象,通常是由工厂方法来实现的。有点绕,需要仔细体会体会。

    展开全文
  • 工厂模式 工厂模式总的来说就是使用工厂方法来代替new创建对象。...3)抽象工厂模式(Abstract Factory) 简单工厂模式 建立一个工厂(一个函数或一个类方法)来制造新的对象。 /** * Created by du
  • 文章目录定义举个栗子抽象工厂模式的优点抽象工厂模式的缺点简单工厂、工厂模式、抽象工厂小结简单工厂工厂方法模式抽象工厂模式 Provide an interface for creating families of related or dependent objects ...
  • Java设计模式—工厂方法模式&抽象工厂模式

    万次阅读 多人点赞 2016-09-11 15:07:17
    (尊重劳动成果,转载请注明出处:https://blog.csdn.net/qq_25827845/article/details/52503884冷血之心的博客) 目录 工厂方法模式: 通用类图如下: 抽象产品类: 具体产品类 ...抽象工厂模式...
  • 抽象工厂模式 抽象工厂模式(Abstract Factory Pattern):为创建一组相关或相互依赖的对象提供一个接口,而且无须指定它们的具体类。 抽象工厂模式的优点: 封装性。高层模块只关心接口。 产品族内的约束为非...
  • 抽象工厂模式 抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。抽象工厂模式又称为Kit模式,属于对象创建型模式。 设计原则: 1.依赖抽象,不要依赖...
  • php-抽象工厂模式实现

    2021-08-07 18:09:07
    抽象工厂模式(Abstract Factory):抽象工厂模式是对工厂模式的抽象,通俗来说,就是把工厂模式的结构分离出来成为能独立运行的个体。 抽象工厂模式将工厂模式进行抽象,可以使得抽象出来的新结构更加的灵活。例如,...
  • 抽象工厂模式应用场景举例】  写到抽象工厂模式了,我深知“抽象工厂模式”博文会带来一点点高潮,因为程序员对工厂模式中的“抽象工厂”都是比较感冒的,而且关注也很多,我就尽量用我所能理解的那么点程度来...
  • 简单工厂模式、工厂方法模式、抽象工厂模式都属于创建型模式。创建型模式的主要关注点是“怎样创建对象?”,它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度,使用者不需要关注对象的创建细节...
  • 刚看到抽象工厂模式,发现抽象工厂模式是很想的,抽象工厂模式定义如下:为创建一组相关或相互依赖的对象提供一个接口,而且不需要指定它们的具体类 抽象工厂模式的通用类图如下: 每一个模式都是针对一定...
  • 抽象工厂模式为一个产品家族提供了统一的创建接口。当需要这个产品家族的某一系列的时候,可以从抽象工厂中选出相对系的系列来创建一个具体的工厂类别。一。简解抽象工厂模式顾名思义就是对工厂的抽象(这不是废话)...
  • 工厂模式有三种,简单工厂模式,工厂模式,抽象工厂模式 1.简单工厂模式: 简单将产品的制造进行封装,不分类别只是简单的 工厂和产品的依赖关系  具体要素: 工厂(静态工厂方法),抽象产品,具体产品 当然...
  • 抽象工厂模式从个人理解上来说适应的场景就是我们所做的事情有相同的也有不同的地方,例如:飞机,火车,汽车 相同的地方我们都可以轮子,车身,但是飞机得跑道,机翼,火车得铁轨,汽车得铁轨...
  • Java中的简单工厂模式 ...女娲人,这就是简单工厂模式的应用。  首先,在这个人的思想里面,有几个重要的角色:女娲本身、抽象的人的概念和女娲所出的一个个具体的人。  1.)女娲是一个工厂类,也就是简单工...
  • 本文继续介绍23种设计模式系列之抽象工厂模式。 前面已经介绍过简单工厂模式和工厂方法模式,这里继续介绍第三种工厂模式-抽象工厂模式,还是以汽车的制造为例。例子背景: 随着客户的要求越来越高,宝马需要...

空空如也

空空如也

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

抽象工厂模式造车