众所周知，在Java中，类提供对象的蓝图，您可以从类创建对象。在Java中有许多不同的方法来创建对象。
以下是一些在Java中创建对象的方法：
1、 使用new关键字
使用new关键字是创建对象的最基本方法。这是在java中创建对象的最常见方法。几乎99%的对象都是这样创建的。通过使用这个方法，我们可以调用我们想要调用的任何构造函数（无参数或参数化构造函数）。
// Java program to illustrate creation of Object
// using new keyword
public class NewKeywordExample
{
String name = "GeeksForGeeks";
public static void main(String[] args)
{
// Here we are creating Object of
// NewKeywordExample using new keyword
NewKeywordExample obj = new NewKeywordExample();
System.out.println(obj.name);
}
}
输出：
GeeksForGeeks
2、使用New Instance
如果我们知道类的名称并且如果它有一个公共的默认构造函数，我们就可以通过Class.forName来创建类的对象。forName实际上在Java中加载类，但不创建任何对象。要创建类的对象，必须使用类的newInstance()方法。
// Java program to illustrate creation of Object
// using new Instance
public class NewInstanceExample
{
String name = "GeeksForGeeks";
public static void main(String[] args)
{
try
{
Class cls = Class.forName("NewInstanceExample");
NewInstanceExample obj =
(NewInstanceExample) cls.newInstance();
System.out.println(obj.name);
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
catch (InstantiationException e)
{
e.printStackTrace();
}
catch (IllegalAccessException e)
{
e.printStackTrace();
}
}
}
输出：
GeeksForGeeks
3、使用clone()方法
每当对任何对象调用clone()方法时，JVM实际上会创建一个新对象，并将前一个对象的所有内容复制到该对象中。使用clone方法创建对象不会调用任何构造函数。
要使用clone()方法，类要实现Cloneable接口并且实现clone()方法。
// Java program to illustrate creation of Object
// using clone() method
public class CloneExample implements Cloneable
{
@Override
protected Object clone() throws CloneNotSupportedException
{
return super.clone();
}
String name = "GeeksForGeeks";
public static void main(String[] args)
{
CloneExample obj1 = new CloneExample();
try
{
CloneExample obj2 = (CloneExample) obj1.clone();
System.out.println(obj2.name);
}
catch (CloneNotSupportedException e)
{
e.printStackTrace();
}
}
}
输出：
GeeksForGeeks
注：
- 这里我们创建的是现有对象的克隆，而不是任何新对象。
- 类需要实现可克隆接口，否则将抛出CloneNotSupportedException.
4、使用反序列化
每当我们序列化并反序列化一个对象时，JVM会创建一个单独的对象。在反序列化，JVM不使用任何构造函数来创建对象。
要反序列化对象，我们需要在类中实现可序列化接口。
序列化对象：
import java.io.Serializable;
import java.time.LocalDate;
/**
* @author:crelle
* @className:Person
* @version:1.0.0
* @date:2020/8/15
* @description:XX
**/
public class Person implements Serializable {
private static final Long serialVersionUID = 237898764368L;
public enum Sex {
MALE, FEMALE
}
private String name;
private LocalDate birthday;
private Sex gender;
private String emailAddress;
private int age;
public Person() {}
public Person(String name) {
this.name = name;
}
public void printPerson() {
System.out.println(toString());
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public LocalDate getBirthday() {
return birthday;
}
public void setBirthday(LocalDate birthday) {
this.birthday = birthday;
}
public Sex getGender() {
return gender;
}
public void setGender(Sex gender) {
this.gender = gender;
}
public String getEmailAddress() {
return emailAddress;
}
public void setEmailAddress(String emailAddress) {
this.emailAddress = emailAddress;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", birthday=" + birthday +
", gender=" + gender +
", emailAddress='" + emailAddress + '\'' +
", age=" + age +
'}';
}
}
/**
* @author:crelle
* @className:DeserializationExample
* @version:1.0.0
* @date:2020/9/18
* @description:XX
**/
// Java program to illustrate Serializing
// an Object.
import crelle.test.java.auxiliary.beans.Person;
import java.io.*;
class SerializationExample
{
public static void main(String[] args)
{
try
{
Person d = new Person("crelle");
FileOutputStream f = new FileOutputStream("person.txt");
ObjectOutputStream oos = new ObjectOutputStream(f);
oos.writeObject(d);
oos.close();
f.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
反序列化对象：
/**
* @author:crelle
* @className:DeserializationExample
* @version:1.0.0
* @date:2020/9/18
* @description:XX
**/
// Java program to illustrate creation of Object
// using Deserialization.
import crelle.test.java.auxiliary.beans.Person;
import java.io.*;
public class DeserializationExample
{
public static void main(String[] args)
{
try
{
Person person;
FileInputStream f = new FileInputStream("person.txt");
ObjectInputStream oos = new ObjectInputStream(f);
person = (Person) oos.readObject();
System.out.println(person.getName());
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
输出：
crelle
5、 使用Constructor类的newInstance()方法：
这类似于类的newInstance()方法。java.lang.reflect.Constructor类中有一个newInstance()方法，可用于创建对象。通过使用此newInstance()方法，它也可以调用参数化构造函数和私有构造函数。
// Java program to illustrate creation of Object
// using newInstance() method of Constructor class
import java.lang.reflect.*;
public class ReflectionExample
{
private String name;
ReflectionExample()
{
}
public void setName(String name)
{
this.name = name;
}
public static void main(String[] args)
{
try
{
Constructor<ReflectionExample> constructor
= ReflectionExample.class.getDeclaredConstructor();
ReflectionExample r = constructor.newInstance();
r.setName("GeeksForGeeks");
System.out.println(r.name);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
输出：
GeeksForGeeks