设计模式学习06(Java实现)——工厂模式

写在前面

记录学习设计模式的笔记
提高对设计模式的灵活运用

学习地址

https://www.bilibili.com/video/BV1G4411c7N4

https://www.bilibili.com/video/BV1Np4y1z7BU

参考文章

http://c.biancheng.net/view/1317.html

项目源码
https://gitee.com/zhuang-kang/DesignPattern

7，工厂模式

7.1 工厂模式的定义和特点

工厂模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”。

在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）。

简单来说，简单工厂模式有一个具体的工厂类，可以生成多个不同的产品，属于创建型设计模式。简单工厂模式不在 GoF 23 种设计模式之列。

简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。

优点：

工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
客户端无需知道所创建具体产品的类名，只需知道参数即可。
也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

缺点：

简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。
使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度
系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。

7.2 工厂模式的结构与实现

简单工厂模式的主要角色如下：

简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
具体产品（ConcreteProduct）：是简单工厂模式的创建目标。

Shape

package com.zhuang.factory.simplefactory;

/**
 * @Classname Shape
 * @Description  产品接口类
 * @Date 2021/3/18 15:40
 * @Created by dell
 */

public interface Shape {
    void draw();
}

Circle

package com.zhuang.factory.simplefactory;

/**
 * @Classname Circle
 * @Description 产品实现类
 * @Date 2021/3/18 15:43
 * @Created by dell
 */

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle-->绘制圆形");
    }
}

Rectangle

package com.zhuang.factory.simplefactory;

/**
 * @Classname Rectangle
 * @Description 产品实现类
 * @Date 2021/3/18 15:40
 * @Created by dell
 */

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle-->绘制长方形");
    }
}

Square

package com.zhuang.factory.simplefactory;

/**
 * @Classname Square
 * @Description 产品实现类
 * @Date 2021/3/18 15:40
 * @Created by dell
 */

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle-->绘制方形");
    }
}

ShapeFactory

package com.zhuang.factory.simplefactory;

/**
 * @Classname ShapeFactory
 * @Description 简单工厂类
 * @Date 2021/3/18 15:43
 * @Created by dell
 */

public class ShapeFactory {
    public static Shape createShape(String shapeType) {
        if ("Rectangle".equalsIgnoreCase(shapeType)) {
            return new Rectangle();
        }
        if ("Circle".equalsIgnoreCase(shapeType)) {
            return new Circle();
        }
        if ("Square".equalsIgnoreCase(shapeType)) {
            return new Square();
        }
        return null;
    }
}

ShapeFactoryTest

package com.zhuang.factory.simplefactory;

/**
 * @Classname ShapeFactoryTest
 * @Description 简单工厂测试类
 * @Date 2021/3/18 15:47
 * @Created by dell
 */

public class ShapeFactoryTest {
    public static void main(String[] args) {
        Shape rectangle = ShapeFactory.createShape("Rectangle");
        rectangle.draw();

        Shape circle = ShapeFactory.createShape("Circle");
        circle.draw();

        Shape square = ShapeFactory.createShape("Square");
        square.draw();

    }
}

Java.util.Calendar 源码使用到了简单工厂模式

7.3 抽象工厂模式的定义和特点

抽象工厂模式（Abstract Factory）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类，每个生成的工厂都能按照工厂模式提供对象。

使用抽象工厂模式一般要满足以下条件。

系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
系统一次只可能消费其中某一族产品，即同族的产品一起使用。

主要优点如下：

可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

其缺点是：

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

7.4 抽象工厂模式的结构与实现

7.4.1 抽象工厂模式的结构

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

7.3.2 代码实现

Shape

package com.zhuang.factory.absfactory;

/**
 * @Classname Shape
 * @Description  产品接口类
 * @Date 2021/3/18 15:40
 * @Created by dell
 */

public interface Shape {
    void draw();
}

Circle

package com.zhuang.factory.absfactory;

/**
 * @Classname Circle
 * @Description 产品实现类
 * @Date 2021/3/18 15:43
 * @Created by dell
 */

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle-->绘制圆形");
    }
}

Square

package com.zhuang.factory.absfactory;

/**
 * @Classname Square
 * @Description  产品实现类
 * @Date 2021/3/18 15:40
 * @Created by dell
 */

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle-->绘制方形");
    }
}

Rectangle

package com.zhuang.factory.absfactory;


/**
 * @Classname Rectangle
 * @Description 产品实现类
 * @Date 2021/3/18 15:40
 * @Created by dell
 */

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle-->绘制长方形");
    }
}

ShapeFactory

package com.zhuang.factory.absfactory;

/**
 * @Classname ShapeFactory
 * @Description 简单工厂类
 * @Date 2021/3/18 15:43
 * @Created by dell
 */

public class ShapeFactory extends AbstractFactory {
    @Override
    public Shape createShape(String shapeType) {
        if ("Rectangle".equalsIgnoreCase(shapeType)) {
            return new Rectangle();
        }
        if ("Circle".equalsIgnoreCase(shapeType)) {
            return new Circle();
        }
        if ("Square".equalsIgnoreCase(shapeType)) {
            return new Square();
        }
        return null;
    }

    @Override
    public Color createColor(String colorType) {
        return null;
    }
}

Color

package com.zhuang.factory.absfactory;

/**
 * @Classname Color
 * @Description  颜色产品接口类
 * @Date 2021/3/18 16:03
 * @Created by dell
 */

public interface Color {
    void fill();
}

Red

package com.zhuang.factory.absfactory;

/**
 * @Classname Red
 * @Description  颜色产品实现类
 * @Date 2021/3/18 16:03
 * @Created by dell
 */

public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Red-->填充红色");
    }
}

Yellow

package com.zhuang.factory.absfactory;

/**
 * @Classname Yellow
 * @Description 颜色产品实现类
 * @Date 2021/3/18 16:04
 * @Created by dell
 */

public class Yellow implements Color {
    @Override
    public void fill() {
        System.out.println("Red-->填充黄色");
    }
}

Black

package com.zhuang.factory.absfactory;

/**
 * @Classname Black
 * @Description 颜色产品实现类
 * @Date 2021/3/18 16:05
 * @Created by dell
 */

public class Black implements Color {
    @Override
    public void fill() {
        System.out.println("Red-->填充黑色");
    }
}

ColorFactory

package com.zhuang.factory.absfactory;

import com.zhuang.factory.simplefactory.Circle;
import com.zhuang.factory.simplefactory.Rectangle;
import com.zhuang.factory.simplefactory.Square;

/**
 * @Classname ColorFactory
 * @Description 颜色工厂类的编写
 * @Date 2021/3/18 16:05
 * @Created by dell
 */

public class ColorFactory extends AbstractFactory {
    @Override
    public Shape createShape(String shapeType) {
        return null;
    }

    @Override
    public Color createColor(String colorType) {
        if ("Red".equalsIgnoreCase(colorType)) {
            return new Red();
        }
        if ("Black".equalsIgnoreCase(colorType)) {
            return new Black();
        }
        if ("Yellow".equalsIgnoreCase(colorType)) {
            return new Yellow();
        }
        return null;
    }
}

AbstractFactory

package com.zhuang.factory.absfactory;

/**
 * @Classname AbstractFactory
 * @Description 产品家族抽象类
 * @Date 2021/3/18 16:06
 * @Created by dell
 */

public abstract class AbstractFactory {
    public abstract Shape createShape(String shapeType);

    public abstract Color createColor(String colorType);
}

AbstractFactoryProducer

package com.zhuang.factory.absfactory;

/**
 * @Classname AbstractFactoryProducer
 * @Description 抽象类的工厂类
 * @Date 2021/3/18 16:10
 * @Created by dell
 */

public class AbstractFactoryProducer {
    public static AbstractFactory createFactory(String choice) {
        if ("Shape".equalsIgnoreCase(choice)) {
            return new ShapeFactory();
        }
        if ("Color".equalsIgnoreCase(choice)) {
            return new ColorFactory();
        }
        return null;
    }
}

AbstractFactoryProducerTest

package com.zhuang.factory.absfactory;

/**
 * @Classname AbstractFactoryProcucerTest
 * @Description 抽象类的工厂类测试类
 * @Date 2021/3/18 16:15
 * @Created by dell
 */

public class AbstractFactoryProducerTest {
    public static void main(String[] args) {
        AbstractFactory shapeFactory = AbstractFactoryProducer.createFactory("Shape");
        assert shapeFactory != null;
        Shape rectangle = shapeFactory.createShape("Rectangle");
        Shape circle = shapeFactory.createShape("Circle");
        Shape square = shapeFactory.createShape("Square");
        rectangle.draw();
        circle.draw();
        square.draw();
        System.out.println("====================================");
        AbstractFactory colorFactory = AbstractFactoryProducer.createFactory("Color");
        Color red = colorFactory.createColor("Red");
        Color yellow = colorFactory.createColor("Yellow");
        Color black = colorFactory.createColor("Black");
        red.fill();
        yellow.fill();
        black.fill();

    }
}

7.5 抽象工厂模式的应用场景

当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

写在最后

如果我的文章对你有用，请给我点个👍，感谢你😊！
有问题，欢迎在评论区指出！💪

设计模式学习06(Java实现)——工厂模式

7，工厂模式

7.1 工厂模式的定义和特点

7.2 工厂模式的结构与实现

7.3 抽象工厂模式的定义和特点

7.4 抽象工厂模式的结构与实现

7.4.1 抽象工厂模式的结构

7.3.2 代码实现

7.5 抽象工厂模式的应用场景

康小庄

引用和评论

Git常用命令速查表

Java8的新特性

Java11的新特性

Java5的新特性

Java9的新特性

Java13的新特性

Java7的新特性