1.java总结

一.创建对象的几种方式

创建对象的方式共有4种：

（1）使用new语句实例化一个对象：

（2）通过反射机制创建对象；

　　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类的方法主要有一下三种：

　　（1）Class.foeName("类的全路径")；

　　（2）类名.Class

　　（3）实例.getClass();

　　其次通过newInstance()方法创建该类的对象。

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

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

　　　　newInstance：弱类型，低效率，只能调用无参构造；

　　　　new ：强类型，相对高效，能调用任何public构造。

（3）通过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接口；

　　2.在类中重写Object的clone()方法；

　　3.在clone()方法中调用super.clone()；

　　4.把浅复制的引用指向原型对象新的克隆体。

（4）通过反序列化创建对象；

　　1.什么是反序列化？

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

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

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

猜你喜欢