Java中创建对象的方式

一、使用new关键字

下面是使用 new 关键字创建对象的示例代码，同时演示了如何调用不同构造函数的方式：

public class Person {
    private String name;
    private int age;
    
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }
    
    public Person(String name) {
        this.name = name;
        this.age = 0;
    }
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public static void main(String[] args) {
        // 调用无参构造函数
        Person person1 = new Person();
        System.out.println("Name: " + person1.getName());
        System.out.println("Age: " + person1.getAge());
        
        // 调用带有一个参数的构造函数
        Person person2 = new Person("John");
        System.out.println("Name: " + person2.getName());
        System.out.println("Age: " + person2.getAge());
        
        // 调用带有两个参数的构造函数
        Person person3 = new Person("Jane", 25);
        System.out.println("Name: " + person3.getName());
        System.out.println("Age: " + person3.getAge());
    }
}

在上述示例中，我们扩展了 Person 类，添加了不同的构造函数：无参构造函数、一个参数的构造函数和两个参数的构造函数。

通过调用不同的构造函数，我们可以传递不同的参数来创建对象，并获取对象的属性值。

二、使用反射机制

当使用反射机制创建对象时，可以通过以下步骤进行：

1. 获取类的 Class 对象，可以使用 Class.forName() 方法，传入类的全限定名。

2. 通过 Class 对象的 newInstance() 方法创建对象。这个方法会调用类的默认构造函数来创建对象。

下面是一个简单的示例代码：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectionDemo {
    public static void main(String[] args) {
        try {
            // 获取类的Class对象
            Class<?> clazz = Class.forName("com.example.MyClass");

            // 使用newInstance()方法创建对象
            Object obj = clazz.newInstance();

            // 输出对象信息
            System.out.println(obj);

        } catch (ClassNotFoundException | IllegalAccessException |
                InstantiationException e) {
            e.printStackTrace();
        }
    }
}

class MyClass {
    // 默认构造函数
    public MyClass() {
        System.out.println("MyClass对象被创建");
    }
}

在上面的示例中，我们使用反射机制创建了一个名为 MyClass 的对象，并输出了对象信息。

✨除此之外✨，还可以使用 Constructor 类的 newInstance() 方法来创建对象。

下面是一个示例代码：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectionDemo {
    public static void main(String[] args) {
        try {
            // 获取类的Class对象
            Class<?> clazz = MyClass.class;

            // 获取类的构造函数
            Constructor<?> constructor = clazz.getConstructor();

            // 使用构造函数的newInstance()方法创建对象
            Object obj = constructor.newInstance();

            // 输出对象信息
            System.out.println(obj);

        } catch (NoSuchMethodException | IllegalAccessException |
                InstantiationException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

class MyClass {
    // 默认构造函数
    public MyClass() {
        System.out.println("MyClass对象被创建");
    }
}

在上面的示例中，我们首先使用 MyClass.class 获取了类的 Class 对象，然后通过 getConstructor() 方法获取了默认构造函数的 Constructor 对象。最后，我们使用构造函数对象的 newInstance() 方法创建了一个 MyClass 对象，并输出了对象信息。

需要注意的是：使用 Constructor 类的 newInstance() 方法时，需要处理可能抛出的异常，如 NoSuchMethodException、IllegalAccessException、InstantiationException 和 InvocationTargetException。

• Class 类的 newInstance() 方法和 Constructor 类的 newInstance() 方法都属于反射机制的一部分。

• Class 类的 newInstance() 方法是一个方便的方法，它会调用类的默认构造函数来创建一个对象。该方法在 JDK 9 中已经被标记为过时（deprecated），并且在未来的版本中可能会被移除。推荐使用 Constructor 类的 newInstance() 方法来创建对象。

• Constructor 类的 newInstance() 方法可以通过指定构造函数的参数来创建对象。这样可以灵活地调用不同的构造函数来创建对象。newInstance() 方法会抛出 InstantiationException、IllegalAccessException 和 InvocationTargetException 异常，需要进行异常处理。

三、使用clone方法

使用clone()方法可以创建一个对象的副本。clone()方法是Object类中的一个方法，它创建并返回一个与原始对象相同的新对象。

具体步骤如下：

1. 首先，需要确保要克隆的类实现了Cloneable接口，该接口标记了类可以被克隆。

2. 在要克隆的类中，重写clone()方法，调用父类的clone()方法，并将返回的对象进行强制转换。

以下是一个示例代码：

public class CloneExample implements Cloneable {
    private String name;

    public CloneExample(String name) {
        this.name = name;
    }

    // 重写clone()方法
    @Override
    public CloneExample clone() throws CloneNotSupportedException {
        return (CloneExample) super.clone();
    }

    public static void main(String[] args) {
        try {
            // 创建原始对象
            CloneExample original = new CloneExample("Original");

            // 克隆对象
            CloneExample clone = original.clone();

            // 修改原始对象的属性
            original.setName("Modified Original");

            // 输出结果
            System.out.println("Original: " + original.getName());
            System.out.println("Clone: " + clone.getName());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }

    public String getName() {
        return name;
    }

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

在上述示例中，首先创建了一个CloneExample类，它实现了Cloneable接口。然后，重写了clone()方法，调用父类的clone()方法，并将返回的对象进行强制转换。在main()方法中，创建了一个原始对象original，然后通过original.clone()方法克隆出一个新对象clone。修改原始对象的属性后，输出原始对象和克隆对象的属性值。

✨注意：✨

• clone()方法是浅拷贝，即它只复制对象的引用，而不会复制对象的内容。如果对象中包含可变的引用类型成员变量，则修改其中一个对象的成员变量会影响另一个对象。

• 如果要实现深拷贝，即复制对象及其所有引用类型成员变量的内容，需要在clone()方法中递归地克隆这些引用类型成员变量。

四、使用反序列化

使用反序列化可以创建一个对象，反序列化是将对象的序列化表示转换回对象的过程。

具体步骤如下：

1. 首先，需要一个包含对象序列化数据的文件或字节数组。

2. 创建一个ObjectInputStream对象，用于从文件或字节数组中读取对象的序列化数据。

3. 使用ObjectInputStream对象的readObject()方法读取对象的序列化数据，并返回一个Object类型的对象。

4. 将返回的Object对象强制转换为实际的对象类型。

5. 以下是一个示例代码：

import java.io.*;

public class DeserializeExample {
    public static void main(String[] args) {
        try {
            // 从文件中读取对象的序列化数据
            FileInputStream fileIn = new FileInputStream("object.ser");
            ObjectInputStream in = new ObjectInputStream(fileIn);

            // 反序列化对象
            MyObject obj = (MyObject) in.readObject();

            // 关闭输入流
            in.close();
            fileIn.close();

            // 使用反序列化得到的对象
            System.out.println("Object: " + obj);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class MyObject implements Serializable {
    private static final long serialVersionUID = 1L;

    private String name;

    public MyObject(String name) {
        this.name = name;
    }

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

6. 在上述示例中，首先通过FileInputStream从文件中读取对象的序列化数据，然后创建一个ObjectInputStream对象in，使用in的readObject()方法读取对象的序列化数据，返回一个Object对象。接着将返回的Object对象强制转换为实际的对象类型MyObject，并使用该对象。