精华内容
下载资源
问答
  • 生产对象的工厂

    2018-09-18 10:51:40
    工厂的概念:用来生产产品的地方,同一种类型产品会有具体的不同产品对象。 1、简单工厂:提供一个方法,根据客户端提供的参数创建对应的产品对象并返回,具体创建那种对象逻辑封装到工厂类中( 可以使用反射+配置...

    简单工厂+工厂方法+抽象方法

    • 概念
    • 区别
    • 类图
    • 代码实例

    概念

    工厂的概念:用来生产产品的地方,同一种类型产品会有具体的不同产品对象。

    1、简单工厂:提供一个方法,根据客户端提供的参数创建对应的产品对象并返回,具体创建那种对象逻辑封装到工厂类中( 可以使用反射+配置文件 替代switch case)

    2、工厂方法:提供一个工厂抽象类用来产生该类产品类型对象,如果想产生具体产品对象则需创建一个该产品类型的工厂,并实现抽象方法创建具体产品对象并返回

    3、抽象工厂:专门用来生产一系列产品的工厂, 工厂方法可以看作是只产生一种产品的抽象工厂模式,而抽象工厂模式是工厂方法的推广

    例如: 电冰箱可以有美的电冰箱或奥克斯电冰箱 电脑也是,有个抽象工厂类用来生产电冰箱、电脑,然后美的工厂和奥克斯工厂来实现该类则创建对应的产品对象

    区别

    如果新增加一个具体产品,如果是简单工厂则需要更改简单工厂类,加个分支逻辑,也就是违背了开闭原则(对扩展open 对修改close),而工厂方法则需要增加一个具体产品工厂类,当然也有不好之处,多增加一个类同时也要需要修改客户端类,也就是判断用那个工厂对象逻辑由客户端做了。

    1、简单工厂 : 用来生产同一等级结构中的任意产品。(不支持拓展增加产品)

    2、工厂方法 :用来生产同一等级结构中的固定产品。(支持拓展增加产品)可以动态添加电器类的产品(电脑、微波炉)

    3、抽象工厂 :用来生产不同产品族的全部产品。(不支持拓展增加产品 (例如原来某个工厂生产空调、电视、电脑如果想加一个微波炉就要修改抽象类了);支持增加产品族)可以动态添加生产松下空调、松下电脑、松下电视

    类图

    以下UML图分别为:简单工厂、工厂方法、抽象工厂

    在这里插入图片描述

    代码实例

    场景:
    现在有个电器类,其类型下有空调、电视、电脑等产品
    1、我想根据传入一个产品类型,进而获取对应的对象(简单工厂) 例如传一个air然后获取到空调对象
    2、我想要不该动原来类的基础上,增添一个新的产品,例如我想加个微波炉产品,那么只能使用工厂方法,动态增加一个微波炉工厂类就行
    3、现在需求该了,我想获取一个产品族,例如美的旗下的空调,电视,电脑对象,那么就需要使用抽象工厂

    Electrics 抽象产品类型

    /**
     * @author duanyimiao
     * @create 2018-09-08 3:44 PM
     * @description 电器类
     **/
    public abstract class Electrics {
         String name;
    
          public String getName(){
            return name;
        }
    
    }
    
    

    AirConditioner 具体产品对象

    /**
     * @author duanyimiao
     * @create 2018-09-08 3:44 PM
     * @description 空调
     **/
    public class AirConditioner extends Electrics{
    
        public AirConditioner(){
            name = "空调";
        }
    
    }
    

    Tv 具体产品对象

    /**
     * @author duanyimiao
     * @create 2018-09-08 3:44 PM
     * @description 电视
     **/
    public class Tv extends Electrics{
    
        public Tv(){
            name = "电视";
        }
    
    }
    
    

    SimpleFactory 简单工厂

    /**
     * @author duanyimiao
     * @create 2018-09-08 3:39 PM
     * @description 简单工厂模式,根据客户端输入的参数产生不同的产品对象
     **/
    public class SimpleFactory {
        public static String type = "Tv";
        //TODO 当使用反射形式 type1 可不用传
        public static Electrics createElectric(String type1) {
            try {
       /*     switch (type) {
                case "conditioner":
                    return new AirConditioner();
                case "tv":
                    return new Tv();
                default:return null;
            }*/
                //使用反射替代 switch case,后可以把type参数放在配置文件中
                return (Electrics)Class.forName("com.dynamo.factory.product." + type).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
    
            }
            return null;
        }
    }
    

    工厂方法

    FactoryMethod

    /**
     * @author duanyimiao
     * @create 2018-09-08 4:04 PM
     * @description 工厂方法,支持动态增加产品(只需要继承该类并返回新的产品对象),符合开闭原则
     **/
    public abstract class FactoryMethod {
    
        public abstract Electrics createElectrics();
    }
    

    TvFactory 电视工厂

    /**
     * @author duanyimiao
     * @create 2018-09-08 4:09 PM
     * @description 生产电视的工厂
     **/
    public class TvFactory extends FactoryMethod {
        @Override
        public Electrics createElectrics() {
            return new Tv();
        }
    }
    
    

    AirConditionerFactory 空调工厂

    /**
     * @author duanyimiao
     * @create 2018-09-08 4:09 PM
     * @description 生产空调的工厂
     **/
    public class AirConditionerFactory extends FactoryMethod {
        @Override
        public Electrics createElectrics() {
            return new AirConditioner();
        }
    }
    

    抽象工厂

    AbstractFactory 抽象工厂

    /**
     * @author duanyimiao
     * @create 2018-09-08 4:15 PM
     * @description 抽象工厂,可以产生一系列产品对象(产品族),例如美的族电器有美的空调、美的电视,同时也可以有奥克斯空调、奥克斯电视
     * 支持动态添加产品族,也就是可以动态添加 松下产品族(空调、电视),并不能动态添加产品,因为这些产品在AbstractFactory中写死了
     *
     * 定义一个生产空调和电视的抽象工厂(可以有美的工厂、奥克斯工厂)
     **/
    public abstract class AbstractFactory {
    
        public abstract AirConditioner createAirConditionor();
    
        public abstract Tv createTv();
    }
    

    AoesFactory 奥克斯工厂

    /**
     * @author duanyimiao
     * @create 2018-09-08 4:20 PM
     * @description 奥克斯工厂
     **/
    public class AoesFactory extends AbstractFactory {
        @Override
        public AirConditioner createAirConditionor() {
            return new AoesConditioner();
        }
    
        @Override
        public Tv createTv() {
            return new AoesTv();
        }
    }
    

    MeidiFactory 美的工厂

    /**
     * @author duanyimiao
     * @create 2018-09-08 4:20 PM
     * @description 美的工厂
     **/
    public class MeidiFactory extends AbstractFactory {
        @Override
        public AirConditioner createAirConditionor() {
            return new MediAirConditioner();
        }
    
        @Override
        public Tv createTv() {
            return new MeidiTv();
        }
    }
    

    MainTest 测试类

    /**
     * @author duanyimiao
     * @create 2018-09-08 3:52 PM
     * @description
     **/
    public class MainTest {
    
        public static void main(String[] args) {
            //简单工厂
            Electrics electrics = SimpleFactory.createElectric("tv");
            System.out.println(electrics.getName());
    
            //工厂方法,动态添加产品,如果需要电脑产品则需要实现一个电脑工厂
            FactoryMethod factoryMethod = new AirConditionerFactory();
            Electrics electrics1 = factoryMethod.createElectrics();
            System.out.println(electrics1.getName());
    
            //使用工厂方法好处:当使用工厂生产多个对象时,如果使用简单工厂会重复多次,如果更换另一种对象类型那么改动地方多,工厂方法就一处地方
            Electrics e1 = SimpleFactory.createElectric("tv");
            Electrics e2 = SimpleFactory.createElectric("tv");
            Electrics e3 = SimpleFactory.createElectric("tv");
            //工厂方法产生多个对象,如果更换生产对象则需要TvFactory替换对应工厂类
            FactoryMethod factoryMethod1 = new TvFactory();
            Electrics e11 = factoryMethod1.createElectrics();
            Electrics e12 = factoryMethod1.createElectrics();
            Electrics e13 = factoryMethod1.createElectrics();
    
            //抽象工厂模式
            AbstractFactory abstractFactory = new MeidiFactory();
            AirConditioner airConditioner = abstractFactory.createAirConditionor();
            Tv tv = abstractFactory.createTv();
            System.out.println(airConditioner.getName());
            System.out.println(tv.getName());
        }
    }
    

    输出结果:

    电视
    空调
    美的空调
    美的电视
    
    展开全文
  • 面向对象的基本概念

    2018-02-25 12:36:41
    从一本书到一家图书馆,单整数到整数列庞大数据库、极其复杂自动化工厂、航天飞机都可看作对象,它不仅能表示有形实体,也能表示无形(抽象)规则、计划或事件。对象由数据(描述事物属性)和作用于...
    面向对象的基本概念如下:

    对象:对象是要研究的任何事物。从一本书到一家图书馆,单的整数到整数列庞大的数据库、极其复杂的自动化工厂、航天飞机都可看作对象,它不仅能表示有形的实体,也能表示无形的(抽象的)规则、计划或事件。对象由数据(描述事物的属性)和作用于数据的操作(体现事物的行为)构成一独立整体。从程序设计者来看,对象是一个程序模块,从用户来看,对象为他们提供所希望的行为。在对内的操作通常称为方法。

    类:类是对象的模板。即类是对一组有相同属性和相同操作的对象的定义,一个类所包含的方法和数据描述一组对象的共同属性和行为。类是在对象之上的抽象,对象则是类的具体化,是类的实例。类可有其子类,也可有其它类,形成类层次结构。

    消息:消息是对象之间进行通信的一种规格说明。一般它由三部分组成:接收消息的对象、消息名及实际变元。

    面向对象主要特征:

    封装性:封装是一种信息隐蔽技术,它体现于类的说明,是对象的重要特性。封装使数据和加工该数据的方法(函数)封装为一个整体,以实现独立性很强的模块,使得用户只能见到对象的外特性(对象能接受哪些消息,具有那些处理能力),而对象的内特性(保存内部状态的私有数据和实现加工能力的算法)对用户是隐蔽的。封装的目的在于把对象的设计者和对象的使用者分开,使用者不必知晓行为实现的细节,只须用设计者提供的消息来访问该对象。

    继承性:继承性是子类自动共享父类之间数据和方法的机制。它由类的派生功能体现。一个类直接继承其它类的全部描述,同时可修改和扩充。继承具有传递性。继承分为单继承(一个子类只有一父类)和多重继承(一个类有多个父类)。类的对象是各自封闭的,如果没继承性机制,则类对象中数据、方法就会出现大量重复。继承不仅支持系统的可重用性,而且还促进系统的可扩充性。

    多态性:对象根据所接收的消息而做出动作。同一消息为不同的对象接受时可产生完全不同的行动,这种现象称为多态性。利用多态性用户可发送一个通用的信息,而将所有的实现细节都留给接受消息的对象自行决定,如是,同一消息即可调用不同的方法。例如:Print消息被发送给一图或表时调用的打印方法与将同样的Print消息发送给一正文文件而调用的打印方法会完全不同。多态性的实现受到继承性的支持,利用类继承的层次关系,把具有通用功能的协议存放在类层次中尽可能高的地方,而将实现这一功能的不同方法置于较低层次,这样,在这些低层次上生成的对象就能给通用消息以不同的响应。在OOPL中可通过在派生类中重定义基类函数(定义为重载函数或虚函数)来实现多态性。

    综上可知,在面对对象方法中,对象和传递消息分别表现事物及事物间相互联系的概念。类和继承是是适应人们一般思维方式的描述范式。方法是允许作用于该类对象上的各种操作。这种对象、类、消息和方法的程序设计范式的基本点在于对象的封装性和类的继承性。通过封装能将对象的定义和对象的实现分开,通过继承能体现类与类之间的关系,以及由此带来的动态联编和实体的多态性,从而构成了面向对象的基本特征。

    面向对象设计是一种把面向对象的思想应用于软件开发过程中,指导开发活动的系统方法,是建立在“对象”概念基础上的方法学。对象是由数据和容许的操作组成的封装体,与客观实体有直接对应关系,一个对象类定义了具有相似性质的一组对象。而每继承性是对具有层次关系的类的属性和操作进行共享的一种方式。所谓面向对象就是基于对象概念,以对象为中心,以类和继承为构造机制,来认识、理解、刻画客观世界和设计、构建相应的软件系统。。按照Bjarne STroustRUP的说法,面向对象的编程范式:

    l 决定你要的类;

    2 给每个类提供完整的一组操作;

    3 明确地使用继承来表现共同点。

    由这个定义,我们可以看出:面向对象设计就是“根据需求决定所需的类、类的操作以及类之间关联的过程”。


    1.什么是面向对象?

    面向对象是一种使用封装、继承、多态、抽象等思想进行软件的分析和开发的方法,而java就是一门面向对象编程的语言。

    2.谈谈你对封装的理解。

    封装就是将实体的属性和行为包装成一个具体的对象,并控制在程序中对其属性的读取、修改。并仅对外公开接口也就是方法,以隐藏对象的属性和实现细节的目的。

    3.谈谈你对java中继承的理解。

    继承就是从已有的类和接口中派生出一个新的类和接口,并根据继承规则能从父类和接口中吸收一些属性和行为作为己用,还可以能通过自定义一些自己的属性和方法来扩展新的能力。

    java中的类只能有一个父类,也就是说类不支持多继承机制,默认情况下java.lang.Object是一个类的直接父类;但是接口则可以继承多个父级接口,支持多继承。

    4.谈谈你对java中的多态的理解。

    多态分为编译时多态和运行时多态。

    编译时多态是指编译器编译期间,根据同一对象或者类中相同名称方法的参数列表的不同(函数签名不同),来决定调用那个方法的多态行为。也就是 指的是java中的方法重载。

    运行时多态是指程序运行期间,同一方法会根据调用对象的类型不同,分别去执行其实际的类型的相应方法。一般多发生在方法覆盖的情况下。

    动态绑定是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。

    5.谈谈你对抽象的理解。

    抽象就是通过特定的实例抽取共同特性后形成概念的过程。它强调主要特征,忽略次要特征。在java中主要体现在类上。


    展开全文
  • 用于快速创建对象的类方法,我们称之为类工厂方法 类工厂方法应用场景 类工厂方法中主要用于给对象分配存储空间和初始化这块存储空间 类工厂方法使用规范 规范: 一定是类方法+ 方法名称以类名称开头,首...

    类工厂方法

    用于快速创建对象的类方法, 我们称之为类工厂方法

     

    类工厂方法应用场景

    类工厂方法中主要用于给对象分配存储空间和初始化这块存储空间

     

    类工厂方法使用规范

    规范:

    一定是类方法 +

    方法名称以类的名称开头, 首字母小写

    一定有返回值, 返回值是id/instancetype

    在类工厂方法实现中,调用本类的构造方法,创建实例对象,并返回实例对象

    自定义类工厂方法是苹果的一个规范, 一般情况下, 我们会给一个类提供自定义构造方法和自定义类工厂方法用于创建一个对象

     


     

    类工厂方法在继承中的注意点

    以后但凡自定义类工厂方法, 在类工厂方法中创建对象一定要使用self来创建,一定不要使用类名来创建

     

     


     

    类的本质

     

    类其实也是一个对象, 这个对象会在这个类第一次被使用的时候创建

    只要有了类对象, 将来就可以通过类对象来创建实例对象

    实例对象中有一个isa指针, 指向创建自己的类对象

    类对象中保存了当前对象所有的对象方法

    当给一个实例对象发送消息的时候, 会根据实例对象中的isa指针去对应的类对象中查找

    所有类对象的继承关系就是元类对象的继承关系:

     

    获取类对象及类对象应用场景

    获取类对象

    使用class方法获取类对象

    // [实例对象 class];  [类名 class];

    Person *p1 = [[Person alloc] init];

    Person *p2 = [[Person alloc] init];

    // 一个类再内存中只有一份类对象

    Class c1 = [p1 class];

    Class c2 = [p2 class];

    Class c3 = [Person class];

    NSLog(@"c1 = %p, c2 = %p, c3 = %p", c1, c2, c3);

     

    类对象的应用场景

    用于创建实例对象

     

    Person *p3 = [[c1 alloc] init];

    p3.age = 30;

    NSLog(@"%i", p3.age);

    用于调用类方法

    [Person test];

    [c1 test];

    转载于:https://www.cnblogs.com/wc-Home/p/5243241.html

    展开全文
  • EmloyeeSystemDesignPatterns:这是一个.NET MVC Core项目,旨在使用LINQEF Core在SQL数据库中查询和执行操作来... 该项目的体系结构利用了不同的设计模式,例如简单工厂工厂方法设计模式等,以及面向对象原理的概念
  • struts2中的对象工厂和静态注入

    千次阅读 2014-08-06 17:11:41
    需要解决问题: struts2中像action result inteceptor 这些类都是由struts2怎么产生?...struts2使用了对象工厂objectFactory这个概念,下面我们来看一下objectFactory这个类结构 下面是objectFactory类图

    需要解决的问题:

    struts2中的像action result  inteceptor 这些类都是由struts2怎么产生的? 给你做,你会让他们怎么产生.带这这个问题,我们来看一下struts2中的对象工厂和静态注入

     

    struts2使用了对象工厂objectFactory这个概念,下面我们来看一下objectFactory这个类的结构

    下面是objectFactory的类图



    通过上面的各个方法,

    buildAction是用来创建action的

    buildInterceptor是用来创建interceptor

    buildResult是用来创建结果集…….

    我们知道了actionresult  inteceptor 这些类的创建方式,那么这个静态注入又是什么呢

    我们把静态和注入分开来理解

    何为静态:

    凡是在struts的xml文件中配置的bean,例如:

            <beantype="com.opensymphony.xwork2.ObjectFactory" name="struts"class="org.apache.struts2.impl.StrutsObjectFactory" />

          在服务器启动的时候就会加载,而且只加载一次,所以为静态

     

    何为注入:StrutsObjectFactory就给纳入到struts2容器中了,这样的现象为注入

     应用:值栈的实现类也是通过静态注入改变的

          <beantype="com.opensymphony.xwork2.util.ValueStackFactory"name="struts"class="com.opensymphony.xwork2.ognl.OgnlValueStackFactory" />

     

    举例说明:

    Public class strutsObjectFactory extend objectFactory {  //StrutsObjectFactory是借用ObjectFactorybuildAction方法创建action

    }

    struts2容器运行后,会加载struts-default.xml文件,而文件中配置有

    <beantype="com.opensymphony.xwork2.ObjectFactory" name="struts"class="org.apache.struts2.impl.StrutsObjectFactory" />

    说明:struts2容器会去读该配置文件中的这个配置,然后决定action是由哪个类来创建的

     

    之后通过bean的内容找到相应的类来创建,这就是struts2的对象工厂和静态注入,在这里只是简单的讲解一下,没有深入去剖析.


    展开全文
  • 用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程; 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类,无须对原工厂进行任何修改,满足开闭原则; 3>缺点: 每增加一...
  • 什么是面向对象 顾名思义,就是和对象面对面,关注于对象 面向对象是一种编程思想,不是语法 我们一般写代码是通过逻辑分析,先做...批量创建相同结构对象的这个函数就是工厂函数 工厂函数创建对象有一个缺点,就是不
  • mybatis实践-objectFactory对象工厂 前言 概念 截图来自http://www.mybatis.org/mybatis-3/zh/configuration.html#objectFactory 理解 根据文档说明objectFactory是每次返回数据时,会利用objectFactory来生产...
  • 工厂模式是java中一大特点,关于工厂模式三种概念详解小伙伴们了解吗?本篇文章就来听小编讲解讲解。简单工厂模式角色分配:1. 工厂(Factory)角色 :简单工厂模式核心,它负责实现创建所有实例内部逻辑。工厂类...
  • 抽象工厂模式的概念 抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向 客户端提供一个接口,使得客户端在不必指定产品的具体类型的情况下,能够创建多个产品 族的产品对象。 抽象工厂...
  • 在前面一章我们介绍了依赖注入,控制反转的概念,以及自己动手搭建了一下Spring.Net的环境。通过这些操作,我们知道了Spring.Net 的核心是使用依赖注入或控制反转这种思想来管理业务对象,降低程序的依赖耦合。这一...
  • 简单工厂模式的概念 简单工厂模式属于类的创建型模式,又叫做静态工厂方法模式。通过专门定义一个类来负 责创建其他类的实例,被创建的实例通常都具有共同的父类。 具体分类 工厂(Creator)角色 简单工厂模式的核心...
  • 本文先介绍了抽象工厂模式的概念及简单实现。再介绍了netty中对抽象工厂模式的实现。最后总结了一点点思考。 抽象工厂模式 概念实现netty 中的抽象工厂模式思考 概念 定义:为创建一组相关或相互依赖的对象提供一个...
  • 定义:工厂模式专门负责将大量有共同接口类实例化。工厂模式可以动态决定将哪一个类实例化,而不必事先知道每次要实例化哪一个类...适用场景:工厂类负责创建的对象比较少:由于创建的对象比较少,不会造成工厂方...
  • 定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中。 核心工厂类不再负责产品创建,这样核心类成为一个抽象工厂角色,仅负责具体工厂子类 必须实现接口,这样进一步抽象化好处是使得工厂方法模式...
  • 工厂模式作用: 实现了创建者和调用者分离 详细分类: 简单工厂模式 工厂方法模式 抽象工厂模式 ...实例化对象不使用new,用工厂方法代替 将选择实现类,创建对象统一管理和控制,从而将调用者和实现解耦 ...
  • 搞了三年的过程化语言,关于对象的概念以前也粗略的了解过,忘了那本书介绍的,说一辆车就是对象,那时候的理解也就是对象就是封装的概念。最近看了一本JavaScript的书,书中举了个例子,对我很有启发。写道:人呢,...
  • 我女朋友愿意和我一起骑着单车,享受着属于我们时光,每次她那纯真笑容,让我心情特别舒畅。 冬天时候,骑在单车上特别冷,这时候...在代码中什么是工厂:通过定义一个单独创建对象的类来创建其它...
  • 工厂类,配置文件,静态,反射方法构成编译器解耦;ioc一个概念 转载于:https://www.cnblogs.com/classmethond/p/10747884.html
  • 围绕一个超级工厂创建其他工厂,该超级工厂为其他工厂的工厂 它提供了一个创建一系列相关或者相互依赖对象的接口,无需指定它们具体的类 优点: 具体产品在应用层的代码隔离,无需关心创建细节 将一个系列产品放到...
  • 相关概念:定义:工厂方法模式(FACTORY METHOD)是一种常用的对象创建型设计模式,此模式核心精神是封装类中不变部分,提取其中个性化善变部分为独立类,通过依赖注入以达到解耦、复用和方便后期维护拓展目的...
  • 一、设计模式的概念 1.设计模式简介 1.软件设计中的“三十六计” 2.是人们在长期的软件开发中的经验总结 3.是对某些特定问题的经过实践检验的特定解决方法 4.被广泛运用在Java框架技术中 2.设计模式的优点 ...
  • 约定优于配置是一个简单的概念。 系统,类库,框架应该假定合理的默认值,而非要求提供不必要的配置。 流行的框架如 Ruby on Rails 和 EJB3 已经开始坚持这些原则,以对像原始的 EJB 2.1 规范那样的框架的配置复杂度...
  • 抽象工厂模式向客户端提供一个接口,使得客户端在不必指定具体类型情况下,创建多个产品族中的对象。本文采取仍然是接着以前那个快餐店例子。 现在,快餐店经常良好,逐渐发展壮大,为了适合不同地方人...
  • 工厂的核心功能是生成电脑,所以有核心的抽象类或接口Computer 根据核心接口进行扩展,派生处具体的工厂产品,华为电脑(HWComputer)和苹果电脑(AppleComputer) public interface Computer { } public class ...
  • 创建bean对象的工厂 bean在计算机英语中,有可重用组件含义 可重用:可反复使用。组件:组成部分,比如service可以被servlet反复使用,dao被service使用。service可以看成是可重用组成部分。 javabean>=实体类...
  • spring-获取工厂对象

    2013-08-13 09:30:14
    这种方式与容器启动时创建的工厂是2个概念,在进行事务控制等方面会有问题! 仅测试用! package com.hqh.student.ws; import java.util.List; import javax.jws.WebService; import org.springframew...
  • 抽象工厂模式向客户端提供一个接口,使得客户端在不必指定具体类型情况下,创建多个产品族中的对象。本文采取仍然是接着以前那个快餐店例子。 现在,快餐店经常良好,逐渐发展壮大,为了适合不同地方人...

空空如也

空空如也

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

对象工厂的概念