Java创建对象的方式

Java创建对象的方式共有四种：

• 使用new语句实例化一个对象；

• 通过反射机制创建对象；

• 通过clone()方法创建一个对象；

• 通过反序列化的方式创建对象。

一.使用new语句实例化一个对象

new语句实例化一个对象是最常见的用来创建对象的方式。

二.通过反射机制创建对象

1.什么是反射机制？

反射机制是java的一个非常重要的特性，它允许程序在运行时进行自我检查，同时也允许对其内部的成员进行操作。反射机制提供的功能主要有：得到一个对象所属的类；获取一个类的所有成员变量和方法；在运行时创建对象；在运行时调用对象的方法。

2.通过反射机制创建对象

package com.java.test;
class Base{
  public void f(){ 
   System.out.println("Base");  
}
}

class Sub extends Base{ 
 //重写父类的成员方法  
public void f(){ 
   System.out.println("Sub");  
}}

public class CreateInstanceTest { 
 public static void main(String[] args){
    try{   
   //参数必须为类的全路径      
Class c=Class.forName("com.java.test.Sub");  
//创建对象 
  Base b=(Base)c.newInstance();     
 b.f();    
}catch(Exception e){  
    e.printStackTrace();    
}  
}

}

通过反射机制创建对象时，首先通过反射机制加载类获得Class类，获得Class类的方法主要有以下三种：

• Class.forName("类的全路径");

• 类名.Class;

• 实例.getClass();

其次使用newInstance()方法创建该类的对象。

3.new和newInstance()创建对象的区别在哪里？

• new是关键字，创建一个新类；newInstance()是方法，使用类加载机制，使用newInstance()必须保证这个类已经被加载；

• newInstance: 弱类型，低效率，只能调用无参构造；new: 强类型，相对高效，能调用任何public构造。

三.使用clone()方法创建一个对象

package com.java.test;
class Student implements Cloneable{
      public int number;    

public void setInt(int number){  
      this.number=number;   
 }    

public int getInt(){  
      return number;    
}    

@Override   
 public Object clone(){ 
       Student stu=null;        try{  
          stu=(Student)super.clone();       
 }catch(Exception e){ 
      e.printStackTrace(); 
       }       
 return stu;   
 }
}  

public class CloneTest { 
   public static void main(String[] args){
        Student stu1=new Student();
        Student stu2=(Student)stu1.clone(); 
       boolean flag=(stu1==stu2);  
      System.out.println("stu1和stu2是同一个对象吗？"+flag);   
 }}//stu1和stu2是同一个对象吗？false

使用clone()方法创建对象的步骤如下：

1. 实现clone的类首先要继承Cloneable接口，class Student implements Cloneable{}；

2. 在类中重写Object中的clone()方法，@Override public Object clone() {}

3. 在clone()方法中调用super.clone()，Student stu2 = (Student)stu1.clone()；

4. 把浅复制的引用指向原型对象新的克隆体，Student stu2 = (Student)stu1.clone()；

四.通过反序列化创建一个对象

1.什么是反序列化？

序列化是一种将对象以一连串的字节描述的过程，可以将对象写在流里进行网络传输，或者保存到文件、数据库等系统里。与序列化相反的是反序列化，它将流转换为对象。

2.通过反序列化创建一个对象

package com.java.test;
import java.io.FileInputStream;import java.io.FileOutputStream;
import java.io.ObjectInputStream;import java.io.ObjectOutputStream;
import java.io.Serializable;
//Serializable-->标志性接口，表示该类的数据成员可以被序列化

public class People implements Serializable{

  public String name; 
 public int age; 
 public String getName() {

    return name;  
}  

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

public int getAge() { 
   return age; 
 }  

public void setAge(int age) { 
   this.age = age; 
 } 
 public People(){

    this.name="Lili";   
 this.age=18;  } 
 public static void main(String[] args){  
  People p=new People();    
ObjectOutputStream oos=null;    
ObjectInputStream ois=null;   
 try{     
 FileOutputStream fos=new FileOutputStream("people.txt"); 
     oos=new ObjectOutputStream(fos);  
    oos.writeObject(p);    
  oos.close();    
}catch(Exception e){   
   e.printStackTrace();
    }   
 //反序列化    
try{   
   FileInputStream fis=new FileInputStream("people.txt"); 
     ois=new ObjectInputStream(fis);    
  People p1=(People) ois.readObject();   
   System.out.println("p1和p是同一个对象吗？"+(p1==p));  
  }catch(Exception e){  
    e.printStackTrace();  
  }  
}}//p1和p是同一个对象吗？false

 序列化时首先创建一个输出流对象oos,使用oos的writeObject()方法将p对象写入oos对象中去。使用反序列化创建对象时，首先创建一个输入流对象ois，使用输入流对象ois的readObject()方法将序列化存入的对象读出，重新创建一个对象。