[java]  view plain  copy
 print ?
  1. package com.lou.creation;  
  2.   
  3. public class Client {  
  4.   
  5.     public static void main(String[] args) {  
  6.         //1.使用new 方式创建对象  
  7.         Worker worker1 = CreateInstanceUtil.createWorker();  
  8.         Worker worker2 = CreateInstanceUtil.createWorker("Louis", 23);  
  9.           
  10.         //2.使用反射机制进行创建：  
  11.         //a.使用反射机制，不带参数 Class 對象的 newInstance() 方法  
  12.         Worker worker3 = CreateInstanceUtil.createWorker1();  
  13.           
  14.         //b.使用反射機制 ， Constructor的 newInstance方法 不带参数  
  15.         Worker worker4 = CreateInstanceUtil.createWorker2();  
  16.           
  17.         //c.使用反射机制 ：带参数的构造函数创建新对象  
  18.         Worker worker5 = CreateInstanceUtil.createWorker3("Louis", 23);  
  19.           
  20.         //3. 使用序列化和反序列化 进行创建，这个实际上是对象的复原  
  21.         //将一个对象存入lou.dat文件内  
  22.         CreateInstanceUtil.storeObject2File("lou.dat");  
  23.         //将对象从文件取出  
  24.         Worker worker6 = CreateInstanceUtil.createWorker4("lou.dat");  
  25.       
  26.         //4.利用对象的深层拷贝功能  
  27.           
  28.         Worker worker7 = CreateInstanceUtil.createWorker5(worker1);  
  29.           
  30.     }  
  31. }  


 

 

[java]  view plain  copy
 print ?
  1. package com.lou.creation;  
  2.   
  3. import java.io.FileInputStream;  
  4. import java.io.FileNotFoundException;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.io.ObjectInput;  
  8. import java.io.ObjectInputStream;  
  9. import java.io.ObjectOutputStream;  
  10. import java.lang.reflect.Constructor;  
  11. import java.lang.reflect.InvocationTargetException;  
  12.   
  13. public class CreateInstanceUtil {  
  14.   
  15.     /* 
  16.      * 方式1： 直接使用new的方式,不使用参数 
  17.      */  
  18.     public static Worker createWorker() {  
  19.         return new Worker();  
  20.     }  
  21.   
  22.     /* 
  23.      * 方式2： 使用new方式，带参数 
  24.      */  
  25.     public static Worker createWorker(String name, int age) {  
  26.         return new Worker(name, age);  
  27.     }  
  28.   
  29.     /* 
  30.      * 方式3： 使用反射机制，不带参数 Class 對象的 newInstance() 方法 
  31.      */  
  32.   
  33.     public static Worker createWorker1() {  
  34.   
  35.         Class clazz = null;  
  36.         Worker worker = null;  
  37.         try {  
  38.             clazz = Class.forName("com.lou.creation.Worker");  
  39.             worker = (Worker) clazz.newInstance();  
  40.         } catch (ClassNotFoundException e) {  
  41.             e.printStackTrace();  
  42.         } catch (InstantiationException e) {  
  43.             e.printStackTrace();  
  44.         } catch (IllegalAccessException e) {  
  45.             e.printStackTrace();  
  46.         }  
  47.   
  48.         return worker;  
  49.     }  
  50.   
  51.     /* 
  52.      * 方式4： 使用反射機制 ， Constructor的 newInstance方法 
  53.      */  
  54.   
  55.     public static Worker createWorker2() {  
  56.         Worker worker = null;  
  57.         try {  
  58.             Class clazz = null;  
  59.             clazz = Class.forName("com.lou.creation.Worker");  
  60.   
  61.             // 获取不带参数的构造器  
  62.             Constructor constructor = clazz.getConstructor();  
  63.             // 使用构造器创建对象  
  64.             worker = (Worker) constructor.newInstance();  
  65.   
  66.         } catch (ClassNotFoundException e) {  
  67.             e.printStackTrace();  
  68.         } catch (InstantiationException e) {  
  69.             e.printStackTrace();  
  70.         } catch (IllegalAccessException e) {  
  71.             e.printStackTrace();  
  72.         } catch (SecurityException e) {  
  73.             e.printStackTrace();  
  74.         } catch (NoSuchMethodException e) {  
  75.             e.printStackTrace();  
  76.         } catch (IllegalArgumentException e) {  
  77.             e.printStackTrace();  
  78.         } catch (InvocationTargetException e) {  
  79.             e.printStackTrace();  
  80.         }  
  81.   
  82.         return worker;  
  83.     }  
  84.   
  85.     /* 
  86.      * 方式5： 使用反射机制 ：带参数的构造函数创建新对象 
  87.      */  
  88.     public static Worker createWorker3(String name, Integer age) {  
  89.         Worker worker = null;  
  90.         try {  
  91.             Class clazz = null;  
  92.             clazz = Class.forName("com.lou.creation.Worker");  
  93.   
  94.             // 获取不带参数的构造器  
  95.             Constructor constructor = clazz.getConstructor(name.getClass(),  
  96.                     age.getClass());  
  97.             // 使用构造器创建对象  
  98.             worker = (Worker) constructor.newInstance(name, age);  
  99.   
  100.         } catch (ClassNotFoundException e) {  
  101.             e.printStackTrace();  
  102.         } catch (InstantiationException e) {  
  103.             e.printStackTrace();  
  104.         } catch (IllegalAccessException e) {  
  105.             e.printStackTrace();  
  106.         } catch (SecurityException e) {  
  107.             e.printStackTrace();  
  108.         } catch (NoSuchMethodException e) {  
  109.             e.printStackTrace();  
  110.         } catch (IllegalArgumentException e) {  
  111.             e.printStackTrace();  
  112.         } catch (InvocationTargetException e) {  
  113.             e.printStackTrace();  
  114.         }  
  115.         return worker;  
  116.     }  
  117.   
  118.     /* 
  119.      * 方式6： 使用序列化和反序列化创建对象，这种方式其实是根据既有的对象进行复制，这个需要事先将可序列化的对象线存到文件里 
  120.      */  
  121.     @SuppressWarnings("resource")  
  122.     public static Worker createWorker4(String objectPath) {  
  123.         ObjectInput input = null;  
  124.         Worker worker = null;  
  125.         try {  
  126.             input = new ObjectInputStream(new FileInputStream(objectPath));  
  127.             worker = (Worker) input.readObject();  
  128.         } catch (FileNotFoundException e) {  
  129.             e.printStackTrace();  
  130.         } catch (IOException e) {  
  131.             e.printStackTrace();  
  132.         } catch (ClassNotFoundException e) {  
  133.             e.printStackTrace();  
  134.         }  
  135.         return worker;  
  136.     }  
  137.   
  138.     /* 
  139.      * 将创建的对象存入到文件内 
  140.      */  
  141.     public static void storeObject2File(String objectPath) {  
  142.         Worker worker = new Worker();  
  143.         ObjectOutputStream objectOutputStream;  
  144.         try {  
  145.             objectOutputStream = new ObjectOutputStream(new FileOutputStream(  
  146.                     objectPath));  
  147.             objectOutputStream.writeObject(worker);  
  148.         } catch (FileNotFoundException e) {  
  149.             // TODO Auto-generated catch block  
  150.             e.printStackTrace();  
  151.         } catch (IOException e) {  
  152.             // TODO Auto-generated catch block  
  153.             e.printStackTrace();  
  154.         }  
  155.     }  
  156.   
  157.     /* 
  158.      * 方式7， 使用对象的 深复制进行复制，创建对象 
  159.      */  
  160.     public static Worker createWorker5(Worker worker) {  
  161.         return (Worker) worker.clone();  
  162.     }  
  163.       
  164.     public static void main(String[] args) {  
  165.           
  166.     }  
  167.   
  168. }  


 

[java]  view plain  copy
 print ?
  1. package com.lou.creation;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. public class Worker implements Cloneable,Serializable {  
  6.   
  7.     private static final long serialVersionUID = 1L;  
  8.     private String name;  
  9.     private int age;  
  10.       
  11.     public Worker()  
  12.     {  
  13.         this.name = "";  
  14.         this.age = 0;  
  15.     }  
  16.       
  17.     public Worker(String name,int age)  
  18.     {  
  19.         this.name = name;  
  20.         this.age = age;  
  21.     }  
  22.       
  23.     public void work()  
  24.     {  
  25.         System.out.println(name +"is working");  
  26.     }  
  27.       
  28.     public Worker clone()  
  29.     {  
  30.         Worker worker = null;  
  31.         try {  
  32.             return (Worker) super.clone();  
  33.         } catch (CloneNotSupportedException e) {  
  34.             // TODO Auto-generated catch block  
  35.             e.printStackTrace();  
  36.         }  
  37.         return worker;  
  38.     }  
  39. }