java基础之 创建对象的几种方式

  • Z时代
  • 2024-01-10
  • 分类：综合

java

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

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

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

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

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

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

 

[java] view plaincopyprint?

  1. public class Customer implements Cloneable{  

  2. private String name;  

  3. private int age;  

  4. public Customer(){  

  5.   this("unknown",0);  

  6.   System.out.println("call default constructor");  

  7. }  

  8. public Customer(String name,int age){  

  9.   this.name=name;  

  10.   this.age=age;  

  11.   System.out.println("call second constructor");  

  12. }  

  13. public Object clone()throws CloneNotSupportedException{  

  14. return super.clone();  

  15. }  

  16. public boolean equals(Object o){  

  17.   if(this==o)return true;  

  18.   if(! (o instanceof Customer)) return false;  

  19.   final Customer other=(Customer)o;  

  20.   if(this.name.equals(other.name) && this.age==other.age)  

  21.      return true;  

  22.   else  

  23.      return false;  

  24. }  

  25. public String toString(){  

  26. return "name="+name+",age="+age;  

  27. }  

  28. public static void main(String args[])throws Exception{  

  29. //运用反射手段创建Customer对象  

  30. Class objClass=Class.forName("Customer");  

  31. Customer c1=(Customer)objClass.newInstance(); //会调用Customer类的默认构造方法  

  32. System.out.println("c1: "+c1); //打印name=unknown,age=0  

  33.    

  34. //用new语句创建Customer对象  

  35. Customer c2=new Customer("Tom",20);  

  36. System.out.println("c2: "+c2); //打印name=tom,age=20  

  37.    

  38. //运用克隆手段创建Customer对象  

  39. Customer c3=(Customer)c2.clone(); //不会调用Customer类的构造方法  

  40. System.out.println("c2==c3 : "+(c2==c3)); //打印false  

  41. System.out.println("c2.equals(c3) : "+c2.equals(c3)); //打印true  

  42. System.out.println("c3: "+c3); //打印name=tom,age=20  

  43. }  

  44. }  

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对象，例如：

 

[java] view plaincopyprint?

  1. String s1="Hello";  

  2. String s2="Hello"; //s2和s1引用同一个String对象  

  3. String s3=new String("Hello");  

  4. System.out.println(s1==s2); //打印true  

  5. System.out.println(s1==s3); //打印false  

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对象。例如：

 

[java] view plaincopyprint?

  1. String s1="H";  

  2. String s2=" ello";  

  3. String s3=s1+s2; //s3引用一个新的String对象  

  4. System.out.println(s3=="Hello"); //打印false  

  5. System.out.println(s3.equals("Hello")); //打印true  

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实例.

以上是 java基础之 创建对象的几种方式 的全部内容， 来源链接： utcz.com/z/390617.html

回到顶部