精华内容
下载资源
问答
  • 这是一个对于C#的抽象工厂模式的应用示例,比较简单,希望可以对新手有所帮助
  • 抽象工厂类的实现

    2018-04-04 19:59:00
    一、简单工厂模式和抽象工厂模式(1)简单工厂模式有叫做静态工厂模式,是用来实例化目标的静态。简单工厂不满足 开闭原则(一个软件实体应当对扩展开放,对修改关闭)(2)工厂方法模式,克服了简单工厂模...

    为什么会经常使用工厂模式,因为工厂模式相当于创建实例对象的new ,我们经常要根据类Class生成实例对象,如A a=new A()工厂模式也是用来创建实例对象的,所以以后new时要考虑使用工厂模式。

    一、简单工厂模式和抽象工厂模式

    (1)简单工厂模式有叫做静态工厂模式,是用来实例化目标类的静态类。简单工厂不满足  开闭原则(一个软件实体应当对扩展开放,对修改关闭)

    (2)工厂方法模式,克服了简单工厂模式的 不满足开闭原则,当只有一个产品等级时,运用工厂方法,比如男人,包括黑种人,白种人,黄种人

    (3)而当又出现女人的时候,就得用抽象工厂模式了

    抽象工厂模式涉及到一下角色;

    (1)抽象工厂角色Factory:担任这个角色的是工厂模式的核心,他是与应用系统是商业逻辑无关的,通常使用接口或者抽象类来实现,如下图的Factory 和human.

    (2)具体工厂角色:这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象逻辑,而这个逻辑是与应用系统的商业逻辑紧密相关的,通常使用具体类来实现,如下图的 factoryA  FactoryB 以及Femalefatory  malefatory

    (3)抽象产品角色:担任这个角色的类是抽象工厂方法模式锁创建的对象的父类,或他们共同拥有的接口,通常使用接口火抽象类实现这一角色,如下面的Plant  fruit 以及 黄种人,白种人 ,黑种人

    (4)具体产品角色:抽象工厂模式所创建的任何产品对象都是某一具体产品类的是,这是客户最终需要的东西

    如下面的PlantA  PlantB fruitA  fruitB以及   男黑人 男白人  男黄人 女黑人  女白人  女黄人

    抽象工厂的优点:产品从客户代码中被分离出来,容易改变产品的系列,将一个系列的产品族统一到一起创建如creatYellow() createBlack()  createWhite()

    缺点是在产品族里扩展新的产品很困难,比如又添加一个红色人种,这样就需要对human中添加createRed(),同时还要对具体的工厂方法中添加,如在mailFactory中添加,但是在产品等级中添加新的产品时比较好办,直接添加一个新的具体工厂类就可以了



    展开全文
  • 使用简单工厂模式模拟女娲(Nvwa)造人(Person),如果传入参数M,则返回一个Man对象,如果传入参数W,则返回一个Woman对象,请实现该场景。现需要增加一个新的Robot,如果传入参数R,则返回一个Robot对象,对...

    一、题目分析
    1、题目要求
    1.1、简单工厂模式
    使用简单工厂模式模拟女娲(Nvwa)造人(Person),如果传入参数M,则返回一个Man对象,如果传入参数W,则返回一个Woman对象,请实现该场景。现需要增加一个新的Robot类,如果传入参数R,则返回一个Robot对象,对代码进行修改并注意女娲的变化。
    1.2、工厂方法模式
    海尔工厂(Haier)生产海尔空调(HaierAirCondition),美的工厂(Midea)生产美的空调(MideaAirCondition) 。使用工厂方法模式描述该场景,绘制类图并编程实现。
    1.3、抽象工厂模式
    电脑配件生产工厂生产内存、CPU等硬件设备,这些内存、CPU的品牌、型号并不一定相同,根据下面的“产品等级结构-产品族”示意图,使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图,绘制类图并编程实现。
    在这里插入图片描述
    2、下面简单总结一下三种工厂方法
    2.1、简单工厂
    简单工厂模式:专门定义一个类用来创建其它类的实例,被创建的实例通常都具有共同的父类。
    概要:

    1. 一个抽象产品类
    2. 具体产品类
    3. 一个工厂
    

    优点:
    简单易于实现把类的实例化交给工厂,易于解耦。
    缺点:
    添加具体产品需要修改工厂违反OCP开放封闭原则
    2.2、工厂方法模式
    工厂方法模式:定义一个用来创建对象的接口,让子类决定实例化哪一个类,让子类决定实例化延迟到子类。
    工厂方法模式是针对每个产品提供一个工厂类,在客户端中判断使用哪个工厂类去创建对象。
    简单工厂模式 VS 工厂方法模式:
    对于简单工厂模式而言,创建对象的逻辑判断放在了工厂类中,客户不感知具体的类,但是其违背了开闭原则,如果要增加新的具体类,就必须修改工厂类。
    对于工厂方法模式而言,是通过扩展来新增具体类的,符合开闭原则,但是在客户端就必须要感知到具体的工厂类,也就是将判断逻辑由简单工厂的工厂类挪到客户端。工厂方法横向扩展很方便,假如该工厂又有新的产品要生产,那么只需要创建相应的工厂类和产品类去实现抽象工厂接口和抽象产品接口即可,而不用去修改原有已经存在的代码。
    概要:

    1. 一个抽象产品类
    2. 多个具体产品类
    3. 一个抽象工厂
    4. 多个具体工厂 - 每一个具体产品对应一个具体工厂
    

    优点:
    降低了代码耦合度,对象的生成交给子类去完成
    实现了开放封闭原则 - 每次添加子产品 不需要修改原有代码
    缺点:
    增加了代码量,每个具体产品都需要一个具体工厂
    当增加抽象产品 也就是添加一个其他产品族 需要修改工厂 违背OCP
    2.3、抽象工厂模式
    抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
    工厂方法模式和抽象工厂模式基本类似,可以这么理解:当工厂只生产一个产品的时候,即为工厂方法模式,而工厂如果生产两个或以上的商品即变为抽象工厂模式。
    概要:

    1. 多个抽象产品类
    2. 具体产品类
    3. 抽象工厂类 - 声明(一组)返回抽象产品的方法
    4. 具体工厂类 - 生成(一组)具体产品
    

    优点:
    实现多个产品族(相关联产品组成的家族),而工厂方法模式的单个产品,可以满足更多的生产需求很好的满足OCP开放封闭原则抽象工厂模式中我们可以定义实现不止一个接口,一个工厂也可以生成不止一个产品类 对于复杂对象的生产相当灵活易扩展
    缺点:
    扩展产品族相当麻烦,而且扩展产品族会违反OCP,因为要修改所有的工厂
    由于抽象工厂模式是工厂方法模式的扩展 总体的来说 很笨重

    二、类图设计
    使用简单工厂模式模拟女娲(Nvwa)造人(Person)
    在这里插入图片描述

    海尔工厂(Haier)生产海尔空调(HaierAirCondition),美的工厂(Midea)生产美的空调(MideaAirCondition) 。在这里插入图片描述

    电脑配件生产工厂生产内存、CPU等硬件设备,这些内存、CPU的品牌、型号并不一定相同,使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图
    在这里插入图片描述

    三、程序实现
    反射机制实现
    在这里插入图片描述
    如上图所示,程序设计一个CPU接口,继承它的子类用于生产CPU,Mac生产的CPU建立MacCpu继承它,Pc上产的CPU建立PcCpu继承它。同理一个RAM接口,分别由Mac和Pc的厂家的MacRam和PcRam继承,即可生产RAM,建立一个接口IFactory,用来描述生产产品,里面包含生产CPU和生产RAM方法,继承继承该接口的类都是每一个厂家的工厂,即如图所示,MacFactory为Mac的工厂,它可以生产他们厂的CPU和RAM,PcFactory也是如此。
    最重要的类莫过于Factory类,Client类通过调用它的静态方法getInstance方法参数classname为该类的全名称,通过Class.forName(类名)获得这个具体工厂类的类,通过newInstance方法实例化具体该工厂类的对象。但是因为我们不知道用户(Client)具体会想要哪一个工厂的产品,所以在抽象工厂中使用IFactory用来接收通过类名实例化的具体工厂。这样,用户只需要在传类名的时候指明具体工厂类就行了。通过IFactory下面的抽象方法,可以调用具体子类工厂的创造具体产品方法。主要类如下。
    Client用户类:

    public class Client {
        public void buyCpu(CPU cpu) {
            cpu.printCpu();
        }
        public void buyRam(RAM ram) {
            ram.printRam();
        }
        public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
            Client client = new Client();
            IFactory macFactory = Factory.getInstance("www.homework.embarkationfournext.reflect.MacFactory");
            client.buyCpu(macFactory.createCpu());
            client.buyRam(macFactory.createRam());
           IFactory pcFactory = Factory.getInstance("www.homework.embarkationfournext.reflect.PcFactory");
            client.buyCpu(pcFactory.createCpu());
            client.buyRam(pcFactory.createRam());
        }
    }
    

    Factory类:

    public class Factory {
        public static IFactory getInstance(String classname) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
            IFactory iFactory = (IFactory) Class.forName(classname).newInstance();
            return iFactory;
        }
    }
    

    IFactory接口:

    public interface IFactory {
        CPU createCpu();
        RAM createRam();
    }
    Mac工厂类:
    public class MacFactory implements IFactory {
        @Override
        public CPU createCpu() {
            return new MacCpu();
        }
    
        @Override
        public RAM createRam() {
            return new MacRam();
        }
    }
    

    Pc工厂的实现同Mac工厂

    四、调试、测试及运行结果
    4.1调试截图
    4.1.1简单工厂模式

    类型为M则person的实例化为Man
    在这里插入图片描述
    类型为W则person的实例化为Woman
    在这里插入图片描述
    类型为R则person的实例化为Robot
    在这里插入图片描述
    4.1.2工厂方法模式

    AirConditionFactory haierFactory = new HaierFactory();
    Client client = new Client();
    client.buyAirCondition(haierFactory.createAriCondition());
    AirConditionFactory mideaFactory = new MideaFactory();
    client.buyAirCondition(mideaFactory.createAriCondition());
    

    实例化海尔工厂hierFactory、美的工厂MideaFactory,对应指定的工厂,通过工厂生产各自的品牌的空调
    在这里插入图片描述
    4.1.3抽象工厂模式
    实例化Client对象client
    macFactory通过类名从工厂获得实例化MacFactory对象
    PcFactory通过类名从工厂获得实例化PCFactory对象
    在这里插入图片描述
    4.2测试截图
    4.2.1简单工厂模式
    输入M创造男人
    在这里插入图片描述
    输入W创造女人
    在这里插入图片描述
    输入R创造机器人
    在这里插入图片描述
    4.2.2工厂方法模式
    实例不同工厂调用创建空调方法,创建不同品牌空调
    在这里插入图片描述
    4.2.3抽象工厂模式
    通过反射传入两个工厂类MacFactory和PCFactory的类名,实例化两个工厂的实例,通过createCpu()和createRam()生产不同厂的CPU、RAM。
    在这里插入图片描述
    五、经验归纳

    简单工厂模式最大的优点就是工厂内有具体的逻辑去判断生成什么产品,将类的实例化交给了工厂,这样当我们需要什么产品只需要修改工厂的调用而不需要去修改客户端,对于客户端来说降低了与具体产品的依赖工厂方法模式是简单工厂的扩展,工厂方法模式把原先简单工厂中的实现那个类的逻辑判断交给了客户端,如果像添加功能只需要修改客户和添加具体的功能,不用去修改之前的类。
    抽象工厂模式进一步扩展了工厂方法模式,它把原先的工厂方法模式中只能有一个抽象产品不能添加产品族的缺点克服了,抽象工厂模式不仅仅遵循了OCP原则,而且可以添加更多产品(抽象产品),具体工厂也不仅仅可以生成单一产品,而是生成一组产品,抽象工厂也是声明一组产品,对应扩展更加灵活,但是要是扩展族系就会很笨重。

    展开全文
  • 本文实例讲述了Python设计模式之抽象工厂模式原理与用法。分享给大家供大家参考,具体如下: 抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们的 下面是一个...
  • 抽象工厂模式

    万次阅读 2018-05-23 16:11:27
    一,定义 抽象工厂模式:提供一个...它有多个抽象产品,每个抽象产品可以派生出多个具体产品,一个抽象工厂类,可以派生出多个具体工厂,每个具体工厂可以创建多个具体产品的实例。 二,实例 我们...

    一,定义

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

    当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口,使客户端在不必指定产品的具体的情况下,创建多个产品对象。它有多个抽象产品类,每个抽象产品类可以派生出多个具体产品类,一个抽象工厂类,可以派生出多个具体工厂类,每个具体工厂类可以创建多个具体产品类的实例。

    二,实例

    我们将实现一个用数据库插入数据的需求,但是可能会用到Sql server 和 Access两种数据库。具体结构如下
    这里写图片描述

    从结构图我们可以看到,他和工厂方法模式基本一样,区别在于,抽象工厂模式,提供一个创建一系列相关或者相互依赖对象的接口。

    三,优缺点

    优点:
    易于交换产品系列,由于具体工厂类在一个应用中只需要在初始化的时候出现一次,这使得改变一个应用的具体工厂变得很容易,只需要改变具体工厂即可使用不同的产品配置。

    让具体的创建实例过程与客户端分离,客户端是通过他们的抽象接口操作实例,产品的具体类名也被具体工厂实现分离,不会出现在代码中

    缺点:
    如果需求来自于增加功能,我们将会发现,我们需要增加很多的类才得以实现。

    工厂模式根据抽象程度的不同分为三种:
    - 简单工厂模式(也叫静态工厂模式)
    - 工厂方法模式(也叫多形性工厂)
    - 抽象工厂模式(也叫工具箱)

    参考:《大话设计模式》

    实现源码:https://github.com/wangxp423/ExerciseDesignmodel

    展开全文
  • 简单工厂:是由一个工厂对象决定创建出哪一种产品的实例。 A实例调用B实例的方法,称为A依赖于B。如果使用new关键字来创建一个B实例(硬编码耦合),然后调用B实例的方法。一旦系统需要重构:需要使用C来代替B...

    简单工厂:是由一个工厂对象决定创建出哪一种产品类的实例。

    A实例调用B实例的方法,称为A依赖于B。如果使用new关键字来创建一个B实例(硬编码耦合),然后调用B实例的方法。一旦系统需要重构:需要使用C类来代替B类时,程序不得不改写A类代码。而用工厂模式则不需要关心B对象的实现、创建过程。


     //抽象产品
        public abstract class Car
        {
            public abstract void Drive();
    
        }
        //具体产品
        public class Benz : Car
        {
            public override void Drive()
            {
                Console.WriteLine("开奔驰");
            }
        }
        //具体产品
        public class Bmw : Car
        {
            public override void Drive()
            {
                Console.WriteLine("开宝马");
            }
        }
        //简单工厂
        public class Driver
        {
            public static Car DriveCar(string carName)
            {
                Car cc;
                if (carName == "奔驰")
                {
                    cc = new Benz();
                }
                else
                {
                    cc = new Bmw();
                }
                return cc;
            }
        }
        //客户
        public class Boss
        {
            Car cars = Driver.DriveCar("奔驰");
            cars.Drive();
            
            Car cars2 = Driver.DriveCar("宝马");
            cars2.Drive();
        }

    使用简单工厂模式的优势: 让对象的调用者和对象创建过程分离,当对象调用者需要对象时,直接向工厂请求即可。从而避免了对象的调用者与对象的实现类以硬编码方式耦合,以提高系统的可维护性、可扩展性。工厂模式也有一个小小的缺陷:当产品修改时,工厂类也要做相应的修改,违反了开-闭原则。如上例,需要增加 奥迪 时,需要修改工厂类 Driver

    简单工厂模式适用于业务简单的情况下或者具体产品很少增加的情况。而对于复杂的业务环境可能不太适应了。这就应该由工厂方法模式来出场了!!

    工厂方法:

    不在工厂类中进行逻辑判断,程序可以为不同产品类提供不同的工厂,不同的工厂类和产不同的产品。当使用工厂方法设计模式时,对象调用者需要与具体的工厂类耦合


    //抽象产品
        public abstract class Car
        {
            public abstract void Drive();
    
        }
        //具体产品
        public class Benz : Car
        {
            public override void Drive()
            {
                Console.WriteLine("开奔驰");
            }
        }
        //具体产品
        public class Bmw : Car
        {
            public override void Drive()
            {
                Console.WriteLine("开宝马");
            }
        }
        //抽象工厂
        public abstract class Driver
        {
            public abstract Car DriveCar();
        }
        //具体工厂
        public class DriverBenz: Driver
        {
            public override Car DriveCar()
            {
                Car c = new Benz();
                return c;
            }
        }
        //具体工厂
        public class DriverBmz : Driver
        {
            public override Car DriveCar()
            {
                Car c = new Bmw();
                return c;
            }
        }
        //客户
        public class Boss
        {
            Driver dbenz = new DriverBenz();
            Car c = dbenz.DriveCar();
            c.Drive();
        }

    使用开闭原则来分析下工厂方法模式。当有新的产品产生时,只要按照抽象产品角色、抽象工厂角色提供的合同来生成,那么就可以被客户使用,而不必去修改任何已有的代码。(即当有新产品时,只要创建并基础抽象产品;新建具体工厂继承抽象工厂;而不用修改任何一个类) 工厂方法模式是完全符合开闭原则的!

    抽象工厂模式:

    先来认识下什么是产品族: 位于不同产品等级结构中,功能相关联的产品组成的家族。
    图中的BmwCar和BenzCar就是两个产品树(产品等级结构);而如图所示的BenzSportsCar和BmwSportsCar就是一个产品族。他们都可以放到跑车家族中,因此功能有所关联。同理BmwBussinessCar和BenzBusinessCar也是一个产品族。
    可以这么说,它和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。抽象工厂模式的用意为:给客户端提供一个接口,可以创建多个产品族中的产品对象。
    而且使用抽象工厂模式还要满足一下条件:
    1.系统中有多个产品族,而系统一次只可能消费其中一族产品
    2.同属于同一个产品族的产品以其使用。
    来看看抽象工厂模式的各个角色(和工厂方法的如出一辙):
    抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。它由抽象类或者接口来实现。
    具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
    抽象产品角色:它是具体产品继承的父类或者是实现的接口。一般有抽象类或者接口来实现。
    具体产品角色:具体工厂角色所创建的对象就是此角色的实例。由具体的类来实现。


    //抽象产品
        public abstract class BenzCar
        {
            public abstract void Drive();
    
        }
        //具体产品
        public class BenzSportCar : BenzCar
        {
            public override void Drive()
            {
                Console.WriteLine("开奔驰");
            }
        }
        //具体产品
        public class BenzBusinessCar : BenzCar
        {
            public override void Drive()
            {
                Console.WriteLine("开奔驰");
            }
        }
        //抽象产品
        public abstract class BmwCar
        {
            public abstract void Drive();
    
        }
        //具体产品
        public class BmwSportCar : BmwCar
        {
            public override void Drive()
            {
                Console.WriteLine("开宝马");
            }
        }
        //具体产品
        public class BmwBusinessCar : BmwCar
        {
            public override void Drive()
            {
                Console.WriteLine("开宝马");
            }
        }
        //抽象工厂
        public abstract class Driver
        {
            public abstract BenzCar DriveBenzCar();
            public abstract BmwCar DriveBmwCar();
        }
        //具体工厂
        public class SportDriver : Driver
        {
            public override BenzCar DriveBenzCar()
            {
                BenzSportCar benzsport = new BenzSportCar();
                return benzsport;
            }
            public override BmwCar DriveBmwCar()
            {
                BmwSportCar bmwsport = new BmwSportCar();
                return bmwsport;
            }
        }
        //具体工厂
        public class BusinessDriver : Driver
        {
            public override BenzCar DriveBenzCar()
            {
                BenzBusinessCar benzbusiness = new BenzBusinessCar();
                return benzbusiness;
            }
            public override BmwCar DriveBmwCar()
            {
                BmwBusinessCar bmwbusiness = new BmwBusinessCar();
                return bmwbusiness;
            }
        }
        //客户
        public class Boss
        {
            Driver dbenz = new SportDriver();
            BenzCar c = dbenz.DriveBenzCar();
            c.Drive();
        }
    所以抽象工厂模式一般用于具有产品树和产品族的场景下。
    抽象工厂模式的缺点:如果需要增加新的产品树,那么就要新增三个产品类,比如VolvoCar,VolvoSportCar,VolvoBusinessCar,并且要修改三个工厂类。这样大批量的改动是很丑陋的做法。
    所以可以用简单工厂配合反射来改进抽象工厂:

    展开全文
  • 抽象工厂

    万次阅读 多人点赞 2018-09-09 18:30:12
    定义 :抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口,无需指定它们具体的 创建型 :创建型 适用场景: 客户端(应用层)不依赖于产品实例如何被创建、实现等细节 强调一系列相关的产品对象...
  • 工厂方法模式的核心是抽象工厂类Factory,各种具体工厂继承抽象工厂类并实现在抽象工厂类中定义的工厂方法,从而让客户只关心抽象产品和抽象工厂,不用管具体返回的是哪一种具体产品,也不用关心它是如何被具体工厂...
  • 主要介绍了JavaScript设计模式之工厂模式和抽象工厂模式,结合实例形式分析了工厂模式的功能、定义、相关问题解决方法,并分析抽象工厂模式与工厂模式的不同之处,需要的朋友可以参考下
  • 主要介绍了Java设计模式之工厂模式,结合实例形式分析了简单工厂、工厂方法、抽象工厂等相关功能、实现与使用方法,需要的朋友可以参考下
  • Java设计模式—工厂方法模式&抽象工厂模式

    万次阅读 多人点赞 2016-09-11 15:07:17
    (尊重劳动成果,转载请注明出处:...抽象工厂类 具体的工厂 场景: 工厂方法模式的优点: 使用场景: 工厂方法模式的扩展: (1)简单工厂模式 (2)多工厂模式 抽象工厂模式...
  • 设计模式 - 创建型模式 - 抽象工厂模式(Java)

    万次阅读 多人点赞 2019-02-02 15:16:02
    分享一个大牛的人工智能教程。... } 当然,抽象工厂的问题也是显而易见的,比如我们要加个显示器,就需要修改所有的工厂,给所有的工厂都加上制造显示器的方法。这有点违反了对修改关闭,对扩展开放这个设计原则。
  • 抽象工厂模式的区别及优缺点及使用场景简单工厂普通简单工厂多方法简单工厂静态方法简单工厂工厂方法模式抽象工厂模式 工厂模式是java设计模式中比较简单的一个设计模式,但很多地方都用到了工厂模式,(如解析xml...
  • 一个借口可以有不同的实现,A,B,C。只要用抽象工厂,传一个字符串或者数字就可以选择返回A,B,C等的实例,有了他的实例其...就算以后在加N个,只要实现接口,在抽象工厂类方法里加一个CASE就可以了。
  • 常用设计模式-抽象工厂

    万次阅读 2020-11-19 17:18:48
    模式简介 工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三: 1. 简单工厂模式(Simple Factory) 2. 工厂方法模式(Factory Method) ...在抽象工厂模式中,接口是负责创建一
  • 首先,把简单工厂、工厂方法以及抽象工厂放在一起来学习主要是为了让我们更加清晰的了解、掌握它们的区别以及使用的场合。工厂方法的出现是解决简单工厂出现的问题(违背了设计原则的开闭原则OCP),而抽象工厂是...
  •  即定义一个创建对象的接口(即抽象工厂类),让其子类(具体工厂)决定实例化哪一个(具体产品)。“一对一”的关系。    抽象工厂:多个抽象产品,派生出多个具体产品;一个抽象工厂类,派生出多个...
  • 带有常用的数据库工厂实体,可直接使用,但本人拥有版权,请注意,还有用户一般常用的方法,和数据库,存储过程等!抽象工厂模式(方法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 157,990
精华内容 63,196
关键字:

抽象工厂类的用法