java原型设计模式

原型设计模式

 

一：首先我们先了解什么是设计模式？

设计模式：代码编写方法，模板，规范……每种设计模式都有它使用的场景，在这种场景下使用设计模式会给我们的程序编写带来极大的方便和性能的优越。

java语言里面有23中设计模式，原型设计模式就是其中的一种。不同的设计模式有不同的特点和用法。

二：原型设计模式：

用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的实例。也就是通过复制现在已经存在的对象来创建一个新的对象。

原型设计模式使用的场景：

1，例如我们需要创建一个类的很多对象时

              我们通常的做法是创建一个类，然后再创建这些对象。然而原型设计模式使得我们可以设计出原型模式，然后用这个类去继承原型模式，然后再实例化一个这个类的对象，然后直接用这个对象类复制出其他的对象。这么做的好处在什么地方呢？答案是：我们new一个对象时的程序花费是非常昂贵的（时间的花销上），而使用原型设计模式后第一个对象创建后会保存在内存里面，然后通过复制这个对象的属性，把这些属性赋给另一个对象，这是非常节约时间的（操作的是内存里面的数据）。

2，例如我们需要创建一个类的很难创建的一些对象时

              什么是很难创建的对象呢？当然从表面上是需要传入很多个参数的那种；其实还有创建对象时调用的构造方法里有很多操作的，例如构造方法里面又调用这个类的方法，这就造成时间上的花销。以上的多个参数对象的创建，我们编写代码时每次都得传入参数，是很麻烦的，而时间花销太多是程序设计不能忍的。

原型设计模式当然还用别的用处，读者自己去发展了……

 三：原型设计模式的实现

       原型设计模式的灵魂在于：用一个已经存在的对象，复制后创建另一个对象。复制，在内存里面操作数据。

       知道这些后原型设计模式的实现就变的简单了，这是因为java里面的每一个类都一个clone()方法，这个方法object类有的，方法clone()就是克隆，也就是复制的作用。当然原型设计模式还是有其他不用clone()就实现的，但是使用clone()方法来实现是最简单的了……

//以下就是实现原型设计模式的方法：

 

public class Tester implements Cloneable{
	
	public Tester clone(){
		Tester prototype = null;
		  try{
			  prototype = (Tester)super.clone();
			  
		  }catch(CloneNotSupportedException e){
		   e.printStackTrace();
		  }
		  return prototype; 
		 }
	}

 

  //现实中我们要使用其对象的类：

 

public class TestA extends Tester{
	int a;
	int b;
	int c;
	int a1[];
	public TestA(int a,int b,int c){
			this.a=a;
			this.b=b;
			this.c=c;
			init1();
			init2();
			init3();
		}
	private void init3() {
		System.out.println("方法一");
	}
	private void init2() {
		System.out.println("方法二");
	}
	private void init1() {
		System.out.println("方法三");
	}
}

 

 //使用的地方：

public class TestB {
	static long start1,end1,start2,end2;
	
	public static void main(String[] args) {
		int a=1;
		int b=2;
		int c=3;
		start1=System.nanoTime();
		//new一个对象
		TestA t=new TestA(a,b,c);
		for(int i=0;i<1000;i++){
			TestA t1=(TestA)t.clone();
		}
		end2=System.nanoTime();
		System.out.println("创建这些对象的时间是："+(end2-start1));
	
	}
}

 

 //不用原型设计模式的代码

public class MyTest {
	
	private static long end2;
	private static long start1;
	int a;
	int b;
	int c;
	static int a1[];
	public MyTest(int a,int b,int c,int [] a1){
		this.a=a;
		this.b=b;
		this.c=c;
		this.a1=a1;
		init1();
		init2();
		init3();
	}
	private void init3() {
	System.out.println("方法一");	
	}
	private void init2() {
		System.out.println("方法二");
	}
	private void init1() {
		System.out.println("方法三");
	}
	//main()
	public static void main(String[] args){
		int a=1;
		int b=2;
		int c=3;
		a1=new int [100];
		start1=System.nanoTime();
		//new一个对象
		MyTest t=new MyTest(a,b,c,a1);
		
		for(int i=0;i<1000;i++){
			MyTest t1=new MyTest(a,b,c,a1);
		}
		end2=System.nanoTime();
		System.out.println("创建这些对象的时间是："+(end2-start1));
	}	
	public void init4() {
		
	}
}

 

 //在这里我们可以看到时间上的优势

 

四：使用原型设计模式时因注意的地方：

     a.对任何的对象x,都有：x.clone() != x,即克隆对象与原对象不是同一个对象。

  b.对任何的对象x,都有：x.clone().getClass() == x.get getClass()，即克隆对象与原对象的类型是一样的。   

   c.如果对象x的equals()方法定义恰当的话，那么x.clone().equals(x)应当是成立的

 

五：深拷贝，浅拷贝。

    在以上的实现原型设计模式的代码中的clone()只能复制8种基本数据类型（浅），其他的数据类型需要自己去写出拷贝（深）。

public Tester clone(){
Tester prototype = null;
  try{
  prototype = (Tester)super.clone();
  //如果对象里面有其他的数据类型，在此处可以自己写下要复制的那些数据类型。
    }catch(CloneNotSupportedException e){
   e.printStackTrace();
  }
  return prototype;
}