在Java中，创建对象通常有以下几种方式：
使用new关键字
这是最常见的方式，通过调用类的构造函数来创建对象。
public class MyClass {
int x;
MyClass(int x) {
this.x = x;
}
public static void main(String[] args) {
MyClass obj = new MyClass(10); // 使用new关键字创建对象
System.out.println(obj.x); // 输出: 10
}
}
使用反射（Reflection）
Java的反射API允许你在运行时创建对象。
public class MyClass {
// ... 省略其他代码 ...
public static void main(String[] args) throws Exception {
Class<?> clazz = MyClass.class;
MyClass obj = (MyClass) clazz.getDeclaredConstructor(int.class).newInstance(20); // 使用反射创建对象
System.out.println(obj.x); // 输出: 20
}
}
注意：反射通常用于更高级的场景，因为它涉及到更多的错误检查和异常处理。
使用Class.forName()与newInstance()（已过时）
虽然Class.newInstance()方法在Java 9中已被标记为过时，但在早期版本中，你可以使用它（与forName()结合）来创建对象。但是，由于它不支持带参数的构造函数，所以其用途有限。
// 注意：此方法在Java 9+中已过时，不建议使用
public class MyClass {
// ... 省略其他代码 ...
// 假设MyClass有一个无参数的构造函数
public static void main(String[] args) throws Exception {
MyClass obj = (MyClass) Class.forName("MyClass").newInstance(); // 使用Class.forName和newInstance创建对象
// 注意：这种方法不支持带参数的构造函数
}
}
使用反序列化（Deserialization）
如果你的对象之前已经被序列化（写入到一个输出流中），你可以通过反序列化来创建它的一个新实例。
import java.io.*;
public class MyClass implements Serializable {
// ... 省略其他代码和序列化ID ...
public static void main(String[] args) throws Exception {
// 假设我们有一个包含MyClass对象的文件
FileInputStream fis = new FileInputStream("myfile.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
MyClass obj = (MyClass) ois.readObject(); // 通过反序列化创建对象
ois.close();
fis.close();
// 现在你可以使用obj了
}
}
使用工厂方法（Factory Method）
下滑查看解决方法
工厂方法是一种设计模式，它使用静态方法来创建对象。这通常用于封装对象的创建逻辑，以便在需要时可以更改它。
public class MyClass {
// ... 省略其他代码 ...
public static MyClass createInstance(int x) {
return new MyClass(x); // 使用工厂方法创建对象
}
public static void main(String[] args) {
MyClass obj = MyClass.createInstance(30); // 使用工厂方法创建对象
System.out.println(obj.x); // 输出: 30
}
}
使用克隆（Clone）
如果你已经有一个对象，并且想要创建它的一个精确副本，你可以使用clone()方法（但需要注意的是，它默认是浅拷贝，且需要实现Cloneable接口）。
public class MyClass implements Cloneable {
int x;
// ... 省略其他代码 ...
@Override
protected MyClass clone() throws CloneNotSupportedException {
return (MyClass) super.clone(); // 使用clone方法创建对象的副本
}
public static void main(String[] args) throws CloneNotSupportedException {
MyClass original = new MyClass(40);
MyClass copy = original.clone(); // 使用clone方法创建对象的副本
System.out.println(copy.x); // 输出: 40
}
}
注意：虽然上述方法都可以用来创建对象，但在实际项目中，最常用的还是使用new关键字和工厂方法。其他方法通常用于更高级或特定的场景。
附：示例代码（全）
以下是本文所用到的所有示例代码。
编写Student学生类
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关键字创建对象
Student student1 = new Student();
System.out.println("使用new关键字创建对象：" + student1);
// 2、使用Class类的newInstance()方法创建对象
Student student2 = Student.class.newInstance();
System.out.println("使用Class类的newInstance()方法创建对象：" + student2);
// 3、使用Constructor类的newInstance()方法创建对象
Constructor student3 = Constructor.class.newInstance();
System.out.println("使用Constructor类的newInstance()方法创建对象：" + student3);
// 4、使用clone()方法创建对象
Student student4 = student2.clone();
System.out.println("使用clone()方法创建对象：" + student4);
try {
// Java序列化是指把Java对象转换为字节序列的过程，而Java反序列化是指把字节序列恢复为Java对象的过程；
// 序列化对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_NAME));
oos.writeObject(student1);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME));
// 5、使用反序列化创建对象
Object student5 = ois.readObject();
System.out.println("使用反序列化创建对象：" + student5);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
}
