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

    千次阅读 2019-09-25 20:07:55
    抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在抽象工厂模式中,接口是负责...

    抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

    在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

    介绍

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

    主要解决:主要解决接口选择的问题。

    何时使用:系统的产品有多于一个的产品族,而系统只消费其中某一族的产品。

    如何解决:在一个产品族里面,定义多个产品。

    关键代码:在一个工厂里聚合多个同类产品。

    应用实例:工作了,为了参加一些聚会,肯定有两套或多套衣服吧,比如说有商务装(成套,一系列具体产品)、时尚装(成套,一系列具体产品),甚至对于一个家庭来说,可能有商务女装、商务男装、时尚女装、时尚男装,这些也都是成套的,即一系列具体产品。假设一种情况(现实中是不存在的,要不然,没法进入共产主义了,但有利于说明抽象工厂模式),在您的家中,某一个衣柜(具体工厂)只能存放某一种这样的衣服(成套,一系列具体产品),每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OOP 的思想去理解,所有的衣柜(具体工厂)都是衣柜类的(抽象工厂)某一个,而每一件成套的衣服又包括具体的上衣(某一具体产品),裤子(某一具体产品),这些具体的上衣其实也都是上衣(抽象产品),具体的裤子也都是裤子(另一个抽象产品)。

    优点:当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。

    缺点:产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的 Creator 里加代码,又要在具体的里面加代码。

    使用场景 :1、QQ 换皮肤,一整套一起换。 2、生成不同操作系统的程序。

    注意事项:产品族难扩展,产品等级易扩展。

    实现

    我们将创建 ShapeColor 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactoryColorFactory,这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer

    AbstractFactoryPatternDemo,我们的演示类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 ShapeCIRCLE / RECTANGLE / SQUARE),以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 ColorRED / GREEN / BLUE),以便获取它所需对象的类型。
    抽象工厂模式

    步骤 1

    为形状创建一个接口。

    Shape.java

    public interface Shape {
        void draw();
    }
    

    步骤 2

    创建实现接口的实体类。

    Rectangle.java

    public class Rectangle implements Shape {
        @Override
        public void draw() {
            System.out.println("Inside Rectangle::draw() method.");
        }
    }
    

    Square.java

    public class Square implements Shape {
        @Override
        public void draw() {
            System.out.println("Inside Square::draw() method.");
        }
    }
    

    Circle.java

    public class Circle implements Shape {
        @Override
        public void draw() {
            System.out.println("Inside Circle::draw() method.");
        }
    }
    

    步骤 3

    为颜色创建一个接口。

    Color.java

    public interface Color {
        void fill();
    }
    

    步骤4

    创建实现接口的实体类。

    Red.java

    public class Red implements Color {
        @Override
        public void fill() {
            System.out.println("Inside Red::fille() method.");
        }
    }
    

    Green.java

    public class Green implements Color {
        @Override
        public void fill() {
            System.out.println("Inside Green::fille() method.");
        }
    }
    

    Blue.java

    public class Blue implements Color {
        @Override
        public void fill() {
            System.out.println("Inside Blue::fille() method.");
        }
    }
    

    步骤 5

    为 Color 和 Shape 对象创建抽象类来获取工厂。

    AbstractFactory.java

    public abstract class AbstractFactory {
        abstract Shape getShape(String shape);
        abstract Color getColor(String color);
    }
    

    步骤 6

    创建扩展了 AbstractFactory 的工厂类,基于给定的信息生成实体类的对象。

    ShapeFactory.java

    public class ShapeFactory extends AbstractFactory {
    
        @Override
        Shape getShape(String shape) {
            if (shape == null) {
                return null;
            }
    
            shape = shape.toLowerCase();
    
            switch (shape) {
                case "circle":
                    return new Circle();
                case "rectangle":
                    return new Rectangle();
                case "square":
                    return new Square();
                default:
                    return null;
            }
    
        }
    
        @Override
        Color getColor(String color) {
            return null;
        }
    
    }
    

    ColorFactory.java

    public class ColorFactory extends AbstractFactory {
    
        @Override
        Shape getShape(String shape) {
            return null;
        }
    
        @Override
        Color getColor(String color) {
            if (color == null) {
                return null;
            }
    
            color = color.toLowerCase();
            switch (color) {
                case "red":
                    return new Red();
                case "blue":
                    return new Blue();
                case "green":
                    return new Green();
                default:
                    return null;
            }
        }
    
    }
    

    步骤 7

    创建一个工厂创造器/生成器类,通过传递形状或颜色信息来获取工厂。

    FactoryProducer.java

    public class FactoryProducer {
    
        public static AbstractFactory getFactory(String choice) {
            if (choice == null) {
                return null;
            }
    
            if ("shape".equalsIgnoreCase(choice)) {
                return new ShapeFactory();
            } else if ("color".equalsIgnoreCase(choice)) {
                return new ColorFactory();
            } else {
                return null;
            }
        }
    
    }
    

    步骤 8

    使用 FactoryProducer 来获取 AbstractFactory,通过传递类型信息来获取实体类的对象。

    AbstractFactoryPatternDemo.java

    public class AbstractFactoryDemo {
    
        public static void main(String[] args) {
            //获取形状工厂
            AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
    
            //获取形状为 Circle 的对象
            Shape shape1 = shapeFactory.getShape("CIRCLE");
            //调用 Circle 的 draw 方法
            shape1.draw();
    
            //获取形状为 Rectangle 的对象
            Shape shape2 = shapeFactory.getShape("RECTANGLE");
            //调用 Rectangle 的 draw 方法
            shape2.draw();
    
            //获取形状为 Square 的对象
            Shape shape3 = shapeFactory.getShape("SQUARE");
            shape3.draw();
    
            //获取颜色工厂
            AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
    
            //获取颜色为 Red 的对象
            Color color1 = colorFactory.getColor("RED");
            //调用 Red 的 fill 方法
            color1.fill();
    
            //获取颜色为 Green 的对象
            Color color2 = colorFactory.getColor("Green");
            //调用 Green 的 fill 方法
            color2.fill();
    
            //获取颜色为 Blue 的对象
            Color color3 = colorFactory.getColor("BLUE");
            //调用 Blue 的 fill 方法
            color3.fill();
        }
    
    }
    

    步骤 9

    验证输出。

    Inside Circle::draw() method.
    Inside Rectangle::draw() method.
    Inside Square::draw() method.
    Inside Red::fill() method.
    Inside Green::fill() method.
    Inside Blue::fill() method.
    
    展开全文
  • 设计模式 - 抽象工厂模式

    千次阅读 2019-08-20 09:57:25
    文章目录设计模式 - 抽象工厂模式1、意图2、实例1、定义颜色,样式接口2、定义颜色,样式枚举3、定义颜色实例4、定义样式实例5、定义工厂接口 - 可以创建不同的工厂6、定义颜色工厂7、定义样式工厂8、定义工厂枚举 -...

    设计模式 - 抽象工厂模式


    1、意图

    提供一个接口,用于创建 相关的对象家族

    抽象工厂模式创建的是对象家族,也就是很多对象而不是一个对象,并且这些对象是相关的,也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象,这和抽象工厂模式有很大不同

    2、实例</

    展开全文
  • 设计模式:抽象工厂模式 抽象工厂模式简介: 简介:抽象工厂模式是一种创建型模式,围绕一个超级工厂创建其他工厂。 意图:提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们的具体类 主要解决: ...

    设计模式:抽象工厂模式

    • 抽象工厂模式简介:
      • 简介:抽象工厂模式是一种创建型模式,围绕一个超级工厂创建其他工厂。
      • 意图:提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们的具体类
      • 主要解决: 解决接口选择问题
      • 使用场景: 系统的产品有多余一个的产品族,而系统只消灭其中某一族的产品。
    • 抽象工厂模式成分
      • 产品族A,B接口
      • 产品族A,B的实现
      • 工厂抽象方法:包含获取两个产品族的方法
      • 获取不同产品族的工厂实现
      • 工厂生成器
    • 抽象工厂优缺点
      • 优点:
        1. 当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象
      • 缺点:
        1. 产品族扩展非常困难,要增加一个系列的某个产品,既要在抽象的creator里加代码,又要在具体的里面加代码
    • 抽象工厂模式实现
      • 产品族的抽象
        package com.fg.java.factory;
        
        public interface Person {
            public void sayName();
        }
        package com.fg.java.factory;
        
        /**
         * 枪的抽象类
         */
        public interface Gun {
            public void SayName();
        }
        

         

      • 产品族的实现
        Person:
        package com.fg.java.factory;
        
        public class HaoTianPerson implements Person {
            public void sayName() {
                System.out.println("my name is HaoTian");
            }
        }
        
        package com.fg.java.factory;
        
        public class WangMuPerson implements Person {
            public void sayName() {
                System.out.println("My name is WangMu");
            }
        }
        

        Gun:
         

        package com.fg.java.factory;
        
        public class M416 implements Gun {
            public void SayName() {
                System.out.println("I`m M416");
            }
        }
        
        package com.fg.java.factory;
        
        public class UZI implements Gun {
            public void SayName() {
                System.out.println("I`m UZI");
            }
        }
        

         

      • 产品工厂抽象
        package com.fg.java.factory;
        
        public abstract class AbstractFactory {
            public abstract Gun getGun(String gun);
            public abstract Person getPerson(String peson);
        }
        

         

      • 产品工厂实现
        PersonFactory:
        package com.fg.java.factory;
        
        public class PersonFactory  extends AbstractFactory{
            @Override
            public Person getPerson(String peson) {
                if(peson == null){
                   return null;
                }
                if("HaoTian".equalsIgnoreCase(peson)){
                    return new HaoTianPerson();
                } else if("WangMu".equalsIgnoreCase(peson)){
                    return new WangMuPerson();
                }
                return null;
            }
        
            @Override
            public Gun getGun(String gun) {
                return null;
            }
        }
        

        GunFacotory:
         

        package com.fg.java.factory;
        
        public class GunFactory  extends AbstractFactory{
            @Override
            public Gun getGun(String gun) {
                if(gun == null){
                    return null;
                }
                if("M416".equalsIgnoreCase(gun)){
                    return new M416();
                }else if("UZI".equalsIgnoreCase(gun)){
                    return new UZI();
                }
                return null;
            }
        
            @Override
            public Person getPerson(String peson) {
                return null;
            }
        }
        

         

      • 生产者
        工厂实现:
        package com.fg.java.factory;
        
        public class FactoryProducer {
            public static AbstractFactory getFactory(String choice){
                if("GUN".equalsIgnoreCase(choice)){
                    return new GunFactory();
                }else if("Person".equalsIgnoreCase(choice)){
                    return new PersonFactory();
                }
                return null;
            }
        }
        

         

    展开全文
  • 设计模式之工厂模式(简单工厂模式,工厂方法模式,抽象工厂模式)工厂模式介绍简单工厂模式工厂方法模式抽象工厂模式 工厂模式 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式...

    设计模式之工厂模式(简单工厂模式,工厂方法模式,抽象工厂模式)

    工厂模式

    工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

    在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。

    介绍

    意图:定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。

    主要解决:主要解决接口选择的问题。

    何时使用:我们明确地计划不同条件下创建不同实例时。

    如何解决:让其子类实现工厂接口,返回的也是一个抽象的产品。

    关键代码:创建过程在其子类执行。

    应用实例: 1、您需要一台电脑,可以直接从工厂里面提货,而不用去管台电脑是怎么做出来的,以及这台电脑里面的具体实现。

    优点: 1、一个调用者想创建一个对象,只要知道其名称就可以了。 2、扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现,调用者只关心产品的接口。

    缺点:每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖。这并不是什么好事。

    注意事项:作为一种创建类模式,在任何需要生成复杂对象的地方,都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式,而简单对象,特别是只需要通过 new 就可以完成创建的对象,无需使用工厂模式。如果使用工厂模式,就需要引入一个工厂类,会增加系统的复杂度。

    简单工厂模式

    在这里插入图片描述
    1、首先我们创建一个抽象产品类接口Computer.java,它是工厂类所创建的所有产品对象的父类,所创建的具体产品对象都是其子类对象;

    package factory;
    /**
     * 抽象接口
     * @author wf
     */
    public interface Computer {
        void creatComputer();
    }
    

    2、然后我们创建具体产品类DellComputer.java,HaseeComputer.java,LenovoComputer.java,它们是简单工厂模式的创建目标,也是抽象产品接口的子类;

    package factory;
    
    /**
     * Dell电脑
     * @author wf
     */
    public class DellComputer implements Computer {
        @Override
        public void creatComputer() {
            System.out.println("Create a dell computer...");
        }
    }
    
    package factory;
    
    /**
     * Hasee电脑
     * @author wf
     */
    public class HaseeComputer implements Computer {
        @Override
        public void creatComputer() {
            System.out.println("CreateFactory a hasee computer...");
        }
    }
    
    package factory;
    
    /**
     * Lenovo电脑
     * @author wf
     */
    public class LenovoComputer implements Computer {
        @Override
        public void creatComputer() {
            System.out.println("CreateFactory a lenovo computer...");
        }
    }
    

    3、准备工作做好后,我们开始创建工厂角色CreateFactory .java,工厂角色即工厂类,它是简单工厂模式的核心,负责实现创建所有产品实例的内部逻辑;工厂类可以被外界直接调用,创建所需的产品对象;

    package factory;
    
    /**
     * 根据传进来的参数的产品类型来 生产/创建 真实的产品实体对象
     * @author wf
     */
    public class CreateFactory {
        public static Computer createComputer(String type) {
            if(type.equals("dellcomputer"))
            	return new DellComputer();
            else if (type.equals("haseecomputer"))
                return new HaseeComputer();
            else if(type.equals("lenovocomputer"))
                return new LenovoComputer();
            else System.out.println("no "+type +" computer");
            return null;
        }
    }
    
    

    4、客户端调用工厂类静态方法创建产品:Client.java

    package factory;
    
    public class Client {
        public static void main(String[] args)
        {
            Computer computer = CreateFactory.createComputer("haseecomputer");
            computer.creatComputer();
        }
    }
    

    输出为:CreateFactory a hasee computer…

    简单工厂类负责了所有产品的创建逻辑,当我们需要新引进一个新产品时,就不得不修改工厂类的产品创建逻辑,在产品类型较多时有可能会造成工厂类的产品创建逻辑过于负责,违背了java设计原则的开-闭原则,不利于系统的维护性和扩展性;

    为了解决上面的问题,下面我们介绍工厂模式的第二种,工厂方法模式。

    工厂方法模式

    工厂方法模式,又称工厂模式、多态工厂模式和虚拟构造器模式,通过定义工厂父类负责定义创建对象的公共接口,而子类则负责生成具体的对象。工厂方法模式将类的实例化(具体产品的创建)延迟到工厂类的子类(具体工厂)中完成,即由子类来决定应该实例化(创建)哪一个类。解决了简单工厂模式中一旦需要生产新产品就需要修改工厂类的方法逻辑的问题。
    在这里插入图片描述

    1、首先我们要创造抽象工厂类AbstractFactory.java,定义具体工厂的公共接口

    package factory;
    
    /**
     * 抽象工厂类,定义具体工厂的公共接口
     * @author wf
     */
    public interface AbstractFactory {
        public Computer computerFactory();
    }
    

    2、创建抽象产品类Computer.java ,定义具体产品的公共接口

    package factory;
    
    /**
     * 抽象产品类,定义具体产品的公共接口
     * @author wf
     */
    public interface Computer {
        void creatComputer();
    }
    

    3、创建具体产品类(继承抽象产品类)DellComputer.java,HaseeComputer.java,LenovoComputer.java, 定义生产的具体产品,以下不一一列出

    package factory;
    
    /**
     * Dell电脑
     * @author wf
     */
    public class DellComputer implements Computer {
        @Override
        public void creatComputer() {
            System.out.println("Create a dell computer...");
        }
    }
    

    4、创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;

    package factory;
    
    public class DellComputerFactory implements AbstractFactory {
        @Override
        public Computer computerFactory() {
            return new DellComputer();
        }
    }
    
    

    5、外界通过调用具体工厂类的方法,从而创建不同具体产品类的实例

    package factory;
    
    public class Client {
        public static void main(String[] args)
        {
            DellComputerFactory dellComputerFactory = new DellComputerFactory();
            dellComputerFactory.computerFactory().creatComputer();
        }
    }
    

    输出:Create a dell computer…

    优点:
    更符合开-闭原则
    新增一种产品时,只需要增加相应的具体产品类和相应的工厂子类即可
    符合单一职责原则
    每个具体工厂类只负责创建对应的产品
    工厂方法模式可以说是简单工厂模式的进一步抽象和拓展,在保留了简单工厂的封装优点的同时,让扩展变得简单,让继承变得可行,增加了多态性的体现。

    抽象工厂模式

    我们在生产电脑的时候,不同电脑的配置都不同,CPU、主板等配件也不同,这时我们就要用到抽象工厂模式,与工厂方法模式相比,抽象工厂模式中的具体工厂不只是创建一种产品,它负责创建一族产品。
    在这里插入图片描述

    参与者

    (1) AbstractFactory(抽象工厂):它声明了一组用于创建一族产品的方法,每一个方法对应一种产品。如上图UML类图中的Factory。

    (2) ConcreteFactory(具体工厂):它实现了在抽象工厂中声明的创建产品的方法,生成一组具体产品,这些产品构成了一个产品族,每一个产品都位于某个产品等级结构中。如上图UML类图中的DellComputerFactory和HaseeComputerFactory。

    (3) AbstractProduct(抽象产品):它为每种产品声明接口,如上图UML类图中的CPU和MainBoard。

    (4) ConcreteProduct(具体产品):它定义具体工厂生产的具体产品对象,实现抽象产品接口中声明的业务方法。如上图UML类图中的InterCPU,InterMainBorad,AMDCpu,AMDBoard。

    为了方便理解,我们在上述的基础上进行修改

    1、两种产品类接口: Cpu.java,MainBoard.java

    package factory;
    
    /**
     * 主板
     */
    public interface Cpu{
    }
    
    package factory;
    
    /**
     * 主板
     */
    public interface MainBoard {
    }
    

    2、具体产品类AMDCpu.java,AMDMainBoard,InterCpu.java,InterMainBoard.java

    package factory;
    
    /**
     * InterCPU
     */
    public class InterCpu implements Cpu {
        public InterCpu()
        {
            System.out.println("Create a InterCpu");
        }
    }
    
    package factory;
    
    /**
     * Inter主板
     */
    public class InterMainBoard implements MainBoard {
        public InterMainBoard()
        {
            System.out.println("Create a nterMainBoard...");
        }
    }
    
    package factory;
    
    /**
     * AMDCPU
     */
    public class AMDCpu implements Cpu {
        public AMDCpu()
        {
            System.out.println("Create a  AMDCpu");
        }
    }
    
    package factory;
    
    /**
     * AMD主板
     */
    public class AMDMainBoard implements MainBoard {
        public AMDMainBoard()
        {
            System.out.println("Create a AMDMainBoard...");
        }
    }
    

    3、抽象工厂类AbstractFactory .java

    package factory;
    
    /**
     * 抽象工厂类,定义具体工厂的公共接口
     * @author wf
     */
    public interface AbstractFactory {
        public Computer computerFactory();
        public Cpu createCpu();
        public MainBoard createMainBoard();
    }
    
    

    4、具体工厂类,只负责生产所需产品

    package factory;
    
    public class DellComputerFactory implements AbstractFactory {
        @Override
        public Computer computerFactory() {
            return new DellComputer();
        }
    
        @Override
        public Cpu createCpu() {
            return new InterCpu();
        }
    
        @Override
        public MainBoard createMainBoard() {
            return new InterMainBoard();
        }
    }
    

    5、生产电脑

    package factory;
    
    public class Client {
        public static void main(String[] args)
        {
            AbstractFactory factory=null;
            factory = new DellComputerFactory();
            factory.createCpu();
            factory.createMainBoard();
            factory.computerFactory().creatComputer();
        }
    }
    

    输出:
    Create a InterCpu
    Create a InterMainBoard…
    Create a dell computer…
    、抽象工厂模式是工厂方法模式的进一步延伸。在抽象工厂模式中,增加新的产品族很方便,但是增加新的产品等级结构很麻烦。

    总体来说,工厂模式适合:凡是出现了大量的产品需要创建,并且具有共同的接口时,可以通过工厂方法模式进行创建。在以上的三种模式中,第一种如果传入的字符串有误,不能正确创建对象,第三种相对于第二种,不需要实例化工厂类,所以,大多数情况下,我们会选用第三种——静态工厂方法模式。

    展开全文
  • 抽象工厂模式(Abstact Factory)是一种常见的软件设计模式。该模式为一个产品族提供了统一的创建接口。当需要这个产品族的某一系列的时候,可以为此系列的产品族创建一个具体的工厂类。 一、意图 抽象工厂模式提供...
  • 抽象工厂模式抽象工厂模式(Abstract Factory)定义简介实现要点总结 抽象工厂模式(Abstract Factory) 定义 抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式...
  • 创建型模式——抽象工厂模式

    千次阅读 2018-03-10 10:40:27
    抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在抽象工厂模式中,接口是负责...
  • 抽象工厂模式 抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在抽象工厂模式中...
  • 抽象工厂模式 抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在抽象工厂模式...
  • 抽象工厂模式(Abstact Factory)是一种常见的软件设计模式。该模式为一个产品族提供了统一的创建接口。当需要这个产品族的某一系列的时候,可以为此系列的产品族创建一个 具体的工厂类。 【意图抽象工厂模式提供...
  • 抽象工厂模式 抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在抽象工厂模式...
  • 抽象工厂模式简介 抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。抽象工厂模式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,612
精华内容 5,444
关键字:

抽象工厂模式的意图是