java中创建对象的方法（转）

有4种显式地创建对象的方式：

　1.用new语句创建对象，这是最常用的创建对象的方式。

　2.运用反射手段，调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。

　3.调用对象的clone()方法。

　4.运用反序列化手段，调用java.io.ObjectInputStream对象的readObject()方法.

　下面演示了用前面3种方式创建对象的过程。

public class Customer implements Cloneable{  
private String name;  
private int age;  
public Customer(){  
  this("unknown",0);  
  System.out.println("call default constructor");  
}  
public Customer(String name,int age){  
  this.name=name;  
  this.age=age;  
  System.out.println("call second constructor");  
}  
public Object clone()throws CloneNotSupportedException{  
return super.clone();  
}  
public boolean equals(Object o){  
  if(this==o)return true;  
  if(! (o instanceof Customer)) return false;  
  final Customer other=(Customer)o;  
  if(this.name.equals(other.name) && this.age==other.age)  
     return true;  
  else  
     return false;  
}  
public String toString(){  
return "name="+name+",age="+age;  
}  
public static void main(String args[])throws Exception{  
//运用反射手段创建Customer对象  
Class objClass=Class.forName("Customer");  
Customer c1=(Customer)objClass.newInstance(); //会调用Customer类的默认构造方法  
System.out.println("c1: "+c1); //打印name=unknown,age=0  

//用new语句创建Customer对象  
Customer c2=new Customer("Tom",20);  
System.out.println("c2: "+c2); //打印name=tom,age=20  

//运用克隆手段创建Customer对象  
Customer c3=(Customer)c2.clone(); //不会调用Customer类的构造方法  
System.out.println("c2==c3 : "+(c2==c3)); //打印false  
System.out.println("c2.equals(c3) : "+c2.equals(c3)); //打印true  
System.out.println("c3: "+c3); //打印name=tom,age=20  
}  
}  

以上程序的打印结果如下：

call second constructor

call default constructor

c1: name=unknown,age=0

call second constructor

c2: name=Tom,age=20

c2==c3 : false

c2.equals(c3) : true

c3: name=Tom,age=20

　从以上打印结果看出，用new语句或Class对象的newInstance()方法创建Customer对象时，都会执行Customer类的构造方法，而用对象的clone()方法创建Customer对象时，不会执行Customer类的构造方法。（区别）

　除了以上4种显式地创建对象的方式以外，在程序中还可以隐含地创建对象，包括以下几种情况：

　1.对于java命令中的每个命令行参数，Java虚拟机都会创建相应的String对象，并把它们组织到一个String数组中，再把该数组作为参数传给程序入口main(String args[])方法。

　2.程序代码中的String类型的直接数对应一个String对象，例如：

String s1="Hello";  
String s2="Hello"; //s2和s1引用同一个String对象  
String s3=new String("Hello");  
System.out.println(s1==s2); //打印true  
System.out.println(s1==s3); //打印false 

　执行完以上程序，内存中实际上只有两个String对象，一个是直接数，由Java虚拟机隐含地创建，还有一个通过new语句显式地创建。

　3.字符串操作符“+”的运算结果为一个新的String对象。例如：

String s1="H";  
String s2=" ello";  
String s3=s1+s2; //s3引用一个新的String对象  
System.out.println(s3=="Hello"); //打印false  
System.out.println(s3.equals("Hello")); //打印true 

　4.当Java虚拟机加载一个类时，会隐含地创建描述这个类的Class实例.

================================================
关于对象clone方法

什么是“clone”？

　在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能会需要一个和A完全相同新对象B，并且此后对B任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。在Java语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单，也是最高效的手段。

”clone“方法介绍

　有三个值得注意的地方，一是希望能实现clone功能的CloneClass类实现了Cloneable接口，这个接口属于java.lang包，java.lang包已经被缺省的导入类中，所以不需要写成java.lang.Cloneable。另一个值得请注意的是重载了clone()方法。最后在clone()方法中调用了super.clone()，这也意味着无论clone类的继承结构是什么样的，super.clone()直接或间接调用了java.lang.Object类的clone()方法。下面再详细的解释一下这几点。
　应该说第三点是最重要的，仔细观察一下Object类的clone()一个native方法，native方法的效率一般来说都是远高于java中的非native方法。这也解释了为什么要用Object中clone()方法而不是先new一个类，然后把原始对象中的信息赋到新对象中，虽然这也实现了clone功能。对于第二点，也要观察Object类中的clone()还是一个protected属性的方法。这也意味着如果要应用clone()方法，必须继承Object类，在Java中所有的类是缺省继承Object类的，也就不用关心这点了。然后重载clone()方法。还有一点要考虑的是为了让其它类能调用这个clone类的clone()方法，重载之后要把clone()方法的属性设置为public。
　那么clone类为什么还要实现Cloneable接口呢？稍微注意一下，Cloneable接口是不包含任何方法的！其实这个接口仅仅是一个标志，而且这个标志也仅仅是针对Object类中clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了super.Clone()方法），那么Object的clone()方法就会抛出CloneNotSupportedException异常。

浅克隆与深克隆

　浅克隆：被复制对象的所有属性都含有与源对象属性有相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制其属性引用的对象。
　浅克隆只会克隆一层（对象层），克隆后得到的对象和原来的对象相比较，他们的属性值都相等。
　Object类的clone()方法属于浅克隆。

　深克隆：被复制对象的所有变量属性都含有源对象属性有相同的值，包含那些引用其他对象的属性，那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象也都复制了一遍。
　深克隆会克隆多层（可以达到属性层，具体情况要看clone()方法的实现逻辑），克隆后得到的对象和原来的对象相比较，他们的属性值都不相等。

克隆示例
实例：对Person类实现克隆方法。
实例说明：clone()方法将对象复制一份并返回给调用者。一般而言，clone（）方法满足如下条件：
　(1) 对任何对象x，都有 x.clone() !=x; //克隆对象与原对象不是同一个对象
　(2) 对任何对象x，都有 x.clone().getClass()= =x.getClass(); //克隆对象与原对象的类型一样
　(3) 如果对象x的equals()方法定义恰当，那么x.clone().equals(x); //应该成立

浅克隆示例
　Person实体类：

 public class Person implements Cloneable {
  private long id;
  private String name;
  public Person(String name) {
    super();
    this.name = name;
  }
  public Person(long id, String name) {
    super();
    this.id = id;
    this.name = name;
  }
  @Override
  public Person clone() throws CloneNotSupportedException {
    Person p = (Person) super.clone();
    return p;
  }
  @Override
  public String toString() {
    return "Id:" + id + "\tName:" + name;
  }
  public long getId() {
    return id;
  }
  public void setId(long id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
}



}

package com.simpleframework;

public class TestPerson {
  public static void main(String[] args) throws CloneNotSupportedException {
    Person p1 = new Person(1001, "Jack");
    System.out.println(p1);
    Person p2 = (Person) p1.clone();
    System.out.println(p2);
    System.out.println("p1==p2:" + (p1 == p2));
    System.out.println("p1.id==p2.id:" + (p1.getId() == p2.getId()));
    System.out.println("p1.name==p2.name:" + (p1.getName() == p2.getName()));

  }
}



}

测试结果：
Id:1001 Name:Jack

Id:1001 Name:Jack

p1==p2:false

p1.id==p2.id:true

p1.name==p2.name:true
结果分析：
　(1) 前两行打印的是两个对象p1和p2的内存地址
　(2) p1和p2不是同一个对象，所以p1==p2不相等
　(3) p2是p1的浅克隆对象，其属性值和源对象相等

深克隆示例
　Person实体类：

public class Person implements Cloneable {
private long id;
private String name;
public Person() {
super();
}
public Person(long id, String name) {
super();
this.id = id;
this.name = name;
}
@Override
protected Object clone() {
System.out.println("==>clone()");
Person p;
try {
p = (Person) super.clone();
p.id = this.id;
p.name = new String(this.name);
return p;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
@Override
public String toString() {
return "Id:" + id + "\tName:" + name;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

测试类：同浅克隆实例的测试类
测试结果：
org.programmer.clone.Person@c17164
org.programmer.clone.Person@1fb8ee3
p1==p2:false
p1.id==p2.id:true
p1.name==p2.name:false
结果分析：
　(4) 前两行打印的是两个对象p1和p2的内存地址
　(5) p1和p2不是同一个对象，所以p1==p2不相等
　(6) p2是p1的深克隆对象，其属性值和源对象的属性值相比较，基本类型的属性值相等，引用类型的属性值不相等

clone常见问题

　(1) 未实现Cloneable接口异常
　java.lang.CloneNotSupportedException
　(2) 深克隆时引用类型的属性对象没有复制，直接引用源对象的属性对象，应该通过new关键字实现引用类型属性对象的复制

================================================
原文1：http://blog.csdn.net/mhmyqn/article/details/7943411
原文2：http://blog.sina.com.cn/s/blog_a57e40d301013ctt.html
参考：http://blog.csdn.net/shootyou/article/details/3945221