Java面试-创建对象，你有几种方法？

点击蓝字“程序员考拉”欢迎关注！

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

• 使用new语句实例化一个对象；
• 通过反射机制创建对象；
• 通过clone()方法创建一个对象；
• 通过反序列化的方式创建对象。

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

new语句实例化一个对象是最常见的用来创建对象的方式。我们看看通过反射机制创建对象。

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

1.什么是反射机制？

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

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

1234567891011121314151617181920212223242526

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();    }  }}

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()方法创建一个对象

123456789101112131415161718192021222324252627282930

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

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.通过反序列化创建一个对象

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152

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

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()方法将序列化存入的对象读出，重新创建一个对象。

 

欢迎点赞分享到朋友圈！

 

原文始发于微信公众号（程序员考拉）：