精华内容
下载资源
问答
  • 抽象工厂模式
    千次阅读 多人点赞
    2021-12-11 20:20:47

    抽象工厂模式

    抽象工厂模式,亦称Abstract Factory。
    是一种创建型设计模式, 它能创建一系列相关的对象, 而无需指定其具体类。

    第一个例子:文具

    问题引入

    假设我们是一家文具店生产厂家,用代码模仿的话,我们需要代码中有一些类,用于表示:

    1. 一系列产品,例如笔、本子和尺子等。
    2. 系列产品中的不同类型,例如小学生套装(铅笔、田字格本、直尺)、中学生套装(钢笔、横线本、三角尺)、大学生套餐(圆珠笔、白纸本、尺子)。

    在这里插入图片描述我们需要单独生成每件文具对象,并且确保套餐中风格一致。如果大学生收到了小学生套餐的铅笔可就不好了。
    此外,我们也不希望未来在套餐中添加新产品去修该原有代码,放在实际生产中,厂家也不会因为添加新产品,去修改原有生产线,在代码中我们也不想频繁地修改核心代码!

    解决方案

    抽象工厂模式就解决了我们这种问题!
    抽象工厂模式建议为每类产品明确声明接口(例如笔、本子、尺子)。然后确保不同套餐中都继承这些接口,例如所有类型的笔,都要继承笔的接口!
    在这里插入图片描述

    接下来我们需要声明抽象工厂,包含套餐中所有产品构造方法的接口,也就是创建实例的办法,例如创建笔CreatePen()、创建本子CreateNoteBook()、创建尺子CreaterRuler()。
    这些方法必须返回抽象产品类型,即我们之前抽象的接口:笔、本子和尺子。
    在这里插入图片描述那么该如何处理产品变体呢? 对于系列产品的每个变体, 我们都将基于 抽象工厂接口创建不同的工厂类。 每个工厂类都只能返回特定类别的产品, 例如, 小学生套餐pupil只能生产铅笔、田字格本和直尺。
    客户端代码可以通过相应的抽象接口调用工厂和产品类。 你无需修改实际客户端代码, 就能更改传递给客户端的工厂类, 也能更改客户端代码接收的产品变体。
    在这里插入图片描述

    在这里插入图片描述假设客户端想要工厂创建一把尺子。 客户端无需了解工厂类, 也不用管工厂类创建出的尺子类型。 无论是小学生、初中生, 对于客户端来说没有分别, 它只需调用抽象尺子接口就可以了。 这样一来, 客户端只需知道椅子以某种方式实现尺子的作用就足够了。 此外, 无论工厂返回的是何种尺子变体, 它都会和由同一工厂对象创建的本子和笔是一个套餐。

    第二个问题家具

    第二个问题作为一个思考题。

    问题引入

    假设你正在开发一款家具商店模拟器。 你的代码中包括一些类, 用于表示:

    1. 一系列相关产品, 例如 椅子Chair 、 ​ 沙发Sofa和 咖啡桌Coffee­Table 。
    2. 系列产品的不同变体。 例如, 你可以使用 现代Modern 、 ​ 维多利亚Victorian 、 ​ 装饰风艺术Art­Deco等风格生成 椅子 、 ​ 沙发和 咖啡桌 。

    在这里插入图片描述

    你需要设法单独生成每件家具对象, 这样才能确保其风格一致。 如果顾客收到的家具风格不一样, 他们可不会开心。

    现代风格的沙发和维多利亚风格的椅子不搭。

    此外, 你也不希望在添加新产品或新风格时修改已有代码。 家具供应商对于产品目录的更新非常频繁, 你不会想在每次更新时都去修改核心代码的。

    解决方案

    答案在这里https://refactoringguru.cn/design-patterns/abstract-factory

    抽象工厂模式结构

    在这里插入图片描述

    1. 抽象产品 (Abstract Product) 为构成系列产品的一组不同但相关的产品声明接口。
    2. 具体产品 (Concrete Product) 是抽象产品的多种不同类型实现。 所有变体 (维多利亚/现代) 都必须实现相应的抽象产品(椅子/沙发)。
    3. 抽象工厂 (Abstract Factory) 接口声明了一组创建各种抽象产品的方法。
    4. 具体工厂 (Concrete Factory) 实现抽象工厂的构建方法。 每个具体工厂都对应特定产品变体, 且仅创建此种产品变体。
    5. 尽管具体工厂会对具体产品进行初始化, 其构建方法签名必须返回相应的抽象产品。 这样, 使用工厂类的客户端代码就不会与工厂创建的特定产品变体耦合。 客户端 (Client) 只需通过抽象接口调用工厂和产品对象,
      就能与任何具体工厂/产品变体交互。

    抽象工厂模式适合应用场景

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

    • 抽象工厂为你提供了一个接口, 可用于创建每个系列产品的对象。 只要代码通过该接口创建对象,那么你就不会生成与应用程序已生成的产品类型不一致的产品。

    • 如果你有一个基于一组抽象方法的类, 且其主要功能因此变得不明确, 那么在这种情况下可以考虑使用抽象工厂模式。

    • 在设计良好的程序中, 每个类仅负责一件事。 如果一个类与多种类型产品交互,就可以考虑将工厂方法抽取到独立的工厂类或具备完整功能的抽象工厂类中。

    实现方式

    1. 以不同的产品类型与产品变体为维度绘制矩阵。
    2. 为所有产品声明抽象产品接口。 然后让所有具体产品类实现这些接口。
    3. 声明抽象工厂接口, 并且在接口中为所有抽象产品提供一组构建方法。
    4. 为每种产品变体实现一个具体工厂类。
    5. 在应用程序中开发初始化代码。 该代码根据应用程序配置或当前环境, 对特定具体工厂类进行初始化。 然后将该工厂对象传递给所有需要创建产品的类。
    6. 找出代码中所有对产品构造函数的直接调用, 将其替换为对工厂对象中相应构建方法的调用。

    抽象工厂模式优缺点

    • 你可以确保同一工厂生成的产品相互匹配。
    • 你可以避免客户端和具体产品代码的耦合。
    • 单一职责原则。 你可以将产品生成代码抽取到同一位置, 使得代码易于维护。
    • 开闭原则。 向应用程序中引入新产品变体时, 你无需修改客户端代码。

    与其他模式的关系

    • 在许多设计工作的初期都会使用工厂方法模式 (较为简单, 而且可以更方便地通过子类进行定制), 随后演化为使用抽象工厂模式、
      原型模式或生成器模式 (更灵活但更加复杂)。
    • 生成器重点关注如何分步生成复杂对象。 抽象工厂专门用于生产一系列相关对象。 抽象工厂会马上返回产品,
      生成器则允许你在获取产品前执行一些额外构造步骤。
    • 抽象工厂模式通常基于一组工厂方法, 但你也可以使用原型模式来生成这些类的方法。
    • 当只需对客户端代码隐藏子系统创建对象的方式时, 你可以使用抽象工厂来代替外观模式。
    • 你可以将抽象工厂和桥接模式搭配使用。 如果由桥接定义的抽象只能与特定实现合作, 这一模式搭配就非常有用。 在这种情况下,
      抽象工厂可以对这些关系进行封装, 并且对客户端代码隐藏其复杂性。
    • 抽象工厂、 生成器和原型都可以用单例模式来实现。

    参考资料

    https://refactoringguru.cn/design-patterns/abstract-factory
    漫画:什么是 “抽象工厂模式” ?

    更多相关内容
  • 抽象工厂模式(Abstact Factory)是一种常见的软件设计模式。该模式为一个产品族提供了统一的创建接口。当需要这个产品族的某一系列的时候,可以为此系列的产品族创建一个 具体的工厂类。 【意图】 抽象工厂模式提供...
  • 浅析JS抽象工厂模式

    2020-11-26 11:32:25
    以下就是作者学习中遇到的问题以及代码实例,最后还给大家关于JS抽象工厂模式的学习做了总结。 抽象工厂模式(Abstract Factory)就是通过类的抽象使得业务适用于一个产品类簇的创建,而不负责某一类产品的实例。 JS中...
  • 工厂模式在一些设计模式的书中分为简单工厂模式,工厂方法模式和抽象工厂模式三类。也有把工厂方法模式划分到抽象工厂模式的,认为工厂方法是抽象工厂模式的特例的一种,就是只有一个要实现的产品接口。
  • 本文实例讲述了Python设计模式之抽象工厂模式原理与用法。分享给大家供大家参考,具体如下: 抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们的类 下面是一个...
  • 抽象工厂模式是对象的创建模式,它是工厂方法模式的进一步推广。 假设一个子系统需要一些产品对象,而这些产品又属于一个以上的产品等级结构。那么为了将消费这些产品对象的责任和创建这些产品对象的责任分割开来,...
  • 抽象工厂模式

    2017-06-29 17:25:09
    Qt实现的抽象工厂模式,抽象工厂,提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。对于工厂方法来说,抽象工厂可实现一系列产品的生产,抽象工厂更注重产品的组合。
  • 这就是我们要说的抽象工厂模式。提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。逻辑模型:物理模型:抽象工厂的目的是要提供一个创建一系列相关或相互依赖对象的接口,而不需要指定它们具体...
  • 抽象工厂模式说明 1. 工厂方法模式的问题: 在工厂方法模式里,创建类都需要通过 工厂类,如果要扩展程序,就必须修改工厂类,这违背了闭包原则,对扩展开放,对修改关闭;对于设计有一定的问题。   2. 如何解决:...
  •  抽象工厂模式为一个产品家族提供了统一的创建接口。当需要这个产品家族的某一系列的时候,可以从抽象工厂中选出相对应的系列来创建一个具体的工厂类别。 2. 抽象工厂模式中的角色  2.1 抽象工厂(Abstract...
  • 抽象工厂模式代码

    2017-08-31 09:11:04
    提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类。 通过主板和cpu组装电脑。这里主板的CPU插槽数要和CPU的针脚数相等,也就是说CPU对象和主板对象是有关联的,同时CPU种类和主板的种类也有很多...
  • 面向对象系统的分析和设计实际上追求的就是两点:高内聚(Cohesion)和低耦合(Coupling).
  • 主要为大家详细介绍了Python设计模式之抽象工厂模式,感兴趣的小伙伴们可以参考一下
  • 之前讲到了C++设计模式——工厂方法模式,我们可能会想到,后期产品会越来越多了,建立的工厂也会越来越多,工厂进行了增长,工厂变的凌乱而难于管理;由于工厂方法模式创建的对象都是继承于Product的,所以工厂方法...
  • 主要介绍了Java设计模式之抽象工厂模式,结合实例形式分析了抽象工厂模式的概念、功能、定义与使用方法,需要的朋友可以参考下
  • 主要介绍了PHP设计模式之抽象工厂模式,结合实例形式分析了php抽象工厂模式的概念、原理、使用方法及相关操作注意事项,需要的朋友可以参考下
  • 主要介绍了Java设计模式编程中的工厂方法模式和抽象工厂模式,设计模式的建立有利于团队协作时代码的共同维护,需要的朋友可以参考下
  • 主要介绍了php设计模式中的抽象工厂模式,使用php实现抽象工厂模式,感兴趣的小伙伴们可以参考一下
  • 设计模式C++学习之抽象工厂模式(AbstractFactory)
  • 设计模式-抽象工厂模式(讲解及其实现代码)
  • 介绍的是工厂模式 包括简单工厂模式、工厂方法模式、抽象工厂模式 包括PPT和代码
  • 主要介绍了C#的设计模式编程之抽象工厂模式的应用,注意区分一下简单工厂模式、工厂方法模式和抽象工厂模式概念之间的区别,需要的朋友可以参考下
  • 1、抽象工厂模式+反射技术 2、抽象工厂模式+简单工厂模式 3、仅仅是抽象工厂模式
  • java设计模式之抽象工厂模式,实例----手机工厂,一个简单的例子,有助于理解抽象工厂模式
  • 抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在抽象工厂模式中,接口是负责...
  • 工厂模式与抽象工厂模式

    万次阅读 2020-12-25 21:34:30
    抽象工厂模式 核心本质:  实例化对象不使用new,用工厂方法代替  将选择实现类,创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。 三种模式: ◆简单工厂模式  用来生产同一等级结构中的任意产品(对于...

    工厂模式

    模式定义:
    定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟到子类
    作用:实现了创建者和调用者的分离
    详细分类:
     简单工厂模式
     工厂方法模式
     抽象工厂模式

    核心本质:
     实例化对象不使用new,用工厂方法代替
     将选择实现类,创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。
    三种模式:
    ◆简单工厂模式
     用来生产同一等级结构中的任意产品(对于增加新的产品,需要修改已有代码),不满足开闭原则
    ◆工厂方法模式
     用来生产同一等级结构中的固定产品(支持增加任意产品),满足开闭原则
    ◆抽象工厂模式
     围绕-个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

    1.简单工厂模式

    例1:
    在这里插入图片描述
    在这里插入图片描述

    public interface Car {
        void name();
    
    }
    
    
    public class Tesla implements Car{
        @Override
        public void name() {
            System.out.println("特斯拉");
        }
    }
    
    
    public class Wuling implements Car{
        @Override
        public void name() {
            System.out.println("五菱宏光");
        }
    }
    
    
    //静态工厂模式
    //增加一个新产品,要修改原来代码,不满足开闭原则
    //开闭原则
    public class CarFactory {
    
        //方法一
        public static Car getCar(String car){
            if(car.equals("五菱")){
                return new Wuling();
            }else if(car.equals("特斯拉")){
                return new Tesla();
            }else {
                return null;
            }
        }
        //方法二
        public static Car getWuling(){
            return new Wuling();
        }
        public static Car getDazhong(){
            return new Dazhong();
        }
    }
    
    
    public class Consumer {
        public static void main(String[] args) {
            //1.传统方式
    //        Car car = new Wuling();
    //        Car car2 = new Tesla();
    //        car.name();
    //        car2.name();
            //2.使用工厂创建
            Car car = CarFactory.getCar("五菱");
            car.name();
    
        }
    
    }
    
    

    例2:
    在这里插入图片描述

    public class FactoryPatternDemo01 {
        public static void main(String[] args) {
            /**
             * 步骤 4
             * 使用该工厂,通过传递类型信息来获取实体类的对象。
             */
            ShapeFactory shapeFactory = new ShapeFactory();
            //获取 Circle 的对象,并调用它的 draw 方法
            Shape shape1 = shapeFactory.getShape("CIRCLE");
    
            //调用 Circle 的 draw 方法
            shape1.draw();
    
            //获取 Rectangle 的对象,并调用它的 draw 方法
            Shape shape2 = shapeFactory.getShape("RECTANGLE");
    
            //调用 Rectangle 的 draw 方法
            shape2.draw();
    
            //获取 Square 的对象,并调用它的 draw 方法
            Shape shape3 = shapeFactory.getShape("SQUARE");
    
            //调用 Square 的 draw 方法
            shape3.draw();
    
    
        }
    }
    
    /**
     * 步骤 1
     * 创建一个接口:
     */
    interface Shape{
        void draw();
    }
    
    /**
     * 步骤 2创建实现接口的实体类
     */
    class Rectangle implements Shape{
    
        @Override
        public void draw() {
            System.out.println("画长方形!!");
        }
    }
    
    class Square implements Shape{
        @Override
        public void draw(){
            System.out.println("画正方形!!");
        }
    }
    
    class Circle implements Shape {
    
        @Override
        public void draw() {
            System.out.println("画圆!");
        }
    }
    
    /**
     * 步骤 3
     * 创建一个工厂,生成基于给定信息的实体类的对象。
     */
    class ShapeFactory{
        //使用 getShape 方法获取形状类型的对象
        public Shape getShape(String shapeType){
            if(shapeType==null){
                return null;
            }
            if(shapeType.equalsIgnoreCase("CIRCLE")){
                return new Circle();
            } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
                return new Rectangle();
            } else if(shapeType.equalsIgnoreCase("SQUARE")){
                return new Square();
            }
            return null;
        }
    
    }
    
    




    2.工厂方法模式

    在这里插入图片描述
    在这里插入图片描述

    public interface Car {
        void name();
    
    }
    
    
    public class Tesla implements Car {
        @Override
        public void name() {
            System.out.println("特斯拉");
        }
    }
    
    
    public class Wuling implements Car {
        @Override
        public void name() {
            System.out.println("五菱宏光");
        }
    }
    
    
    public interface CarFactory {
        Car getCar();
    }
    
    
    public class TeslaFactory implements CarFactory{
        @Override
        public Car getCar() {
            return new Tesla();
        }
    }
    
    
    public class WulingFactory implements CarFactory{
        @Override
        public Car getCar() {
            return new Wuling();
        }
    }
    
    
    public class Consumer {
        public static void main(String[] args) {
           Car car = new WulingFactory().getCar();
           Car car1 = new TeslaFactory().getCar();
           car.name();
           car1.name();
    
        }
    
    }
    

    3.抽象工厂模式:

    ◆定义:抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口,无需指定它们具体的类(类似于工厂的工厂)
    适用场景:

    • 客户端(应用层)不依赖于产品类实例如何被创建、实现等细节
    • 强调一系列相关的产品对象(属于同- -产品族) -起使用创建对象需要大量的重复代码
    • 提供一个产品类的库,所有的产品以同样的接口出现,从而使得客户端不依赖于具体的实现

    优点:

    • 具体产品在应用层的代码隔离,无需关心创建的细节
    • 将一个系列的产品统一到一起创建

    缺点:

    • 规定了所有可能被创建的产品集合,产品簇中扩展新的产品困难;
    • 增加了系统的抽象性和理解难度

    在这里插入图片描述
    举例:
    在这里插入图片描述
    类图如下:
    在这里插入图片描述

    //抽象产品工厂,工厂的工厂
    public interface IProductFactory {
        //生产手机
        IphoneProduct iphoneProduct();
        //生产路由器
        IRouterProduct routerProduct();
    }
    
    
    //生产手机的工厂
    public interface IphoneProduct {
        void start();
        void shutdown();
        void callup();
        void sendSMS();
    }
    
    
    //生产路由器的工厂
    public interface IRouterProduct {
        void start();
        void shutdown();
        void openwifi();
        void setting();
    }
    
    
    //华为工厂
    public class HuaweiFactory implements IProductFactory{
        @Override
        public IphoneProduct iphoneProduct() {//生产手机
            return new HuaweiPhone();
        }
        @Override
        public IRouterProduct routerProduct() {//生产路由器
            return new HuaweiRouter();
        }
    }
    
    
    //华为手机
    public class HuaweiPhone implements IphoneProduct{
        @Override
        public void start() { System.out.println("打开华为手机"); }
    
        @Override
        public void shutdown() { System.out.println("关闭华为手机"); }
    
        @Override
        public void callup() { System.out.println("华为手机打电话"); }
    
        @Override
        public void sendSMS() { System.out.println("华为手机发短信"); }
    }
    
    
    //华为路由器
    public class HuaweiRouter implements IRouterProduct{
        @Override
        public void start() { System.out.println("启动华为路由器"); }
    
        @Override
        public void shutdown() { System.out.println("关闭华为wifi"); }
    
        @Override
        public void openwifi() { System.out.println("打开华为wifi"); }
    
        @Override
        public void setting() { System.out.println("华为路由器设置"); }
    }
    
    
    //小米工厂
    public class XiaomiFactory implements IProductFactory{
        @Override
        public IphoneProduct iphoneProduct() {//生产手机
            return new XiaomiPhone();
        }
        @Override
        public IRouterProduct routerProduct() {//生产路由器
            return new XiaomiRouter();
        }
    }
    
    
    //小米手机
    public class XiaomiPhone implements IphoneProduct{
        @Override
        public void start() { System.out.println("开启小米手机"); }
        @Override
        public void shutdown() { System.out.println("关闭小米手机"); }
        @Override
        public void callup() { System.out.println("小米打电话"); }
        @Override
        public void sendSMS() { System.out.println("小米发短信"); }
    }
    
    
    //小米路由器
    public class XiaomiRouter implements IRouterProduct{
        @Override
        public void start() { System.out.println("启动小米路由器"); }
    
        @Override
        public void shutdown() { System.out.println("关闭小米wifi"); }
    
        @Override
        public void openwifi() { System.out.println("打开小米wifi"); }
    
        @Override
        public void setting() { System.out.println("小米路由器设置"); }
    }
    
    
    public class Client {
        public static void main(String[] args) {
            //小米工厂
            System.out.println("==========小米系列产品=======");
            //小米手机
            XiaomiFactory xiaomiFactory = new XiaomiFactory();
            IphoneProduct iphoneProduct = xiaomiFactory.iphoneProduct();
            iphoneProduct.callup();
            iphoneProduct.sendSMS();
    
            //小米路由器
            IRouterProduct iRouterProduct = xiaomiFactory.routerProduct();
            iRouterProduct.openwifi();
    
            //华为工厂
            System.out.println("==========华为系列产品=======");
            //h华为手机
            HuaweiFactory huaweiFactory = new HuaweiFactory();
            IphoneProduct iphoneProduct2 = huaweiFactory.iphoneProduct();
            iphoneProduct2.callup();
            iphoneProduct2.sendSMS();
    
            //华为路由器
            IRouterProduct iRouterProduct2 = huaweiFactory.routerProduct();
            iRouterProduct2.openwifi();
    
    
        }
    }
    
    

    例2:
    在这里插入图片描述

    public class AbstractFactoryPatternDemo1 {
    
        /**
         * 步骤 8
         * 使用 FactoryProducer 来获取 AbstractFactory,通过传递类型信息来获取实体类的对象。
         * @param args
         */
        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");
    
            //调用 Square 的 draw 方法
            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();
        }
    }
    
    
    /**
     步骤 1
     为形状创建一个接口。
     */
    interface Shape{
        void draw();
    }
    
    /**
     * 步骤 2
     * 创建实现接口的实体类
     */
    class Rectangle implements Shape {
    
        @Override
        public void draw() {
            System.out.println("长方形::draw() method.");
        }
    }
    
    class Square implements Shape {
    
        @Override
        public void draw() {
            System.out.println("正方形::draw() method.");
        }
    }
    
    class Circle implements Shape {
    
        @Override
        public void draw() {
            System.out.println("I圆::draw() method.");
        }
    }
    
    /**
     * 步骤 3
     * 为颜色创建一个接口。
     */
    interface Color {
        void fill();
    }
    
    /**
     * 步骤4
     * 创建实现接口的实体类。
     */
    class Red implements Color {
    
        @Override
        public void fill() {
            System.out.println("Inside Red::fill() method.");
        }
    }
    class Green implements Color {
    
        @Override
        public void fill() {
            System.out.println("Inside Green::fill() method.");
        }
    }
    class Blue implements Color {
    
        @Override
        public void fill() {
            System.out.println("Inside Blue::fill() method.");
        }
    }
    
    /**
     * 步骤 5
     * 为 Color 和 Shape 对象创建抽象类来获取工厂。
     */
    abstract class AbstractFactory {
        public abstract Color getColor(String color);
        public abstract Shape getShape(String shape) ;
    }
    
    
    /**
     * 步骤 6
     * 创建扩展了 AbstractFactory 的工厂类,基于给定的信息生成实体类的对象。
     */
    class ShapeFactory extends AbstractFactory {
    
        @Override
        public Shape getShape(String shapeType){
            if(shapeType == null){
                return null;
            }
            if(shapeType.equalsIgnoreCase("CIRCLE")){
                return new Circle();
            } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
                return new Rectangle();
            } else if(shapeType.equalsIgnoreCase("SQUARE")){
                return new Square();
            }
            return null;
        }
    
        @Override
        public Color getColor(String color) {
            return null;
        }
    }
    
    class ColorFactory extends AbstractFactory {
    
        @Override
        public Shape getShape(String shapeType){
            return null;
        }
    
        @Override
        public Color getColor(String color) {
            if(color == null){
                return null;
            }
            if(color.equalsIgnoreCase("RED")){
                return new Red();
            } else if(color.equalsIgnoreCase("GREEN")){
                return new Green();
            } else if(color.equalsIgnoreCase("BLUE")){
                return new Blue();
            }
            return null;
        }
    }
    
    /**
     * 步骤 7
     * 创建一个工厂创造器/生成器类,通过传递形状或颜色信息来获取工厂。
     */
    class FactoryProducer {
        public static AbstractFactory getFactory(String choice){
            if(choice.equalsIgnoreCase("SHAPE")){
                return new ShapeFactory();
            } else if(choice.equalsIgnoreCase("COLOR")){
                return new ColorFactory();
            }
            return null;
        }
    }
    

    小结:
    ◆简单工厂模式(静态工厂模式)
    ◆虽然某种程度上不符合设计原则,但实际使用最多!
    ◆工厂方法模式
    ◆不修改已有类的前提下,通过增加新的工厂类实现扩展。
    ◆抽象工厂模式
    ◆不可以增加产品,可以增加产品族!

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 188,483
精华内容 75,393
关键字:

抽象工厂模式