Java对象的创建

   1.用new语句创建对象，这是最常见的创建对象的方法。
   2.运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
 3.调用对象的clone()方法。
 4.运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。
1
2
3
4

clone() 方法

要调用对象的 clone() 方法来创建对象的副本，我们需要进行以下步骤：

1. 创建一个实现了 Cloneable 接口的类，该接口是一个标记接口，用于指示该类可以被克隆。
2. 在该类中重写 clone() 方法，并在方法中调用 super.clone() 方法来获取对象的浅拷贝。
3. 在代码中使用 new 关键字创建原始对象。
4. 调用原始对象的 clone() 方法来创建对象的副本。
   下面是一个示例代码，演示了如何创建对象并调用 clone() 方法来创建对象的副本：

public class CloneExample {
    public static void main(String[] args) throws CloneNotSupportedException {
        // 创建原始对象
        MyClass obj1 = new MyClass("Hello, World!");

        // 调用 clone() 方法创建对象的副本
        MyClass obj2 = (MyClass) obj1.clone();

        // 打印原始对象和副本对象的属性
        System.out.println("Original: " + obj1.getMessage());
        System.out.println("Cloned: " + obj2.getMessage());
    }
}

class MyClass implements Cloneable {
    private String message;

    public MyClass(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在上述示例中，我们首先创建了一个名为 CloneExample 的主类，其中定义了一个名为 MyClass 的自定义类。MyClass 类实现了 Cloneable 接口，并重写了 clone() 方法。
我们使用 new 关键字创建原始对象 obj1，并将其消息设置为 “Hello, World!”。
然后，我们调用 clone() 方法创建对象的副本 obj2，并将其强制转换为 MyClass 类型。
最后，我们打印原始对象和副本对象的属性，可以看到它们具有相同的消息。
需要注意的是，为了正确地实现克隆，我们需要重写 clone() 方法，并在其中调用 super.clone() 方法。
通过调用对象的 clone() 方法，我们可以创建对象的副本，以便进行修改、备份或传递给其他部分使用。

反序列化

以下是一个示例，演示了如何使用反序列化调用 java.io.ObjectInputStream 对象的 readObject() 方法： 或者fastjson等

import java.io.*;
public class DeserializationExample {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 序列化对象到文件
        serialize(new Person("John", 30), "person.ser");
        // 反序列化并调用 readObject() 方法获取对象
        Person deserializedPerson = deserialize("person.ser");
        System.out.println("Name: " + deserializedPerson.getName());
        System.out.println("Age: " + deserializedPerson.getAge());
    }
    private static void serialize(Object object, String fileName) throws IOException {
        FileOutputStream fileOut = new FileOutputStream(fileName);
        ObjectOutputStream objOut = new ObjectOutputStream(fileOut);
        objOut.writeObject(object);
        objOut.close();
        fileOut.close();
        System.out.println("Object serialized successfully.");
    }
    private static Person deserialize(String fileName) throws IOException, ClassNotFoundException {
        FileInputStream fileIn = new FileInputStream(fileName);
        ObjectInputStream objIn = new ObjectInputStream(fileIn);
        Person person = (Person) objIn.readObject();
        objIn.close();
        fileIn.close();
        System.out.println("Object deserialized successfully.");
        return person;
    }
}

class Person implements Serializable {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

在上述示例中，我们首先使用 serialize() 方法将 Person 对象序列化为文件 person.ser。
接下来，我们使用 deserialize() 方法从文件中反序列化对象，并将其转换为 Person 类型。在这个过程中，我们调用了 ObjectInputStream 对象的 readObject() 方法，它返回了反序列化后的对象。
最后，我们通过调用对象的方法获取了姓名和年龄，并进行打印输出。
需要注意的是，在使用反序列化的过程中，可能会抛出 IOException 和 ClassNotFoundException 异常，因此需要进行异常处理。
通过使用反序列化，我们可以从文件（或其他流）中读取已序列化的对象，并将其重新还原为原始对象。这在某些场景下非常有用，例如在分布式系统中的对象传输和持久化存储等。

反射

以下是一个示例，演示了如何使用反射调用 java.lang.Class 或

java.lang.reflect.Constructor 类的 newInstance() 方法：
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectionExample {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 使用 Class 类的 newInstance() 方法创建对象
        Class<MyClass> clazz = MyClass.class;
        MyClass instance1 = clazz.newInstance();

        // 使用 Constructor 类的 newInstance() 方法创建对象
        Constructor<MyClass> constructor = clazz.getDeclaredConstructor();
        MyClass instance2 = constructor.newInstance();

        // 检查两个实例是否相等
        System.out.println("instance1 == instance2: " + (instance1 == instance2));
    }
}

class MyClass {
    public MyClass() {
        System.out.println("MyClass Constructor called");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

在上述示例中，我们首先使用 Class 类的 newInstance() 方法来创建一个 MyClass 类的实例 instance1。这种方式适用于当我们已经有了类的 Class 对象时。
接下来，我们使用 Constructor 类的 newInstance() 方法来创建一个 MyClass 类的实例 instance2。在这种情况下，我们通过调用 getDeclaredConstructor() 方法获取到类的默认构造器，并通过反射调用 newInstance() 方法来创建对象。
最后，我们检查 instance1 和 instance2 是否相等，输出结果显示它们确实相等，证明两种方式都成功地创建了对象。
需要注意的是，在使用反射调用 newInstance() 方法时，需要处理可能抛出的异常，如 NoSuchMethodException、IllegalAccessException 和 InvocationTargetException 等。
使用反射调用 newInstance() 方法可以在运行时动态地创建对象，这在某些场景下非常有用，比如依据类名字符串动态创建对象，或者在不知道类的具体类型时创建对象。但请注意，为了保证代码的可读性和稳定性，建议尽量使用普通方式来创建实例化对象，而不是过度依赖反射机制。