乐趣区

关于java:设计模式学习06Java实现工厂模式

作者：

jiezi

在

写在后面

  • 记录学习设计模式的笔记
  • 进步对设计模式的灵活运用

学习地址

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 种设计模式之列。

简略工厂模式每减少一个产品就要减少一个具体产品类和一个对应的具体工厂类，这减少了零碎的复杂度，违反了“开闭准则”。

长处：

  1. 工厂类蕴含必要的逻辑判断，能够决定在什么时候创立哪一个产品的实例。客户端能够罢黜间接创立产品对象的职责，很不便的创立出相应的产品。工厂和产品的职责辨别明确。
  2. 客户端无需晓得所创立具体产品的类名，只需晓得参数即可。
  3. 也能够引入配置文件，在不批改客户端代码的状况下更换和增加新的具体产品类。

毛病：

  1. 简略工厂模式的工厂类繁多，负责所有产品的创立，职责过重，一旦异样，整个零碎将受影响。且工厂类代码会十分臃肿，违反高聚合准则。
  2. 应用简略工厂模式会减少零碎中类的个数（引入新的工厂类），减少零碎的复杂度和了解难度
  3. 零碎扩大艰难，一旦减少新产品不得不批改工厂逻辑，在产品类型较多时，可能造成逻辑过于简单
  4. 简略工厂模式应用了 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 形象工厂模式的构造

  1. 形象工厂（Abstract Factory）：提供了创立产品的接口，它蕴含多个创立产品的办法 newProduct()，能够创立多个不同等级的产品。
  2. 具体工厂（Concrete Factory）：次要是实现形象工厂中的多个形象办法，实现具体产品的创立。
  3. 形象产品（Product）：定义了产品的标准，形容了产品的次要个性和性能，形象工厂模式有多个形象产品。
  4. 具体产品（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 形象工厂模式的利用场景

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

写在最初

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

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章