设计模式---原型模式

别偷我的猪_09

于 2023-03-15 11:49:49 发布

阅读量319

点赞数

分类专栏：软件设计模式文章标签：原型模式设计模式

本文链接：https://blog.csdn.net/qq_44950283/article/details/129545846

版权

软件设计模式专栏收录该内容

7 篇文章 0 订阅

订阅专栏

原型模式(Prototype Pattern) 是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式之一。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

简介

1. 模式动机

$\bullet$ 在面向对象系统中，使用原型模式来复制一个对象自身，从而克隆出多个与原型对象一模一样的对象。

$\bullet$ 在软件系统中，有些对象的创建过程比较复杂，而且有时候需要频繁创建，原型模式通过给出一个原型对象来指明要创建的对象类型，然后用复制这个原型对象的办法创建更多同类型的对象，这就是原型模式的意图所在。

$\bullet$ 原型模式将克隆过程委派给被克隆的实际对象。模式为所有支持克隆的对象声明一个通用的接口，该接口让你能够克隆对象，同时又无需将代码和对象所属类耦合。通常情况下，这样的接口中仅包含一个克隆方法。

$\bullet$ 所有的类对克隆方法的实现都非常相似。该方法会创建一个当前类的对象，然后将原始对象所有的成员变量值复制到新建的类中。甚至可以复制私有成员变量，因为绝大部分编程语言都允许对象访问其同类对象的私有成员变量。

2. 深克隆和浅克隆

通常情况下，一个类包含一些成员对象，在使用原型模式克隆对象时，根据其成员对象是否也克隆，原型模式可以分为两种形式：深克隆和浅克隆。

$\bullet$ 浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于那些引用其它对象的属性，仍指向原有属性所指向的对象的内存地址。

$\bullet$ 深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

3. 适用场景

$\bullet$ 对象之间相同或相似，即只是个别的几个属性不同的时候。

$\bullet$ 创建对象成本较大，例如初始化时间长，占用 CPU 太多，或者占用网络资源太多等，需要优化资源。

$\bullet$ 创建一个对象需要繁琐的数据准备或访问权限等，需要提高性能或者提高安全性。

$\bullet$ 系统中大量使用该类对象，且各个调用者都需要给它的属性重新赋值。

实现

我们将创建一抽象类 Shape 和扩展 Shape 类的实体类。下一步是定义类 ShapeCache，该类把 shape 对象存储在一个 Hashtable 中，并在请求的时候返回它们的克隆。

PrototypePatternDemo 类使用 ShapeCache 类来获取 Shape 对象。

步骤1：创建一个实现 Cloneable 接口的抽象类。

public abstract class Shape implements Cloneable{

    private String id;
    protected String type;

    abstract void draw();

    public String getType(){
        return type;
    }

    public String getId(){
        return id;
    }

    public void setId(String id){
        this.id = id;
    }

    public Object clone(){
        Object clone = null;
        try{
            clone = super.clone();
        }catch(CloneNotSupportException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

步骤2：创建扩展了上面抽象类的实体类

public class Rectangle extends Shape{
    
    public Rectangle(){
        type = "Rectangle";
    }

    // Shape 里的 draw() 是被 abstract 关键字修饰的，所以子类必须实现它
    @Override
    public void draw(){
        System.out.println("Rectangle");
    }
}

public class Square extends Shape{
    
    public Rectangle(){
        type = "Square ";
    }

    // Shape 里的 draw() 是被 abstract 关键字修饰的，所以子类必须实现它
    @Override
    public void draw(){
        System.out.println("Square ");
    }
}

public class Circle extends Shape{
    
    public Rectangle(){
        type = "Circle ";
    }

    // Shape 里的 draw() 是被 abstract 关键字修饰的，所以子类必须实现它
    @Override
    public void draw(){
        System.out.println("Circle ");
    }
}

步骤3：创建 ShapeCache 类，并把它们存储在一个 Hashtable 中。

import java.util.Hashtable;

public class ShapeCache{
    
    private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>();
    
    public static Shape getShape(String shapeId){
        Shape cachedShape = shapeMap.get(shapeId);
        return (Shape)cacheShape.clone();
    }

    // 对每种形状都运行数据库查询，并创建该形状
    // shapeMap.put(shapeKey, shapeValue);
    // 例如，我们要添加三种形状
    public static void loadCache(){
        Circle circle = new Circle();
        circle.setId("1");
        shapeMap.put(circle.getId(), circle);

        Square square = new Square();
        square.setId("2");
        shapeMap.put(square.getId(), square);

        Rectangle rectangle = new Rectangle ();
        rectangle .setId("3");
        shapeMap.put(rectangle .getId(), rectangle );

    }
}

步骤4：PrototypePatternDemo 使用 ShapeCache 类来获取存储在 Hashtable 中形状的克隆。

public class PrototypePatternDemo{
    
    public static void main(Strign[] args){
        ShapeCache.loadCache();

        //cloneShape == ShapeCache.getShape(id) 根据 id 去克隆对应的 Shape 
        Shape cloneShape = (Shape) ShapeCache.getShape("1");
        System.out.println("Shape" + cloneShape.getType());

        Shape cloneShape2 = (Shape) ShapeCache.getShape("2");
        System.out.println("Shape" + cloneShape2.getType());

        Shape cloneShape3 = (Shape) ShapeCache.getShape("3");
        System.out.println("Shape" + cloneShape3.getType());
        
    }
}

步骤5：输出结果

Shape : Circle
Shape : Square
Shape : Rectangle

注意：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable 接口，深拷贝则是通过实现 Serializable 读取二进制流。

优缺点

优点：

$\bullet$ 当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程，通过一个已有实例可以提高新实例的创建效率。

$\bullet$ 可以动态增加或减少产品类。

$\bullet$ 原型模式提高了简化的创建结构。

$\bullet$ 可以使用深克隆的方式保存对象的状态。

缺点：

$\bullet$ 每一个类都必须配备一个克隆方法，配备克隆方法需要对类的功能进行通盘考虑，这对全新的类来说不是很难，但对已有的类进行改造时，不一定是件容易的事，必须修改其源代码，违背了“开闭原则”。

$\bullet$ 必须实现 Cloneable 接口。

参考文献：菜鸟教程

别偷我的猪_09

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
设计模式---原型模式

在面向对象系统中，使用原型模式来复制一个对象自身，从而克隆出多个与原型对象一模一样的对象。在软件系统中，有些对象的创建过程比较复杂，而且有时候需要频繁创建，原型模式通过给出一个原型对象来指明要创建的对象类型，然后用复制这个原型对象的办法创建更多同类型的对象，这就是原型模式的意图所在。原型模式将克隆过程委派给被克隆的实际对象。模式为所有支持克隆的对象声明一个通用的接口，该接口让你能够克隆对象，同时又无需将代码和对象所属类耦合。通常情况下，这样的接口中仅包含一个克隆方法。
复制链接

扫一扫