用Java创建对象的不同方法有哪些？

众所周知, 在Java中, 类为对象提供了设计图, 你可以从类中创建对象。用Java创建对象的方法有很多。

以下是在Java中创建对象的一些方法：

1)使用新的关键字：使用new关键字是创建对象的最基本方法。这是在Java中创建对象的最常见方法。几乎99％的对象都是通过这种方式创建的。通过使用此方法, 我们可以调用要调用的任何构造函数(无参数或参数化的构造函数)。

//Java program to illustrate creation of Object
//using new keyword
public class NewKeywordExample 
{
     String name = "srcmini" ;
     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);
     }
}

输出如下：

srcmini

2)使用新实例:如果我们知道该类的名称, 并且它具有公共默认构造函数, 则可以创建一个对象–类名。我们可以使用它来创建类的对象。实际上, Class.forName使用Java加载了Class, 但没有创建任何Object。要创建该类的对象, 你必须使用该类的新实例方法。

//Java program to illustrate creation of Object
//using new Instance
public class NewInstanceExample
{
     String name = "srcmini" ;
     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();
         }
     }
}

输出如下：

srcmini

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 = "srcmini" ;
  
     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();
         }
     }
}

输出如下：

srcmini

注意 ：

• 在这里, 我们正在创建现有对象而不是任何新对象的克隆。
• 类需要实现Cloneable接口, 否则它将抛出CloneNotSupportedException.

4)使用反序列化:每当我们序列化然后反序列化一个对象时, JVM都会创建一个单独的对象。在反序列化中, JVM不使用任何构造函数来创建对象。

要反序列化对象, 我们需要在类中实现Serializable接口。

序列化对象：

//Java program to illustrate Serializing
//an Object.
import java.io.*;
  
class DeserializationExample implements Serializable
{
     private String name;
     DeserializationExample(String name)
     {
         this .name = name;
     }
  
     public static void main(String[] args)
     {
         try
         {
             DeserializationExample d =
                     new DeserializationExample( "srcmini" );
             FileOutputStream f = new FileOutputStream( "file.txt" );
             ObjectOutputStream oos = new ObjectOutputStream(f);
             oos.writeObject(d);
             oos.close();
             f.close();
         }
         catch (Exception e)
         {
             e.printStackTrace();
         }
     }
}

DeserializationExample类的对象使用writeObject()方法进行序列化, 然后写入file.txt文件。

对象的反序列化：

//Java program to illustrate creation of Object
//using Deserialization.
import java.io.*;
  
public class DeserializationExample
{
     public static void main(String[] args)
     {
         try
         {
             DeserializationExample d;
             FileInputStream f = new FileInputStream( "file.txt" );
             ObjectInputStream oos = new ObjectInputStream(f);
             d = (DeserializationExample)oos.readObject();
         }
         catch (Exception e)
         {
             e.printStackTrace();
         }
         System.out.println(d.name);
     }
}

输出如下：

srcmini

5)使用构造器类的newInstance()方法：这类似于类的newInstance()方法。在其中有一个newInstance()方法java.lang.reflect.Constructor我们可以用来创建对象的类。通过使用此newInstance()方法, 它也可以调用参数化构造函数和私有构造函数。

这两种newInstance()方法都被称为创建对象的反射方式。实际上, Class的newInstance()方法在内部使用了Constructor类的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( "srcmini" );
             System.out.println(r.name);
         }
         catch (Exception e)
         {
             e.printStackTrace();
         }
     }
}

输出如下：

srcmini

如果发现任何不正确的地方, 或者想分享有关上述主题的更多信息, 请写评论。