Java创建对象的5种方式

1. new 关键字

可以随意的调用构造器

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        Person person2 = new Person("name");
    }
}

2. 反射机制（Class.forName(“完整类名”)）

优点：使用灵活，可以不修改代码，通过修改配置文件来任意的创建对象

如果只希望一个类的静态代码执行，其他代码不执行，就可使用反射机制

例：Class.forName(“com.mysql.cj.jdbc.Driver”);

public class Main {
    public static void main(String[] args) throws Exception {
        Class<Person> clazz = (Class<Person>) Class.forName("Person");
        Person person = clazz.newInstance();
        System.out.println(person);
    }
}

注：使用newInstance创建类时，被创建的类中必须存在无参构造否则会报错

Exception in thread "main" java.lang.InstantiationException: Person
	at java.lang.Class.newInstance(Class.java:427)
	at Main.main(Main.java:9)
Caused by: java.lang.NoSuchMethodException: Person.<init>()
	at java.lang.Class.getConstructor0(Class.java:3082)
	at java.lang.Class.newInstance(Class.java:412)
	... 1 more

3.Constructors.Instance()

比Class.forName()的功能更加强大，可以使用它调用一些私有的构造方法，而不仅仅限制于public

3.1 getDeclaredConstructors()

代码：

public class Person {
    String name;
 
    public Person() {
    }
 
    public Person(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
 
        Constructor<?>[] constructors = Person.class.getDeclaredConstructors();
        System.out.println(constructors[0]);
        System.out.println(constructors[1]);
        Person person = (Person) constructors[0].newInstance();
        System.out.println(person);
        Person person1 = (Person) constructors[1].newInstance("111");
        System.out.println(person1);
 
    }
}

执行结果：

public Person()
public Person(java.lang.String)
Person{name='null'}
Person{name='111'}

注：constructors数组中构造参数的下标取决与被创建类中构造方法的前后顺序

3.2 getConstructors()

此方法只能得到public的构造方法，得到的只能是getDeclaredConstructors()结果的子集
代码：

public class Person {
    String name;
 
    public Person() {
    }
 
    private Person(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
 
        Constructor<?>[] constructors = Person.class.getDeclaredConstructors();
        Constructor<?>[] constructors1 = Person.class.getConstructors();
        System.out.println(constructors.length);
        System.out.println(constructors[0]);
        System.out.println(constructors[1]);
        System.out.println(constructors1.length);
        System.out.println(constructors1[0]);
 
    }
}

执行结果：

2
public Person()
private Person(java.lang.String)
1
public Person()

4. Clone

若想使用此方法，则必须实现Cloneable接口并重写其中的clone方法，clone()方法是浅拷贝，不会调用构造方法，只会将被拷贝的类中的属性的地址引用到新的类中

public class People implements Cloneable {
 
    public People() {
        System.out.println("我被调用了");
    }
 
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
 
    public static void main(String[] args) throws CloneNotSupportedException {
 
        People people = new People();
        People clone = (People) people.clone();
        System.out.println(people.equals(clone));
 
    }
}

执行结果：

我被调用了
false

值得注意的是：
java.lang.Cloneable 是一个标示性接口,不包含任何方法。
clone ()方法在 Object 类中定义的一个Native方法:

protected native Object clone() throws CloneNotSupportedException;

5. 反序列化

每当我们序列化和反序列化一个对象的时候，JVM就会为我们创建一个单独的对象。在反序列化中，JVM不适用任何构造函数来创建对象。要反序列化对象，我们需要在类中实现Serializable接口。

代码：

package com.junjie.test3;

import java.io.Serializable;
import java.util.Objects;
 
public class Employee implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    private String name;
 
    public Employee() {
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Employee employee = (Employee) obj;
        return Objects.equals(name, employee.name);
    }
 
    @Override
    public String toString() {
        return String.format("Employee{name='%s'}", name);
    }
}

package com.junjie.test3;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ObjectCreation {
 
    public static void main(String[] args) throws Exception {
        Employee employee = new Employee();

        //5、Serializable(序列化)
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.obj"))) {
            out.writeObject(employee);
        }
 
        //6、Using Deserailizable(反序列化)
        Employee employee5;
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"))) {
            employee5 = (Employee) in.readObject();
            employee5.setName("employee5");
        }
        System.out.println(employee5.getName());
    }
 
}

深拷贝和浅拷贝

上述我们看到的clone方法实现的是浅拷贝，如果想要实现深拷贝，那就需要重写clone方法，在其中实现对引用类型变量实现拷贝，但是太过于繁琐。
而反序列化则可以简洁的实现深拷贝，因为反序列化出来的对象都是全新的。
具体可以参考下边的一篇博文：
https://blog.csdn.net/weixin_41979002/article/details/119798197