Java創(chuàng)建對象的六種常用方式總結(jié)

更新時間：2024年06月22日 11:30:31 作者：代碼無疆

作為Java開發(fā)者,經(jīng)常創(chuàng)建很多對象,你是否知道Java中創(chuàng)建對象有哪些方式呢?下面這篇文章主要給大家介紹了關(guān)于Java創(chuàng)建對象的六種常用方式,文中通過代碼介紹的非常詳細(xì),需要的朋友可以參考下

使用new關(guān)鍵字

這是最常見的方式，通過調(diào)用類的構(gòu)造函數(shù)來創(chuàng)建對象。

public class MyClass {
    int x;

    MyClass(int x) {
        this.x = x;
    }

    public static void main(String[] args) {
        MyClass obj = new MyClass(10); // 使用new關(guān)鍵字創(chuàng)建對象
        System.out.println(obj.x); // 輸出: 10
    }
}

使用反射（Reflection）

Java的反射API允許你在運行時創(chuàng)建對象。

public class MyClass {
    // ... 省略其他代碼 ...

    public static void main(String[] args) throws Exception {
        Class<?> clazz = MyClass.class;
        MyClass obj = (MyClass) clazz.getDeclaredConstructor(int.class).newInstance(20); // 使用反射創(chuàng)建對象
        System.out.println(obj.x); // 輸出: 20
    }
}

注意：反射通常用于更高級的場景，因為它涉及到更多的錯誤檢查和異常處理。

使用Class.forName()與newInstance()（已過時）

雖然Class.newInstance()方法在Java 9中已被標(biāo)記為過時，但在早期版本中，你可以使用它（與forName()結(jié)合）來創(chuàng)建對象。但是，由于它不支持帶參數(shù)的構(gòu)造函數(shù)，所以其用途有限。

// 注意：此方法在Java 9+中已過時，不建議使用
public class MyClass {
    // ... 省略其他代碼 ...

    // 假設(shè)MyClass有一個無參數(shù)的構(gòu)造函數(shù)
    public static void main(String[] args) throws Exception {
        MyClass obj = (MyClass) Class.forName("MyClass").newInstance(); // 使用Class.forName和newInstance創(chuàng)建對象
        // 注意：這種方法不支持帶參數(shù)的構(gòu)造函數(shù)
    }
}

使用反序列化（Deserialization）

如果你的對象之前已經(jīng)被序列化（寫入到一個輸出流中），你可以通過反序列化來創(chuàng)建它的一個新實例。

import java.io.*;

public class MyClass implements Serializable {
    // ... 省略其他代碼和序列化ID ...

    public static void main(String[] args) throws Exception {
        // 假設(shè)我們有一個包含MyClass對象的文件
        FileInputStream fis = new FileInputStream("myfile.ser");
        ObjectInputStream ois = new ObjectInputStream(fis);
        MyClass obj = (MyClass) ois.readObject(); // 通過反序列化創(chuàng)建對象
        ois.close();
        fis.close();
        // 現(xiàn)在你可以使用obj了
    }
}

使用工廠方法（Factory Method）

下滑查看解決方法

工廠方法是一種設(shè)計模式，它使用靜態(tài)方法來創(chuàng)建對象。這通常用于封裝對象的創(chuàng)建邏輯，以便在需要時可以更改它。

public class MyClass {
    // ... 省略其他代碼 ...

    public static MyClass createInstance(int x) {
        return new MyClass(x); // 使用工廠方法創(chuàng)建對象
    }

    public static void main(String[] args) {
        MyClass obj = MyClass.createInstance(30); // 使用工廠方法創(chuàng)建對象
        System.out.println(obj.x); // 輸出: 30
    }
}

使用克?。–lone）

如果你已經(jīng)有一個對象，并且想要創(chuàng)建它的一個精確副本，你可以使用clone()方法（但需要注意的是，它默認(rèn)是淺拷貝，且需要實現(xiàn)Cloneable接口）。

public class MyClass implements Cloneable {
    int x;

    // ... 省略其他代碼 ...

    @Override
    protected MyClass clone() throws CloneNotSupportedException {
        return (MyClass) super.clone(); // 使用clone方法創(chuàng)建對象的副本
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        MyClass original = new MyClass(40);
        MyClass copy = original.clone(); // 使用clone方法創(chuàng)建對象的副本
        System.out.println(copy.x); // 輸出: 40
    }
}

注意：雖然上述方法都可以用來創(chuàng)建對象，但在實際項目中，最常用的還是使用new關(guān)鍵字和工廠方法。其他方法通常用于更高級或特定的場景。

附：示例代碼（全）

以下是本文所用到的所有示例代碼。

編寫Student學(xué)生類

package com.effective.chapter2.other;
 
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
 
import java.io.Serializable;
 
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Cloneable, Serializable {
    private String name;
    private Integer age;
 
    @Override
    public Student clone() {
        try {
            Student clone = (Student) super.clone();
            // TODO: copy mutable state here, so the clone can't change the internals of the original
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

編寫測試類

package com.effective.chapter2.other;
 
import java.io.*;
import java.lang.reflect.Constructor;
 
public class CreateObjectTest {
 
    private static final String FILE_NAME = "student.obj";
 
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, IOException {
 
        // 1、使用new關(guān)鍵字創(chuàng)建對象
        Student student1 = new Student();
        System.out.println("使用new關(guān)鍵字創(chuàng)建對象：" + student1);
 
        // 2、使用Class類的newInstance()方法創(chuàng)建對象
        Student student2 = Student.class.newInstance();
        System.out.println("使用Class類的newInstance()方法創(chuàng)建對象：" + student2);
 
        // 3、使用Constructor類的newInstance()方法創(chuàng)建對象
        Constructor student3 = Constructor.class.newInstance();
        System.out.println("使用Constructor類的newInstance()方法創(chuàng)建對象：" + student3);
 
        // 4、使用clone()方法創(chuàng)建對象
        Student student4 = student2.clone();
        System.out.println("使用clone()方法創(chuàng)建對象：" + student4);
 
        try {
            // Java序列化是指把Java對象轉(zhuǎn)換為字節(jié)序列的過程，而Java反序列化是指把字節(jié)序列恢復(fù)為Java對象的過程；
            // 序列化對象
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_NAME));
            oos.writeObject(student1);
 
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME));
            // 5、使用反序列化創(chuàng)建對象
            Object student5 = ois.readObject();
            System.out.println("使用反序列化創(chuàng)建對象：" + student5);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}