There are four different ways to create objects in java:

1.     Using new keyword
2.     Using Class.forName():
3.     Using clone():
4.     Using Object Deserialization:  
5.     Using newIntance() method

Using new keyword:

    This is the most common way to create an object in java. Almost 99% of objects are created in this way.

MyObject object=new Object();

Using Class.forName():

• If we know the name of the class & if it has a public default constructor we can create an object in this way.
• Syntax:
• Myobject obj=(MyObject) class.forName("object").newInstance();

Using clone():

• The clone() can be used to create a copy of an existing object.
• Syntax:
• MyObject obj=new MyObject();
• MyObject object=(MyObject )obj.clone();

Using Object Deserialization:

• Object deserialization is nothing but creating an object from its serialized form.
• Syntax:
• objectInputStream istream=new objectInputStream(some data);
• MyObject object=(MyObject) instream.readObject();

Using newInstance() method

Object obj = DemoClass.class.getClassLoader().loadClass("DemoClass").newInstance();

Java Program on creating object using new keyword:

    package com.instanceofjava;
    
    public class Employee
    {
    
    private int id;
    private String name;
    
    Employee(int id,String name){
    this.id=id;
    this.name=name;
    }
    
    public void display(){
    
    System.out.println(id+" "+name);
    
    }
    
    public static void  main (String args[]){

    Emploee e=new Employee(1,"Indhu");
    Employee e1=new Employee(2,"Sindhu");
    
    e.display();
    e1.display();
    
    }
    }

 Output:

    Indhu
    Sindhu

Java Program on creating object using clone() method:

    package com.instanceofjava;
    
    public class Empcloneable implements Cloneable {
    
      int a;
      String name;
    
    Empcloneable(int a,String name){
    
     this.a=a;
     this.name=name;
    
    }
    
     public Empcloneable clone() throws CloneNotSupportedException{
    
      return (Empcloneable) super.clone();
    
     }
    
    public static void main(String[] args) {

    Empcloneable e=new Empcloneable(2,"Indhu");
    System.out.println(e.name);
    
    try {

    Empcloneable b=e.clone();
    System.out.println(b.name);
    
    } catch (CloneNotSupportedException e1) {
    
     e1.printStackTrace();
    }
    
    }
    }


 Output:

    Indhu
    Indhu

Java Program on creating object using Deserialization

    package com.instanceofjava;
    import java.io.*;
    public class Files
    {
    
    public static void main(String [] args)
    {
    
     Employee e = null;
    
    try
    {
    
    FileInputStream fileIn = new FileInputStream("/E/employee.txt");
    ObjectInputStream in = new ObjectInputStream(fileIn);
    
    e = (Employee) in.readObject();
    in.close();
    fileIn.close();
    
    }catch(IOException i)
    {
    i.printStackTrace();
    return;
    
    }catch(ClassNotFoundException c)
    {
    System.out.println("Employee class not found");
    c.printStackTrace();
    return;
    }
    
    System.out.println("Deserialized Employee...");
    System.out.println("Name: " + e.name);
    
    }
    
    }


 Output:

    Name:Indhu

Java Program on creating object using class.forName();

    package com.instanceofjava;
    public class Sample{
    
    public static void main(String args[]){
    
    try {
    
     Class s= Class.forName("com.instanceofjava.Sample");
     Sample obj=(Sample) s.newInstance(); 
     System.out.println(obj.hashcode());
    
     } catch (Exception e) {
    
      e.printStackTrace();
    
    }
    
    }
    
    }

 Output:

    2007759836

You Might Like:

1.What are all the Five different places to create object in java

2.Java Example program to restrict a class from creating not more than three objects 

3.Six different ways to iterate list in java

Map:

• Map is key-value pair.
• Map Interface represents a mapping between key and value.
• Map having:

Common   class
package com.instanceofjavaforus;

public class Common {

    int x;
   
    boolean flag=true;
    //if flag is true producer thread has to produce
    // if flag is false consumer thread has to produce

    synchronized public void produce(int i){
       
        if(flag){
           
            x=i;
            System.out.println("producer thread has produced "+i);
            flag=false;
            notify();
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }      
        }
     }
   

    synchronized public int consume(){
        if(flag){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
           
        }
        flag=true;
        notify();
        return x;
    }
   
}

package com.instanceofjavaforus;

public class ProducerThread extends Thread {
    Common c;
   
    ProducerThread(Common c){
        this.c=c;
    }
   
    public void run(){
        int i=0;
        while(true){
           
            i++;
            c.produce(i);
           
           
            try {
                Thread.sleep(600);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } 
        } 
    } 
}

ConsumerThread:

package com.instanceofjavaforus;

public class ConsumerThread extends Thread {
   
    Common c;
   
    ConsumerThread(Common c){
        this.c=c;
    }
   
    public void run(){
       
        while(true){
           
            int x=c.consume();
            System.out.println("Consumer consumes"+x);
            try {
                Thread.sleep(600);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } 
        } 
    }
}

ProducerConsumerTest:

package com.instanceofjavaforus;

public class ProducerConsumerTest {
   
    public static void main(String args[]){
        Common c= new Common();
        ProducerThread pt=new ProducerThread(c);
        ConsumerThread ct= new ConsumerThread(c);
        pt.start();
        ct.start();
    }
}

Output:

producer thread has produced 1
Consumer consumed 1
producer thread has produced 2
Consumer consumed 2
producer thread has produced 3
Consumer consumed 3
producer thread has produced 4
Consumer consumed 4
producer thread has produced 5
Consumer consumed 5
producer thread has produced 6
Consumer consumed 6

               Syntax: A obj= new A();

Example program:

      public class A {
         int a;
     public  void Print(){
        System.out.println("value of a="+a);
    }
    public static void main(String[] args) {
   A obj=new A();
  obj.print();
    }
}

Output:

• Concept of defining multiple constructors within the same class by changing the data types of the parameters is known as constructor overloading.

package com.instanceofjavaforus;

public class ConstructorOverloading {

int a,b,c;

ConstructorOverloading(){
    this(1);
}

ConstructorOverloading(int a){
    this(a,2);
}

ConstructorOverloading(int a, int b){
    this(a,b,3);
}

ConstructorOverloading(int a, int b,int c){
this.a=1;
this.b=2;
this.c=3;
System.out.println(a+""+b+""+c);
}
   
public static void main(String args[]){
   
    ConstructorOverloading obj=new ConstructorOverloading();
   
   }
   
}


OutPut:
1 2 3