设计模式之原型模式(Prototype)详解及代码示例

☆樱花仙子☆ 提交于 2020-03-30 03:03:36

一、原型模式的定义与特点

  原型(Prototype)模式的定义如下:用一个已经创建的实例作为原型,通过复制该原型对象来创建一个和原型相同或相似的新对象。它属于创建型设计模式,用于创建重复的对象,同时又能保证性能(用这种方式创建对象非常高效)。

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

二、原型模式优点

  • 性能优良:原型模式是在内存二进制流的拷贝,要比new一个对象性能好很多,特别是在一个循环体类产生大量对象的时候更加明显。
  • 逃避构造函数的约束:这是优缺点共存的一点,直接在内存中拷贝,构造函数是不会执行的。

三、原型模式的使用场景

  • 资源初始化场景:类初始化需要消耗非常多的资源的时候。
  • 性能和安全要求的场景:通过new产生一个对象需要非常繁琐的数据准备和访问权限的时候。
  • 一个对象多个修改者的场景:一个对象需要提供给其他对象访问,而各个调用者可能都需要修改其值时考虑使用。

  实际项目中原型模式很少单独出现,一般和工厂模式一起出现,通过clone方法创建一个对象,然后由工厂方法提供给调用者。

四、原型模式的结构与实现

  由于 Java 提供了对象的 clone() 方法,所以用 Java 实现原型模式很简单,只需要实现Cloneable接口并重写clone()方法,简单程度仅次于单例模式和迭代器模式。

  原型模式包含以下主要角色。

  • 抽象原型类:规定了具体原型对象必须实现的接口。
  • 具体原型类:实现抽象原型类的 clone() 方法,它是可被复制的对象。
  • 访问类:使用具体原型类中的 clone() 方法来复制新的对象。

  其结构图如图所示:

              

   代码实现如下:

//具体原型类
class Realizetype implements Cloneable
{
    Realizetype()
    {
        System.out.println("具体原型创建成功!");
    }
    public Object clone() throws CloneNotSupportedException
    {
        System.out.println("具体原型复制成功!");
        return (Realizetype)super.clone();
    }
}

//原型模式的测试类
public class PrototypeTest
{
    public static void main(String[] args)throws CloneNotSupportedException
    {
        Realizetype obj1=new Realizetype();
        Realizetype obj2=(Realizetype)obj1.clone();
        System.out.println("obj1==obj2?"+(obj1==obj2));
    }
}

  结果如下:

具体原型创建成功!    //此处构造方法在clone的时候并不会执行,因为对象是从内存以二进制流的方式进行拷贝,当然不会执行
具体原型复制成功!
obj1==obj2?false   //不是同一个对象

五、补充说明

  1、构造方法clone时不会执行

  构造方法在clone的时候并不会执行,因为对象是从内存以二进制流的方式进行拷贝,当然不会执行,如上例子中所示。

  2、深拷贝、浅拷贝

  如下代码,就是浅拷贝:

class Thing2 implements Cloneable {
    private ArrayList<String> list = new ArrayList<String>();

    @Override
    public Thing2 clone() {
        Thing2 thing = null;
        try {
            thing = (Thing2) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            System.out.println("克隆失败");
        }
        return thing;
    }

    public void setValue(String value) {
        this.list.add(value);
    }

    public ArrayList getValue() {
        return this.list;
    }
}

public class SimpleClone {
    public static void main(String[] args) {
        Thing2 thing = new Thing2();
        thing.setValue("张三");
        Thing2 cloneThing= thing.clone();
        cloneThing.setValue("李四");
        System.out.println(thing.getValue());
    }
}

  测试结果输出为:

原始对象:[张三, 李四]
克隆对象:[张三, 李四]

  原型模式克隆出来的对象应该是相互独立的,那么为什么会出现原始对象和克隆对象之间共享访问呢?

  这是因为object类的clone方法只拷贝本对象,其对象内部的数组,引用对象等都不拷贝,还是指向原生对象的内部元素地址,这种拷贝就是浅拷贝。两个对象共用一个私有变量。这是一种非常不安全的方式。

  原始类型会被拷贝(int,double,long。。。),String类型也会被拷贝;数组、引用类型不会被拷贝

  使用原型类型时,引用的成员变量必须满足两个条件才不会被拷贝:

  • 是类的成员变量,而不是方法内的变量
  • 必须是一个可变的引用对象,而不是一个原始类型或者不可变对象(比如final)

  如下为深拷贝:

class Thing1 implements Cloneable {
    private ArrayList<String> list = new ArrayList<String>();

    @Override
    public Thing1 clone() {
        Thing1 thing = null;
        try {
            thing = (Thing1) super.clone();
            thing.list = (ArrayList) this.list.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            System.out.println("克隆失败");
        }
        return thing;
    }

    public void setValue(String value) {
        this.list.add(value);
    }

    public ArrayList getValue() {
        return this.list;
    }
}

public class DeepClone {
    public static void main(String[] args) {
        Thing1 thing = new Thing1();
        thing.setValue("张三");
        Thing1 cloneThing= thing.clone();
        cloneThing.setValue("李四");
        System.out.println("原始对象:"+thing.getValue());
        System.out.println("克隆对象:"+cloneThing.getValue());

    }
}

  输出结果为:

原始对象:[张三]
克隆对象:[张三, 李四]

  注意:

  • 深拷贝和浅拷贝要分开实现,不然会导致程序变得非常复杂
  • 带有final类型的变量是不可以进行拷贝的,这样是无法实现深拷贝。

  这是因为final关键字的特性

  对于一个final变量,如果是基本数据类型的变量,则其数值一旦在初始化之后便不能更改;如果是引用类型的变量,则在对其初始化之后便不能再让其指向另一个对象。因此:要使用clone()方法,类的成员变量上不要增加final关键字。

  3、原型模式的扩展

  原型模式可扩展为带原型管理器的原型模式,它在原型模式的基础上增加了一个原型管理器 PrototypeManager 类。该类用 HashMap 保存多个复制的原型,Client 类可以通过管理器的 get(String id) 方法从中获取复制的原型。其结构图如图所示:

                

   代码如下:

import java.util.*;
interface Shape extends Cloneable
{
    public Object clone();    //拷贝
    public void countArea();    //计算面积
}
class Circle implements Shape
{
    public Object clone()
    {
        Circle w=null;
        try
        {
            w=(Circle)super.clone();
        }
        catch(CloneNotSupportedException e)
        {
            System.out.println("拷贝圆失败!");
        }
        return w;
    }
    public void countArea()
    {
        int r=0;
        System.out.print("这是一个圆,请输入圆的半径:");
        Scanner input=new Scanner(System.in);
        r=input.nextInt();
        System.out.println("该圆的面积="+3.1415*r*r+"\n");
    }
}
class Square implements Shape
{
    public Object clone()
    {
        Square b=null;
        try
        {
            b=(Square)super.clone();
        }
        catch(CloneNotSupportedException e)
        {
            System.out.println("拷贝正方形失败!");
        }
        return b;
    }
    public void countArea()
    {
        int a=0;
        System.out.print("这是一个正方形,请输入它的边长:");
        Scanner input=new Scanner(System.in);
        a=input.nextInt();
        System.out.println("该正方形的面积="+a*a+"\n");
    }
}
class ProtoTypeManager
{
    private HashMap<String, Shape>ht=new HashMap<String,Shape>(); 
    public ProtoTypeManager()
    {
        ht.put("Circle",new Circle());
        ht.put("Square",new Square());
    } 
    public void addshape(String key,Shape obj)
    {
        ht.put(key,obj);
    }
    public Shape getShape(String key)
    {
        Shape temp=ht.get(key);
        return (Shape) temp.clone();
    }
}
public class ProtoTypeShape
{
    public static void main(String[] args)
    {
        ProtoTypeManager pm=new ProtoTypeManager();    
        Shape obj1=(Circle)pm.getShape("Circle");
        obj1.countArea();          
        Shape obj2=(Shape)pm.getShape("Square");
        obj2.countArea();     
    }
}

  测试结果为:

这是一个圆,请输入圆的半径:3
该圆的面积=28.2735

这是一个正方形,请输入它的边长:3
该正方形的面积=9
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!