java創建類的5種方式

1、使用new關鍵字 } → 調用了構造函數

這種方式，我們可以調用任意的構造函數(無參的和帶參數的)。

2、使用Class類的newInstance方法 } → 調用了構造函數

使用Class類的newInstance方法創建對象。這個newInstance方法調用無參的構造函數創建對象。

3、使用Constructor類的newInstance方法 } → 調用了構造函數

和Class類的newInstance方法很像， java.lang.reflect.Constructor類里也有一個newInstance方法可以創建對象。我們可以通過這個newInstance方法調用有參數的和私有的構造函數。

4、使用clone方法 } → 沒有調用構造函數

無論何時我們調用一個對象的clone方法，jvm就會創建一個新的對象，將前面對象的內容全部拷貝進去。用clone方法創建對象並不會調用任何構造函數。

要使用clone方法，我們需要先實現Cloneable接口並實現其定義的clone方法。

5、使用反序列化 } → 沒有調用構造函數

當我們序列化和反序列化一個對象，jvm會給我們創建一個單獨的對象。在反序列化時，jvm創建對象並不會調用任何構造函數。
為了反序列化一個對象，我們需要讓我們的類實現Serializable接口

 

代碼demo

package javatest.demo;

import java.io.Serializable;

public class PrintTest implements Cloneable, Serializable {

    public static final long serivalVersion = 1L;

    private String name;

    public PrintTest() {
        System.out.println("this is Constructor");
    }

    public void hello() {
        System.out.println("hello ");
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        PrintTest other = (PrintTest) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "PrintTest [name=" + name + "]";
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return super.clone();
    }

    public String getName() {
        return name;
    }

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

}

package javatest.demo;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;

/**
 * 創建一個類的幾種方法?
 * 
 * @author BrokenColor
 * @date 2018年6月7日
 */
public class InstanceDemo {

    public static void main(String[] args) {

        // 使用new關鍵字} → 調用了構造函數
        System.out.println("=================new關鍵字:");
        PrintTest printtest1 = new PrintTest();
        printtest1.setName("printtest1");
        System.out.println(printtest1 + ",hashcode:" + printtest1.hashCode());
        printtest1.hello();
        try {
            // 使用Class類的newInstance方法} → 調用了構造函數
            System.out.println("=========Class類的newInstance方法:");
            PrintTest printtest2 = (PrintTest) Class.forName("javatest.demo.PrintTest").newInstance();
            //或者可以
            // PringtTest pringttest2 = PringtTest.class.newInstance();
            printtest2.setName("printtest2");
            System.out.println(printtest2 + ",hashcode:" + printtest2.hashCode());
            printtest2.hello();

            // 使用Constructor類的newInstance方法 } → 調用了構造函數
            System.out.println("=======Constructor類的newInstance方法:");
            Constructor<PrintTest> constructor = PrintTest.class.getConstructor();
            PrintTest printTest3 = (PrintTest) constructor.newInstance();
            printTest3.setName("printTest3");
            System.out.println(printTest3 + ",hashcode:" + printTest3.hashCode());
            printTest3.hello();

            // 使用clone方法 } → 沒有調用構造函數
            System.out.println("=======使用clone方法 } → 沒有調用構造函數");
            PrintTest printTest4 = (PrintTest) printTest3.clone();
            printTest4.setName("printTest4");
            System.out.println(printTest4+",hashcode:"+printTest4.hashCode());
            
            //序列化
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.obj"));
            out.writeObject(printTest4);
            out.close();

            // 使用反序列化 } → 沒有調用構造函數
            System.out.println("===========使用反序列化");
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
            PrintTest printTest5 = (PrintTest) in.readObject();
            printTest5.setName("printTest5");
            System.out.println(printTest5+",hashcode:"+printTest5.hashCode());
            printTest5.hello();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

運行結果：