Java中，类的实例化方法有四种途径：

1）使用new操作符

2）调用Class对象的newInstance()方法

3）调用clone()方法，对现有实例的拷贝

4）通过ObjectInputStream的readObject()方法反序列化类

1.ClassInstance.java

  1. 1 import java.io.*; 
  2.  2  
  3.  3 class ClassInstance implements Cloneable, Serializable { 
  4.  4     private String str = "测试..."; 
  5.  5     public void fun(){ 
  6.  6         System.out.println(str); 
  7.  7     } 
  8.  8     public ClassInstance(String str){ 
  9.  9         System.out.println("有参类的实例化"); 
  10. 10         this.str += str;  
  11. 11     } 
  12. 12     public ClassInstance(){ 
  13. 13         System.out.println("无参类的实例化"); 
  14. 14     } 
  15. 15     public Object clone(){ 
  16. 16         return this; 
  17. 17     } 
  18. 18 } 


2.ClassInstanceTest.java


 


  1.  1 import java.io.*; 
  2.  2 import java.lang.reflect.*; 
  3.  3  
  4.  4 public class ClassInstanceTest{ 
  5.  5     public static void main(String[] args) throws ClassNotFoundException, InstantiationException, 
  6.  6            IllegalAccessException, IOException,InvocationTargetException, NoSuchMethodException{ 
  7.  7         //第一种类的实例化方式 
  8.  8         ClassInstance ci01 = new ClassInstance("01"); 
  9.  9         ci01.fun(); 
  10. 10  
  11. 11         //第二种类的实例化方式 
  12. 12         ClassInstance ci02 = (ClassInstance) Class.forName("ClassInstance").newInstance(); 
  13. 13         ci02.fun(); 
  14. 14  
  15. 15         //第三种类的实例化方式 
  16. 16         ClassInstance ci03 = (ClassInstance) ci01.clone(); 
  17. 17         ci03.fun(); 
  18. 18  
  19. 19         //第四种类的实例化方式 
  20. 20         FileOutputStream fos = new FileOutputStream("ci.tmp"); 
  21. 21         ObjectOutputStream oos = new ObjectOutputStream(fos); 
  22. 22         oos.writeObject(ci01); 
  23. 23         oos.close(); 
  24. 24         fos.close(); 
  25. 25          
  26. 26         FileInputStream fis = new FileInputStream("ci.tmp"); 
  27. 27         ObjectInputStream ois = new ObjectInputStream(fis); 
  28. 28          
  29. 29         ClassInstance ci04  = (ClassInstance) ois.readObject(); 
  30. 30         ois.close(); 
  31. 31         fis.close(); 
  32. 32          
  33. 33         ci04.fun(); 
  34. 34         System.out.println("--------------------额外测试--------------------"); 
  35. 35         ClassInstance ci05 = null; 
  36. 36         //额外的思考 在第二种类实例化的方式中有没有一种方法实现有参数的构造方式 
  37. 37         //获得类的构造信息 
  38. 38         Constructor[] ctor = Class.forName("ClassInstance").getDeclaredConstructors(); 
  39. 39         //找到我们需要的构造方法 
  40. 40         for(int i=0;i<ctor.length;i++ ){ 
  41. 41             Class[] cl = ctor[i].getParameterTypes(); 
  42. 42             if(cl.length == 1){ 
  43. 43                 //实例化对象 
  44. 44                 ci05 = (ClassInstance) Class.forName("ClassInstance").getConstructor(cl).newInstance(new Object[]{"05"}); 
  45. 45             } 
  46. 46         } 
  47. 47         ci05.fun(); 
  48. 48     } 
  49. 49 } 


 3.输出结果




1 有参类的实例化 2 测试...01
3 无参类的实例化 4 测试... 5 测试...01
6 测试...01
7 -------------------额外测试--------------------
8 有参类的实例化 9 测试...05

 　　除了这几种情况可以实例化一个Java类对象外，隐式调用实例化也是利用了已上集中情况。例如常见的方法：


 


  1. 1 public class ClassInstance{ 
  2. 2 　　public ClassInstance(){ 
  3. 3 　　} 
  4. 4     public ClassInstance getInstance(){ 
  5. 5 　　　　return new ClassInstance(); 
  6. 6 　　} 
  7. 7 } 


　　通过观察结果，我们发现无论哪一种方式必须经过的一步---调用构造方法。无论怎样构造函数作为初始化类的意义怎样都不会改变。