java创建对象的途径

java中可以通过4种途径创建对象：

 

1 通过new创建

2 通过clone创建

3 通过反射机制

4 对象的序列化与反序列化

 

通过new创建

  在B类中创建A类对象  A a=new A();  要求A类的构造函数在B类中是可见的

 

通过clone创建

 对于克隆(Clone)，Java有一些限制：
    1、被克隆的类必须自己实现Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。Cloneable 接口实际上是个标识接口，没有任何接口方法。
    2、实现Cloneable接口的类应该使用公共方法重写 Object.clone（它是受保护的）。某个对象实现了此接口就克隆它是不可能的。即使 clone 方法是反射性调用的，也无法保证它将获得成功。
    3、在Java.lang.Object类中克隆方法是这么定义的：
    protected Object clone()
                    throws CloneNotSupportedException
    创建并返回此对象的一个副本。表明是一个受保护的方法，同一个包中可见。

   克隆方法构造对象与构造函数无关，即不要求构造函数是可见的，只要有一个克隆对象就行。

    克隆创建对象举例：

package clone;

public class PrivateB implements Cloneable {
 public String b = "bb";

 private static PrivateB pb = new PrivateB();

 private PrivateB() {

 }

 public static PrivateB getInstance() {
  return pb;
 }

 public Object clone() throws CloneNotSupportedException {
      
  return super.clone();

 }
}

 

package clone;

public class CreateB {
    public void create(){
     PrivateB pb=PrivateB.getInstance();
     try {
   PrivateB pb1=(PrivateB) pb.clone();
   //pb1.b="ddss";
   System.out.print(pb1.b);
   System.out.print(pb.b);
  } catch (CloneNotSupportedException e) {
   
   e.printStackTrace();
  }
     
    }
   
    public static void main(String args[]){
  new CreateB().create();
 }
}

  运行CreateB输出结果为：bbbb

  因为用克隆方法创建对象与构造函数无关，所以使用单例模式的类不要用克隆方法。

 

 

通过反射机制

 package reflect.model;

public class PrivateA {

 public String a = "private";

 public PrivateA() {

 }
}

 

package reflect;

import reflect.model.PrivateA;

public class Test {

 public void get() {
  String name="reflect.model.PrivateA";
  try {
   PrivateA pa = (PrivateA)Class.forName(name).newInstance();
   System.out.println(pa.a);
  } catch (InstantiationException e) {
   
   e.printStackTrace();
  } catch (IllegalAccessException e) {
   
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   
   e.printStackTrace();
  }
 }
 
 public static void main(String args[]){
  new Test().get();
 }
}

运行test输出结果为：private

通过反射机制创建对象就是解决只知道类名时怎么创建对象。

注意：Test 之所以可以通过反射机制创建PrivateA 的对象是因为PrivateA 的构造函数是可见的。如果PrivateA 的构造函数是不可见的，则不能通过反射机制创建PrivateA 的对象。

 

对象的序列化与反序列化

 

 package objectoutput;

import java.io.Serializable;

public class A implements Serializable
{
    
 private static A a=new A();
     public String aa="aa";
    
     public A(){}
    
     public static A getInstanse(){
      return a;
     }
}

 

package objectoutput;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class CreatA {
     
 public static void main(String[] args) 
 {
 
 try
 {
 File testFile=new File("E:/Info.dat");
 ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream(testFile,true));
 
 out.writeObject(A.getInstanse());
 out.flush();
 out.close();
 ObjectInputStream in=new ObjectInputStream(new FileInputStream(testFile));
 A temp;
 try
 {
 temp= (A) in.readObject();
 
     System.out.println("Object :"+temp.aa);
 }
 catch(Exception e)
 {
 e.printStackTrace();
 }
 in.close();
 
 }
 catch(Exception e)
 {
 
 e.printStackTrace();
 }
 }

}

 

运行结果：Object :aa

作用：保存对象的运行状态并回复他