web开发者不可错过的11个JavaScript工具

在java语言中,当我们在传递参数时，如是是个对象,我们并不想在在方法中改变对象的值,那么我们该怎么办:
1,可以new 一个对象,然后再setXXX(getXXX())来给对象赋值，如果要产生N个,比如N是100，如果这个对象有N个属性,比如10个，这样就要new100次，get,set 1000次。这样工作是相当无聊的，而且无意义。
2,采用Object的clone()方法，也就是复制对象，需实现Cloneable接口否则会抛出CloneNotSupportedException异常代码如下：
可是，如果当该对象的属性不是基本数据类型的是，如是某个对象，该对象的属性与原对象的属性是同一个，即引用指向同一个对象，在堆内存中并没有为该属性开辟一块新的内存。
为解决此问题，我们来谈谈，浅复制，和深复制。
⑴浅复制（浅克隆）
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
如下java代码：

public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}

⑵深复制（深克隆）
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍，如下java代码:

public Object deepClone() throws IOException, OptionalDataException,
ClassNotFoundException {
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
oo.writeObject(this);
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi = new ObjectInputStream(bi);
return (oi.readObject());
}

下面我给下有关代码及注释：

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OptionalDataException;
import java.io.Serializable;
/*
* 1.使用Prototype模式的一个好处就是可以节省大量的接口实现类的编写。
* 采用工厂模式的话，如果分别为用户指定的每种场合都提供一个用户接口
* 工厂类，将会为我们带来繁重的工作量。未来避免用户接口工厂类不断增
* 加，可以考虑使用Prototype模式。
* 2.而Prototype模式的一个致命的缺点是：Java中的原型方法不允许新对
* 象拥有与父对象不同的方法。这时候，在使用原型方法之前，需要仔细考
* 虑原型方法的利弊，甚至要试一下Prototype模式是否满足需求。
* 3.综上所述：Prototype模式最适用的场合应该是：当几个对象的类仅在
* 属性上存在一点差异，而行为上完全相同时。可以在复制一个原型对象后，
* 对其属性进行细小的微调，从而实现定制化的目的。
* */
public class BookBean implements Cloneable,Serializable {
private Integer id;
private String name;

public Integer getId() {
return id;
}

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

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}
/*
* 深克隆需要使用Java中提供的
* 对象串行化功能－即把要复制
* 的对象写入到一个缓冲流，然
* 后通过输入流读入，完成对象
* 的复制
* */
public Object deepClone() throws IOException, OptionalDataException,
ClassNotFoundException {
try {
// 在内存中开辟一块缓冲区，用于将自身写入
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bos);
// 通过Serialization机制将自身写入缓冲区
out.writeObject(this);
out.close();
/ /读
ByteArrayInputStream bis = new ByteArrayInputStream(bos
.toByteArray());
ObjectInputStream in = new ObjectInputStream(bis);
// 将刚才写入的内容读入一个新的对象
Object ret = in.readObject();
in.close();
// 返回对象
return ret;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}
下面是一个测试类：
public class TestPrototype {
public static void main(String args[]) throws Exception{
BookBean book=new BookBean();
book.setId(1);
book.setName("java设计模式");
System.out.println(book.getId()+","+book.getName());
BookBean book2=(BookBean)book.deepClone();
System.out.println(book2.getId()+","+book2.getName());
if(book==book2){
System.out.println("==");
} else {
System.out.println("!=");
}
if(book.getId()==book2.getId()){
System.out.println("==");
}else {
System.out.println("!=");
}
if(book.getName()==book2.getName()){
System.out.println("==");
}else {
System.out.println("!=");
}

}
}