How to Create Object In Java With Explanation & Program?

In this article, we will discuss various ways to create an Object in Java i.e.;

Various ways to create Object in Java

Primarily, there are only 4 ways to create an object in Java, are;

• Using new operator or keyword
• Using the clone method of the Object class
• Using Object De-serialization
• Using Reflection API

But using reflection way, we can derive multiple ways to create objects in Java

Interface vs Abstract Class In Java

Let us move forward and discuss all possible ways to create an object in Java

Way 1: Using the new operator or keyword

This is a very common way to create or instantiate new objects, as shown in the below demo example

package in.bench.resources.various.ways.to.create.objects;
public class UsingNewOperatorOrKeyword 
{
    public static void main(String[] args) 
   {
        // Way 1: using new operator or keyword
        UsingNewOperatorOrKeyword object1 = new UsingNewOperatorOrKeyword();
    }
}

clone() method of an Object class, creates another copy of the same Object with all its details

Method signature :

protected native Object clone() throws CloneNotSupportedException;

Check Also: Positive & Negative Testing

package in.bench.resources.various.ways.to.create.objects;
public class UsingCloneMethodOfObjectClass implements Cloneable 
{
       public static void main(String[] args)
   {
        // normal way of creating / instantiating new object
        UsingCloneMethodOfObjectClass ucmooc = new UsingCloneMethodOfObjectClass();
      try 
      {
         // Way 2: using clone() method of Object class
         UsingCloneMethodOfObjectClass object2 = (UsingCloneMethodOfObjectClass) ucmooc.clone();

         // invoking display() method
         object2.display();
      }
      catch (CloneNotSupportedException cnsex) 
      {
         cnsex.printStackTrace();
      }
   }
       
   // display() method to test
       public void display() 
   {
              System.out.println("display() method is invoked");
          }
}

Output:

display() method

1. The class for which cloning is performed must implement ”java.lang.Cloneable” interface, otherwise “java.lang.CloneNotSupportedException” will be thrown
2. Explicit type-cast is required, as shown in the below figure point-1.
3. It is necessary to handle compile-time exceptions either by throws clause or surrounding with a try-catch block, as shown in the below figure point-2.

Way 3: Using Object de-serialization process

This case assumes that the already object is serialized using the serialization process. Now, when the reverse process happens i.e.; de-serializing binary file format from file storage into Java’s heap memory, then a new object is created

package com.hcl.tmobile.submitservicechange;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class UsingDeSerialization 
{
   public static void main(String[] args) 
   {
      // TODO Auto-generated method stub
      // creating input stream variables
      FileInputStream fis = null;
      ObjectInputStream ois = null;

      // to hold customer values after de-serialization
      Customer customer = null;

      try 
      {
         // reading binary data
         fis = new FileInputStream("Customer.ser");

         // converting binary-data to java-object
         ois = new ObjectInputStream(fis);

         // Way 3: creating Object after de-serialization
         customer = (Customer) ois.readObject();
        }
           
      catch (FileNotFoundException fnfex) 
      {
         fnfex.printStackTrace();
        }
      catch (IOException ioex) 
      {
            ioex.printStackTrace();
        }
      catch (ClassNotFoundException ccex) 
      {
          ccex.printStackTrace();
      }

      System.out.println("Customer values : " + customer);
   }
}

Explanation:

• Assume that, already Customer object is serialized in the file named “Customer.ser”
• The above program depicts the steps to de-serialize an Object (i.e.; de-serializing from file storage in binary format into Java’s heap memory)
• Notice line no. 28, which read the object’s state and re-creates a new object
• In this way, a new Object can be created in Java using the Object de-serialization process

Way 4: Using Reflection & newInstance() method of Class & Constructor

There are different variants while dealing with reflection way of creating objects i.e.;

Using Classes & Constructors:

Using Class.forName(“fully.qualified.name.of.class”).newInstance();
Using <ClassName>.class.newInstance();
Using <ClassName>.class.getClassLoader().loadClass(“fully.qualified.name.of.class”).newInstance();
Using Constructor i.e.;
Constructor<<className>> constructor = <ClassName>.class.getConstructor();
<ClassName> object44 = constructor.newInstance();

Pre-requisite:

To create an Object using reflection & newInstance() method way, we require below 2 things in advance

• Fully qualified class name
• default public constructor, because newInstance() method invokes default no-arg constructor while creating Object

Way 4.1: Reflection – Class.forName(“className”).newInstance();

This type of Object creation is commonly encountered while connecting database at a lower level i.e.; for loading & creating Object of that particular driver type

Loading –> Class.forName(“fully.qualified.class.name”)
Creating –> invoking newInstance() method on that particular loaded class

For example,

• Oracle –> oracle.jdbc.driver.OracleDriver
• MySQL –> com.mysql.jdbc.Driver
• SQL Server –> com.microsoft.sqlserver.jdbc.SQLServerDriver
• MS Access –> sun.jdbc.odbc.JdbcOdbcDriver

UsingClassForNameOfReflection.java

package in.bench.resources.reflection;
public class UsingClassForNameOfReflection 
{
   // public no-arg constructor
   public UsingClassForNameOfReflection()
   {
      System.out.println("newInstance() method invokes: default no-arg constructor");
   }
   public static void main(String[] args) 
   {
      try 
      {
         // Way 4.1: using Class.forName("className").newInstance()
         UsingClassForNameOfReflection object41 =
               (UsingClassForNameOfReflection) Class
               .forName("in.bench.resources.reflection.UsingClassForNameOfReflection")
               .newInstance();
         // invoking display() method
         object41.display();
      }
      catch (InstantiationException iex) 
      {
         iex.printStackTrace();
      }
      catch (IllegalAccessException iaex) 
      {
         iaex.printStackTrace();
      }
      catch (ClassNotFoundException cnfex) 
      {
         cnfex.printStackTrace();
      }
   }
   // display() method to test
   public void display(){
      System.out.println("Way 4.1: using Class.forName(className).newInstance()");
   }
}

newInstance() method invokes: default no-arg constructor

Way 4.1: using Class.forName(className).newInstance()

• We have explicitly provided a default no-arg constructor at line no. 6
• But if we haven’t coded any explicit constructor in the class, the compiler (or JVM) inserts a default no-arg constructor (provided there is no parameterized constructor)
• Line no. 14 creates an Object using newInstance() method after loading respective class using Class.forName(“fully.qualified.name.of.class”)
• When the newInstance() method is executed then it invokes public default no-arg constructor
• After the object creation step, using object reference we are invoking the display() method to print a simple message in the console

Way 4.2: Reflection – <ClassName>.class.newInstance();

This is very similar to the earlier approach with the only difference is that instead of loading class here it expects to know the fully qualified class name

Loading –> <ClassName>.class
Creating –> invoking newInstance() method for that particular class

package in.bench.resources.reflection;
public class UsingClassNameOfReflection {
   // public no-arg constructor
   public UsingClassNameOfReflection() {
      System.out.println("newInstance() method invokes: default no-arg constructor");
   }
   public static void main(String[] args) {
      try {
         // Way 4.2: using <ClassName>.class.newInstance();
         UsingClassNameOfReflection object42 = UsingClassNameOfReflection.class.newInstance();
         // invoking display() method
         object42.display();
      }
      catch (InstantiationException iex) {
         iex.printStackTrace();
      }
      catch (IllegalAccessException iaex) {
         iaex.printStackTrace();
      }
   }
   // display() method to test
   public void display(){
      System.out.println("Way 4.2: using <ClassName>.class.newInstance();");
   }
}

Output:

newInstance() method invokes: default no-arg constructor
Way 4.2: using <ClassName>.class.newInstance();

Explanation:

• We have explicitly provided a default no-arg constructor at line no. 6
• But if we haven’t coded any explicit constructor in the class, the compiler (or JVM) inserts a default no-arg constructor (provided there is no parameterized constructor)
• Line no. 14 creates an Object using the newInstance() method after getting a fully qualified class name
• When the newInstance() method is executed then it invokes public default no-arg constructor
• After the object creation step, using object reference we are invoking the display() method to print a simple message in the console

Way 4.3: Reflection – using a class loader

This is again very similar to earlier approaches (4.1 & 4.2), but here it uses the class loader to load class

Loading –> <ClassName>.class.getClassLoader().loadClass(“qualified.class.name”)
Creating –> invoking newInstance() method on that particular loaded class

package in.bench.resources.reflection;
public class UsingClassLoaderOfReflection {
   // public no-arg constructor
   public UsingClassLoaderOfReflection() {
      System.out.println("newInstance() method invokes: default no-arg constructor");
   }
   public static void main(String[] args) {
      // local variable
      Object object = null;
      try {
         // Way 4.3: using class loader
         object = UsingClassLoaderOfReflection.class.getClassLoader()
               .loadClass("in.bench.resources.reflection.UsingClassLoaderOfReflection")
               .newInstance();
         // type-cast to required type from Object
         // invoking display() method
         object43.display();
      }
      catch (InstantiationException iex) {
         iex.printStackTrace();
      }
      catch (IllegalAccessException iaex) {
         iaex.printStackTrace();
      }
      catch (ClassNotFoundException cnfex) {
         cnfex.printStackTrace();
      }
   }
   // display() method to test
   public void display(){
      System.out.println("Way 4.3: using class loader;");
   }
}

Output:

newInstance() method invokes: default no-arg constructor
Way 4.3: using class loader;

Explanation:

• We have explicitly provided a default no-arg constructor at line no. 6
• But if we haven’t coded any explicit constructor in the class, the compiler (or JVM) inserts a default no-arg constructor (provided there is no parameterized constructor)
• Line no. 17 creates an Object using the newInstance() method, after loading a respective class using the class loader
• When the newInstance() method is executed then it invokes public default no-arg constructor
• After the object creation step, using object reference we are invoking the display() method to print a simple message in the console

 Way 4.4: Reflection – using constructor with generics

In all earlier reflection approaches, we have used the only class name to load a class and later creating/instantiating Object using the newInstance() method. But here, we are going to use Constructor to load class in a reflective way

Loading –> <ClassName>.class.getConstructor()
Creating –> invoking newInstance() method on that particular loaded class (via Constructor)

package in.bench.resources.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class UsingConstructorOfReflection {
   // public no-arg constructor
   public UsingConstructorOfReflection() {
      System.out.println("newInstance() method invokes: default no-arg constructor");
   }
   public static void main(String[] args) {
      try {
         // Way 4.4: using newInstance() method of Constructor
         Constructor<UsingConstructorOfReflection> constructor =
               UsingConstructorOfReflection.class.getConstructor();
         // invoking newInstance() method to create Object using Reflection
         UsingConstructorOfReflection object44 = constructor.newInstance();
         // invoking display() method
         object44.display();
      }
      catch (InstantiationException iex) {
         iex.printStackTrace();
      }
      catch (IllegalAccessException iaex) {
         iaex.printStackTrace();
      }
      catch (IllegalArgumentException iargex) {
         iargex.printStackTrace();
      }
      catch (InvocationTargetException itex) {
         itex.printStackTrace();
      }
      catch (NoSuchMethodException nsmex) {
         nsmex.printStackTrace();
      }
      catch (SecurityException sex) {
         sex.printStackTrace();
      }
   }
   // display() method to test
   public void display(){
      System.out.println("Way 4.4: using newInstance() method of Constructor");
   }
}

newInstance() method invokes: default no-arg constructor
Way 4.4: using newInstance() method of Constructor

Explanation:

• We have explicitly provided a default no-arg constructor at line no. 9
• But if we haven’t coded any explicit constructor in the class, the compiler (or JVM) inserts a default no-arg constructor (provided there is no parameterized constructor)
• Line no. 17 & 21 creates an Object using newInstance() method, after loading respective class via Constructor-way
• When the newInstance() method is executed then it invokes public default no-arg constructor
• After the object creation step, using object reference we are invoking the display() method to print a simple message in the console

Exception for reflection API and newInstance() method

• While creating Object using reflection API & newInstance() method, definitely a default no-arg constructor is required
• It can be explicit default constructor coded in the class by programmer or else JVM provided default no-arg constructor at compile-time
• In any case, if the corresponding class doesn’t contain default no-arg constructor then at run-time, an exception is thrown stating reason “java.lang.NoSuchMethodException” as shown in the below figure

Create Object Java Program: Different Ways to Create Object In Java With Example Program

Check Also: Decimal to Binary Conversion In Java

package com.softwaretestingo.java.basics;
class aabc
{
   int a,b;
   void m1()
   {
      System.out.println("Value Of a -- " +a);
      System.out.println("Value Of b -- " +b);
   }
}
public class ObjectCreation {
   public static void main(String[] args) {
      // TODO Auto-generated method stub
      System.out.println("======Main Starts Here=====");
      aabc obj=new aabc();
      obj.a=20;
      obj.b=40;
      obj.m1();
      System.out.println("=========================");
      aabc obj1=new aabc();
      obj1.a=30;
      //obj1.b=50;
      obj1.m1();
      System.out.println("====== Main Ends Here ========");
   }
}

Check Also: Compare two String matches() In Java