Enumeration:

• Enumeration interface implemented in java 1.2 version.So Enumeration is legacy interface.
• Enumeration uses elements() method.
• Enumeration can traverse in forward direction only.
• Enumeration having methods like hasMoreElement(),nextElement().

Program:

Output:

Iterator:

ListIterator:

Inheritance:

• The concept of getting properties of one class object to another class object is known as inheritance.
• Here properties means variable and methods.

Types of Inheritance:

•  We have two classes B and c which are inheriting A class properties.
• Here Class D inheriting B class and C class So properties present in those classes will be available in java.
• But both classes are in same level with same priority.
• If we want to use show() method that leads to ambiguity
• This is called diamond problem.
• Because of multiple inheritance there is chance of the root object getting created more than once.
• Always the root object i.e object of object class hast to be created only once.
• Because of above mentioned reasons multiple inheritance would not be supported by java.
• Thus in java a class can not extend more than one class simultaneously. At most a class can extend only one class.

So these are the reasons that java does not supports multiple inheritance.Even though having this much reasons some people say and we also gets some doubts when we are using interfaces. lets me clear this one also. our immediate question should be.

Is Java supports multiple inheritance using interfaces?

• Before that we need to know about interfaces.
• Interfaces having fully abstract functionality.
• Means methods in interfaces by default public abstract methods so we need to implement these methods in classes which are extending this interface.

   

• Here it seems we are achieving multiple inheritance by using interfaces. but we are not.
• Syntactically it seems to multiple inheritance but the actual implementation of multiple inheritance is not there. how can i say that? let me clear

Difference between interfaces and inheritance: in multiple inheritance

• Inheritance means getting the properties from one class object to another class object.
• Means if any class extending another class then the super class methods can be used in sub classes happily.
• But in interfaces the methods in interfaces are fully abstract so we need to provide functionality in our extended class and use it .seems both are opposite right? yes.
• That is the reason we can say interfaces are only supports syntactical multiple inheritance which is not implementation of multiple inheritance.

So finally java supports only syntax of multiple inheritance does not supports implementation of multiple inheritance.
Inheritance is like debit and interface is like credit but interface has its own importance in other concepts like server side programming

What is the major change in JAVA 8 regarding interfaces:

•  Yes from java 8 we can add static methods and defaults methods in interfaces by this we can achieve multiple inheritance.
•  Java 8 interface static and default methods

1.Defining object of a class as local to a method or local variable:

2.Defining object of a class as an instance variable of another class:

3.Defining object of a class as the parameter of the method.

 

 4.Defining  object of a class as the return data type of the method.

5.Defining object of a class as the static variable or class variable of another class

This scenario used in System.out.println();

    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