Java深海拾遗系列（7）--- Java 创建对象的不同姿势

 

使用new关键字     

     使用new关键字是创建对象的最基本方法。这是在java中创建对象的最常见方法。几乎99%的对象都是用这种方式创建的。通过使用这个方法，我们可以调用任何想要调用的构造函数(没有参数或参数化的构造函数)。

package org.cfj.objcreate;

public class NewKeywordEx {
    String name="NewKeyCreateObj";

    public static void main(String[] args) {
         NewKeywordEx newKeywordEx=new NewKeywordEx();
        System.out.println(newKeywordEx.name);
    }
}

使用New Instance

      使用new instance：如果我们知道类的名称，并且它具有公共默认构造函数，则可以创建一个对象–Class.forName。 我们可以使用它来创建类的对象。 实际上，Class.forName使用Java加载了Class，但没有创建任何Object。 要创建该类的对象，您必须使用该类的新实例方法。

package org.cfj.objcreate;

public class NewInstanceEx {
    String name = "newInstanceEx";
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Class cl = Class.forName("org.cfj.objcreate.NewInstanceEx");
        NewInstanceEx newInstanceEx = (NewInstanceEx) cl.newInstance();
        System.out.println(newInstanceEx.name);

    }
}

使用Clone

   每当在任何对象上调用clone()时，JVM实际上会创建一个新对象，并将前一个对象的所有内容复制到其中。使用克隆方法创建对象不会调用任何构造函数。要在对象上使用clone()方法，我们需要实现Cloneable并在其中定义clone()方法。

package org.cfj.objcreate;

public class cloneEx implements Cloneable {
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    private String name = "cloneEx";
    CloneExModel cloneExModel = new CloneExModel("张三", "123");

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, CloneNotSupportedException {
        cloneEx cloneEx = new cloneEx();
        cloneEx cloneEx1 = (cloneEx) cloneEx.clone();
        cloneEx1.name = "cloneEx1";
        System.out.println(cloneEx.name); //输出：cloneEx
        System.out.println(cloneEx1.name); //输出：cloneEx1
        System.out.println(cloneEx == cloneEx1); //输出：false
        cloneEx1.cloneExModel.setUserName("张三clone");
        System.out.println(cloneEx.cloneExModel.getUserName());//输出：张三
        System.out.println(cloneEx1.cloneExModel.getUserName());//输出：张三
    }
}

Note:

•  这里我们创建的是现有对象的克隆，而不是任何新对象。
•  类需要实现Cloneable接口，否则将抛出CloneNotSupportedException。

使用反序列化

     无论何时序列化和反序列化一个对象，JVM都会创建一个单独的对象。在反序列化中，JVM不使用任何构造函数来创建对象.为了反序列化对象，我们需要在类中实现Serializable接口。 

package org.cfj.objcreate;

import java.io.*;

public class DeserializationEx implements Serializable {
    private String name;

    DeserializationEx(String name) {
        this.name = name;
    }

    public static void main(String[] args) throws IOException {
        /*
      //  使用writeObject()方法序列化反序列化示例类的对象，并将其写入file.txt文件

        DeserializationEx d =
                new DeserializationEx("DeserializationEx");
        FileOutputStream f = new FileOutputStream("file.txt");
        ObjectOutputStream oos = new ObjectOutputStream(f);
        oos.writeObject(d);
        oos.close();
        f.close();
*/

        try
        {
            DeserializationEx d1;
            FileInputStream f1 = new FileInputStream("file.txt");
            ObjectInputStream oos1 = new ObjectInputStream(f1);
            d1 = (DeserializationEx)oos1.readObject();
            System.out.println(d1.name); //DeserializationEx
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

}

用Constructor类的 newInstance()

    java.lang.reflect.Constructor类中有一个newInstance（）方法，可用于创建对象。 通过使用此newInstance（）方法，它还可以调用参数化构造函数和私有构造函数。

package org.cfj.objcreate;

import java.lang.reflect.Constructor;

public class ReflectionEx {
    private String name;
    ReflectionEx()
    {
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public static void main(String[] args)
    {
        try
        {
            Constructor<ReflectionEx> constructor
                    = ReflectionEx.class.getDeclaredConstructor();
            ReflectionEx r = constructor.newInstance();
            r.setName("ReflectionEx");
            System.out.println(r.name);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}