Advanced Java Programming - Unit Wise Questions

Multithreading is a process of executing two or more threads simultaneously to maximum utilization of CPU.  A thread is a lightweight sub-process, the smallest unit of processing.

Multithreaded program can be created by using two mechanisms:

1. By extending Thread class

Thread class provide constructors and methods to create and perform operations on a thread. This class overrides the run() method available in the Thread class. A thread begins its life inside run() method. We create an object of our new class and call start() method to start the execution of a thread. Start() invokes the run() method on the Thread object.

Example:

class First extends Thread

{

    @Override

    public void run()

    {

        for (int i=1; i<=10; i++)

        {

            System.out.println(i);

            try

            {

                Thread.sleep(500);

            }

            catch (InterruptedException e)

            {

                System.out.println(e.getMessage());

            }

        }

    }

}

class Second extends Thread

{

    @Override

    public void run()

    {

        for (int i=11; i<=20; i++)

        {

            System.out.println(i);

            try{

                Thread.sleep(1000);

            }

            catch (InterruptedException e)

            {

                System.out.println(e.getMessage());

            }

        }

    }

}

public class ThreadInterval

{

    public static void main(String[] args)

    {

        Thread first = new First();

        Thread second= new Second();

        first.start();

        second.start();

    }

}

2. By implementing Runnable interface

The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread. Runnable interface have only one method named run() which  is used to perform action for a thread. The start() method of Thread class is used to start a newly created thread.

Example:

public class ExampleClass implements Runnable {  

    @Override  

    public void run() {  

        System.out.println("Thread has ended");  

    }  

    public static void main(String[] args) {  

        ExampleClass ex = new ExampleClass();  

        Thread t1= new Thread(ex);  

        t1.start();  

        System.out.println("Hi");  

    }  

}  

The process of executing multiple threads simultaneously is known as multithreading. The main purpose of multithreading is to provide simultaneous execution of two or more parts of a program to maximum utilize the CPU time. A multithreaded program contains two or more parts that can run concurrently. Each such part of a program called thread.

Multithreading is important due to following reasons:

• It doesn't block the user because threads are independent and we can perform multiple operations at the same time.
• We can perform many operations together, so it saves time.
• Threads are independent, so it doesn't affect other threads if an exception occurs in a single thread.

Example:

Program to create two threads. The first thread should print numbers from 1 to 10 at intervals of 0.5 second and the second thread should print numbers from 11 to 20 at the interval of 1 second.

class First extends Thread

{

    @Override

    public void run()

    {

        for (int i=1; i<=10; i++)

        {

            System.out.println(i);

            try

            {

                Thread.sleep(500);

            }

            catch (InterruptedException e)

            {

                System.out.println(e.getMessage());

            }

        }

    }

}

class Second extends Thread

{

    @Override

    public void run()

    {

        for (int i=11; i<=20; i++)

        {

            System.out.println(i);

            try{

                Thread.sleep(1000);

            }

            catch (InterruptedException e)

            {

                System.out.println(e.getMessage());

            }

        }

    }

}

public class ThreadInterval

{

    public static void main(String[] args)

    {

        Thread first = new First();

        Thread second= new Second();

        first.start();

        second.start();

    }

}

Life Cycle of Thread

A thread in Java at any point of time exists in any one of the following states.

• New:  A new thread begins its life cycle in the new state. It remains in this state until the program starts the thread. It is also referred to as a born thread. In simple words, a thread has been created, but it has not yet been started. A thread is started by calling its start() method.
• Runnable: The thread is in the runnable state after the invocation of start() method, but the thread scheduler has not selected it to be the running thread. A thread starts life in the Ready-to-run state by calling the start method and wait for its turn. The thread scheduler decides which thread runs and for how long.
• Running:  When the thread starts executing, then the state is changed to a “running” state. The scheduler selects one thread from the thread pool, and it starts executing in the application.
• Dead: This is the state when the thread is terminated. The thread is in running state and as soon as it completed processing it is in “dead state”. Once a thread is in this state, the thread cannot even run again.
• Blocked (Non-runnable state):This is the state when the thread is still alive but is currently not eligible to run. A thread that is blocked waiting for a monitor lock is in this state. A running thread can transit to one of the non-runnable states depending on the situation. A thread remains in a non-runnable state until a special transition occurs. A thread doesn’t go directly to the running state from a non-runnable state but transits first to the Ready-to-run state.

An interface in Java is a blueprint of a class. It has static constants and abstract methods. An interface is a mechanism to achieve abstraction. There can be only abstract methods in the Java interface, not method body. It is used to achieve abstraction and multiple inheritance in java.

In Multiple inheritances, one class can have more than one superclass and inherit features from all parent classes. Java does not support multiple inheritances with classes. In java, we can achieve multiple inheritances only through Interfaces. An interface is declared by using the interface keyword. It provides total abstraction; means all the methods in an interface are declared with the empty body, and all the fields are public, static and final by default. A class that implements an interface must implement all the methods declared in the interface.

Multiple inheritance can be achieved with interfaces, because the class can implement multiple interfaces. To implement multiple interfaces, separate them with a comma.

In the following example Class Animal is derived from interface AnimalEat and AnimalTravel.

interface AnimalEat {
   void eat();
}
interface AnimalTravel {
   void travel();
}
class Animal implements AnimalEat, AnimalTravel {
   public void eat() {
      System.out.println("Animal is eating");
   }
   public void travel() {
      System.out.println("Animal is travelling");
   }
}

An Exception is an unwanted event that interrupts the normal flow of the program. When an exception occurs program execution gets terminated. In such cases we get a system generated error message. 

Java exception handling is important because it helps maintain the normal, desired flow of the program even when unexpected events occur. If Java exceptions are not handled, programs may crash or requests may fail.  Suppose there are 10 statements in a program and an exception occurs at statement 5; the rest of the code will not be executed, i.e., statements 6 to 10 will not be executed. However, when we perform exception handling, the rest of the statements will be executed. That is why we use exception handling.

Java provides five keywords that are used to handle the exception. 

1. try:  The "try" keyword is used to specify a block where an exception can occur. It is always followed by a catch block, which handles the exception that occurs in the associated try block. A try block must be followed by catch blocks or finally block or both.

2. Catch: The "catch" block is used to handle the exception. This block must follow the try block and a single try block can have several catch blocks associated with it. When an exception occurs in a try block, the corresponding catch block that handles that particular exception executes. It can be followed by finally block later.

3. Finally: A finally block contains all the crucial statements that must be executed whether an exception occurs or not. The statements present in this block will always execute, regardless an exception occurs in the try block or not such as closing a connection, stream etc.

4. throw: The "throw" keyword is used to throw an exception.

5. throws: The "throws" keyword is used to declare exceptions. It specifies that there may occur an exception in the method. It doesn't throw an exception. It is always used with method signature.

Example:

class TestExceptions {
   static void myMethod(int testnum) throws Exception {
      System.out.println ("start - myMethod");
      if (testnum == 12) 
         throw new Exception();
      System.out.println("end - myMethod");
      return;	
   }
   public static void main(String  args[]) {
      int testnum = 12;
      try {
         System.out.println("try - first statement");
         myMethod(testnum);
         System.out.println("try - last statement");
      }
      catch ( Exception ex) {
         System.out.println("An Exception");
      }
      finally {
         System. out. println( "finally") ;
      }
      System.out.println("Out of try/catch/finally - statement");
   }
}

Output:

try - first statement
start - myMethod
An Exception
finally
Out of try/catch/finally - statement

Inheritance is a concept that acquires the properties from one class to other classes. A class can inherit attributes and methods from another class. The class that inherits the properties is known as the sub-class or the child class. The class from which the properties are inherited is known as the superclass or the parent class.

Benefits of Inheritance

• Inheritance helps in code reuse. The child class may use the code defined in the parent class without re-writing it.
• Inheritance can save time and effort as the main code need not be written again.
• Inheritance provides a clear model structure which is easy to understand.
• An inheritance leads to less development and maintenance costs.
• With inheritance, we will be able to override the methods of the base class so that the meaningful implementation of the base class method can be designed in the derived class. An inheritance leads to less development and maintenance costs.
• In inheritance base class can decide to keep some data private so that it cannot be altered by the derived class.

Multiple Inheritance

In Multiple inheritances, one class can have more than one superclass and inherit features from all parent classes. Java does not support multiple inheritances with classes. In java, we can achieve multiple inheritances only through Interfaces. In the following example Class Animal is derived from interface AnimalEat and AnimalTravel.

interface AnimalEat {
   void eat();
}
interface AnimalTravel {
   void travel();
}
class Animal implements AnimalEat, AnimalTravel {
   public void eat() {
      System.out.println("Animal is eating");
   }
   public void travel() {
      System.out.println("Animal is travelling");
   }
}

An Exception is an unwanted event that interrupts the normal flow of the program. When an exception occurs program execution gets terminated. In such cases we get a system generated error message. 

Exception handling is a powerful mechanism or technique that allows us to handle runtime errors in a program so that the normal flow of the program can be maintained. Java exception handling is important because it helps maintain the normal, desired flow of the program even when unexpected events occur. If Java exceptions are not handled, programs may crash or requests may fail.  Suppose there are 10 statements in a program and an exception occurs at statement 5; the rest of the code will not be executed, i.e., statements 6 to 10 will not be executed. However, when we perform exception handling, the rest of the statements will be executed. That is why we use exception handling

Java provides five keywords that are used to handle the exception. 

1. try:  The "try" keyword is used to specify a block where an exception can occur. It is always followed by a catch block, which handles the exception that occurs in the associated try block. A try block must be followed by catch blocks or finally block or both.

2. Catch: The "catch" block is used to handle the exception. This block must follow the try block and a single try block can have several catch blocks associated with it. When an exception occurs in a try block, the corresponding catch block that handles that particular exception executes. It can be followed by finally block later.

3. Finally: A finally block contains all the crucial statements that must be executed whether an exception occurs or not. The statements present in this block will always execute, regardless an exception occurs in the try block or not such as closing a connection, stream etc.

4. throw: The "throw" keyword is used to throw an exception.

5. throws: The "throws" keyword is used to declare exceptions. It specifies that there may occur an exception in the method. It doesn't throw an exception. It is always used with method signature.

Example:

class TestExceptions {
   static void myMethod(int testnum) throws Exception {
      System.out.println ("start - myMethod");
      if (testnum == 12) 
         throw new Exception();
      System.out.println("end - myMethod");
      return;	
   }
   public static void main(String  args[]) {
      int testnum = 12;
      try {
         System.out.println("try - first statement");
         myMethod(testnum);
         System.out.println("try - last statement");
      }
      catch ( Exception ex) {
         System.out.println("An Exception");
      }
      finally {
         System. out. println( "finally") ;
      }
      System.out.println("Out of try/catch/finally - statement");
   }
}

Output:

try - first statement
start - myMethod
An Exception
finally
Out of try/catch/finally - statement

An Exception is an unwanted event that interrupts the normal flow of the program. When an exception occurs program execution gets terminated. In such cases we get a system generated error message. 

Exception handling is a powerful mechanism or technique that allows us to handle runtime errors in a program so that the normal flow of the program can be maintained. Java exception handling is important because it helps maintain the normal, desired flow of the program even when unexpected events occur. If Java exceptions are not handled, programs may crash or requests may fail.  Suppose there are 10 statements in a program and an exception occurs at statement 5; the rest of the code will not be executed, i.e., statements 6 to 10 will not be executed. However, when we perform exception handling, the rest of the statements will be executed. That is why we use exception handling

Java provides five keywords that are used to handle the exception. 

1. try:  The "try" keyword is used to specify a block where an exception can occur. It is always followed by a catch block, which handles the exception that occurs in the associated try block. A try block must be followed by catch blocks or finally block or both.

2. Catch: The "catch" block is used to handle the exception. This block must follow the try block and a single try block can have several catch blocks associated with it. When an exception occurs in a try block, the corresponding catch block that handles that particular exception executes. It can be followed by finally block later.

3. Finally: A finally block contains all the crucial statements that must be executed whether an exception occurs or not. The statements present in this block will always execute, regardless an exception occurs in the try block or not such as closing a connection, stream etc.

4. throw: The "throw" keyword is used to throw an exception.

5. throws: The "throws" keyword is used to declare exceptions. It specifies that there may occur an exception in the method. It doesn't throw an exception. It is always used with method signature.

Example:

class TestExceptions {
   static void myMethod(int testnum) throws Exception {
      System.out.println ("start - myMethod");
      if (testnum == 12) 
         throw new Exception();
      System.out.println("end - myMethod");
      return;	
   }
   public static void main(String  args[]) {
      int testnum = 12;
      try {
         System.out.println("try - first statement");
         myMethod(testnum);
         System.out.println("try - last statement");
      }
      catch ( Exception ex) {
         System.out.println("An Exception");
      }
      finally {
         System. out. println( "finally") ;
      }
      System.out.println("Out of try/catch/finally - statement");
   }
}

Output:

try - first statement
start - myMethod
An Exception
finally
Out of try/catch/finally - statement

An exception is an event that occurs during the execution of a program and that disrupts the normal flow of instructions. Java exceptions are specialized events that indicate something bad has happened in the application, and the application either needs to recover or exit.

Exception handling is important because it helps maintain the normal, desired flow of the program even when unexpected events occur. If Java exceptions are not handled, programs may crash or requests may fail. Suppose there are 10 statements in a program and an exception occurs at statement 5; the rest of the code will not be executed, i.e., statements 6 to 10 will not be executed. However, when we perform exception handling, the rest of the statements will be executed. That is why we use exception handling

Error vs Exception

In Java, we can create our own exceptions that are derived classes of the Exception class. Creating our own Exception is known as custom exception or user-defined exception. Using the custom exception, we can have your own exception and message. Here, we have passed a string to the constructor of superclass i.e. Exception class that can be obtained using getMessage() method on the object we have created.

Example:

class CustomException extends Exception {
   String message;
   CustomException(String str) {
      message = str;
   }
   public String toString() {
      return ("Custom Exception Occurred : " + message);
   }
}
public class MainException {
   public static void main(String args[]) {
      try {
         throw new CustomException("This is a custom message");
      } catch(CustomException e) {
         System.out.println(e);
      }
   }
}

In Multiple inheritances, one class can have more than one superclass and inherit features from all parent classes. Java does not support multiple inheritances with classes. In java, we can achieve multiple inheritances only through Interfaces. An interface is declared by using the interface keyword. It provides total abstraction; means all the methods in an interface are declared with the empty body, and all the fields are public, static and final by default. A class that implements an interface must implement all the methods declared in the interface.

Multiple inheritance can be achieved with interfaces, because the class can implement multiple interfaces. To implement multiple interfaces, separate them with a comma.

In the following example Class Animal is derived from interface AnimalEat and AnimalTravel.

interface AnimalEat {
   void eat();
}
interface AnimalTravel {
   void travel();
}
class Animal implements AnimalEat, AnimalTravel {
   public void eat() {
      System.out.println("Animal is eating");
   }
   public void travel() {
      System.out.println("Animal is travelling");
   }
}

In Multiple inheritances, one class can have more than one superclass and inherit features from all parent classes. Java does not support multiple inheritances with classes. In java, we can achieve multiple inheritances only through Interfaces. An interface is declared by using the interface keyword. It provides total abstraction; means all the methods in an interface are declared with the empty body, and all the fields are public, static and final by default. A class that implements an interface must implement all the methods declared in the interface.

Multiple inheritance can be achieved with interfaces, because the class can implement multiple interfaces. To implement multiple interfaces, separate them with a comma.

In the following example Class Animal is derived from interface AnimalEat and AnimalTravel.

interface AnimalEat {
   void eat();
}
interface AnimalTravel {
   void travel();
}
class Animal implements AnimalEat, AnimalTravel {
   public void eat() {
      System.out.println("Animal is eating");
   }
   public void travel() {
      System.out.println("Animal is travelling");
   }
}

Let us suppose we have a file named “test.txt” in D-drive. Now we first read from this file character-by-character and later we write the contents of this file to another file say “testwrite.txt” in E-drive. For these tasks, we use the character stream classes namely FileReader and FileWriter. The code is given below:

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class FileReadWrite {

  public static void main(String []args) {

  try

  {

    FileReader fr = new FileReader("D:\\\\test.txt");

    FileWriter fw = new FileWriter("E:\\\\testwrite.txt");

    int c;

    while((c=fr.read())!=-1) {

      fw.write(c);

      System.out.print((char)c);

    }

    fr.close();

    fw.close();

  }

  catch (IOException ex)

  {

    ex.printStackTrace();

  }

 }

}

Let us suppose we have a file named “test.txt” in D-drive. Now we first read from this file character-by-character and later we write the contents of this file to another file say “testwrite.txt” in E-drive. For these tasks, we use the character stream classes namely FileReader and FileWriter. The code is given below:

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class FileReadWrite {

  public static void main(String []args) {

  try

  {

    FileReader fr = new FileReader("D:\\\\test.txt");

    FileWriter fw = new FileWriter("E:\\\\testwrite.txt");

    int c;

    while((c=fr.read())!=-1) {

      fw.write(c);

      System.out.print((char)c);

    }

    fr.close();

    fw.close();

  }

  catch (IOException ex)

  {

    ex.printStackTrace();

  }

 }

}

The process of executing multiple threads simultaneously is known as multithreading. The main purpose of multithreading is to provide simultaneous execution of two or more parts of a program to maximum utilize the CPU time. A multithreaded program contains two or more parts that can run concurrently. Each such part of a program called thread.

Example:

Program to create two threads. The first thread should print numbers from 1 to 10 at intervals of 0.5 second and the second thread should print numbers from 11 to 20 at the interval of 1 second.

class First extends Thread

{

    @Override

    public void run()

    {

        for (int i=1; i<=10; i++)

        {

            System.out.println(i);

            try

            {

                Thread.sleep(500);

            }

            catch (InterruptedException e)

            {

                System.out.println(e.getMessage());

            }

        }

    }

}

class Second extends Thread

{

    @Override

    public void run()

    {

        for (int i=11; i<=20; i++)

        {

            System.out.println(i);

            try{

                Thread.sleep(1000);

            }

            catch (InterruptedException e)

            {

                System.out.println(e.getMessage());

            }

        }

    }

}

public class ThreadInterval

{

    public static void main(String[] args)

    {

        Thread first = new First();

        Thread second= new Second();

        first.start();

        second.start();

    }

}

Let us suppose we have a file named “test.txt” in D-drive. Now we first read from this file character-by-character and later we write the contents of this file to another file say “testwrite.txt” in E-drive. For these tasks, we use the character stream classes namely FileReader and FileWriter. The code is given below:

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class FileReadWrite {

  public static void main(String []args) {

  try

  {

    FileReader fr = new FileReader("D:\\\\test.txt");

    FileWriter fw = new FileWriter("E:\\\\testwrite.txt");

    int c;

    while((c=fr.read())!=-1) {

      fw.write(c);

      System.out.print((char)c);

    }

    fr.close();

    fw.close();

  }

  catch (IOException ex)

  {

    ex.printStackTrace();

  }

 }

}

A class is a user defined blueprint or prototype from which objects are created.  It represents the set of properties or methods that are common to all objects of one type.

To create a class, use the keyword class.

Syntax:

Class vs Interface

Let us suppose we have a file named “test.txt” in D-drive. Now we first read from this file character-by-character and later we write the contents of this file to another file say “testwrite.txt” in E-drive. For these tasks, we use the character stream classes namely FileReader and FileWriter. The code is given below:

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class FileReadWrite {

  public static void main(String []args) {

  try

  {

    FileReader fr = new FileReader("D:\\\\test.txt");

    FileWriter fw = new FileWriter("E:\\\\testwrite.txt");

    int c;

    while((c=fr.read())!=-1) {

      fw.write(c);

      System.out.print((char)c);

    }

    fr.close();

    fw.close();

  }

  catch (IOException ex)

  {

    ex.printStackTrace();

  }

 }

}

import java.io.FileReader;

import java.io.IOException;

public class FileReaderDemo {

   public static void main(String[] args) {

   try {

           FileReader fr = new FileReader("Test.txt");

           int c;

           while ((c = fr.read()) != -1) {

              System.out.print((char) c);

           }

   }

   catch (IOException ex) {

            ex.printStackTrace();

     }

  }

}

public static int isAllPossibilities(int[] a)

        {

            int isAllPosibilities = 1;

            if (a.Length == 0) isAllPosibilities = 0;

            for (int i = 0; i < a.Length && isAllPosibilities==1; i++)

            {

                int index = -1;

                for (int j = 0; j < a.Length && index==-1; j++)

                {

                    if (i == a[j]) index = j;

                }

                if (index == -1)

                    isAllPosibilities = 0;

            }

            return isAllPosibilities;

        }

An Exception is an unwanted event that interrupts the normal flow of the program. When an exception occurs program execution gets terminated. In such cases we get a system generated error message. 

Java exception handling is important because it helps maintain the normal, desired flow of the program even when unexpected events occur. If Java exceptions are not handled, programs may crash or requests may fail.  Suppose there are 10 statements in a program and an exception occurs at statement 5; the rest of the code will not be executed, i.e., statements 6 to 10 will not be executed. However, when we perform exception handling, the rest of the statements will be executed. That is why we use exception handling.

Example:

class Example
{
   public static void main(String args[])
   {
      try{
         int num1=30, num2=0;
         int output=num1/num2;
         System.out.println ("Result: "+output);
      }
      catch(ArithmeticException e){
         System.out.println ("You Shouldn't divide a number by zero");
      }
   }
}

Chain of constructor is the process of calling one constructor from another constructor with respect to current object. Constructor chaining can be done in two ways: 

• Within same class: It can be done using this() keyword for constructors in same class
• From base class: by using super() keyword to call constructor from the base class

The main purpose of using a private constructor is to restrict object creation. We also use private constructors to implement the singleton design pattern. 

Example:

public class A  

{  

//craeting a private constructor   

private A()  

{  

}  

void display()  

{  

System.out.println("Private Constructor");  

}  

}  

private class Test  

{  

public static void main(String args[])  

{  

//compile time error  

A obj = new A();   

}  

}  

Let us suppose we have a file named “test.txt” in D-drive. Now we first read from this file character-by-character and later we write the contents of this file to another file say “testwrite.txt” in E-drive. For these tasks, we use the character stream classes namely FileReader and FileWriter. The code is given below:

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class FileReadWrite {

  public static void main(String []args) {

  try

  {

    FileReader fr = new FileReader("D:\\\\test.txt");

    FileWriter fw = new FileWriter("E:\\\\testwrite.txt");

    int c;

    while((c=fr.read())!=-1) {

      fw.write(c);

      System.out.print((char)c);

    }

    fr.close();

    fw.close();

  }

  catch (IOException ex)

  {

    ex.printStackTrace();

  }

 }

}

The process of executing multiple threads simultaneously is known as multithreading. The main purpose of multithreading is to provide simultaneous execution of two or more parts of a program to maximum utilize the CPU time. A multithreaded program contains two or more parts that can run concurrently. Each such part of a program called thread.

Multithreading is important due to following reasons:

• It doesn't block the user because threads are independent and we can perform multiple operations at the same time.
• We can perform many operations together, so it saves time.
• Threads are independent, so it doesn't affect other threads if an exception occurs in a single thread.

Example:

Program to create two threads. The first thread should print numbers from 1 to 10 at intervals of 0.5 second and the second thread should print numbers from 11 to 20 at the interval of 1 second.

class First extends Thread

{

    @Override

    public void run()

    {

        for (int i=1; i<=10; i++)

        {

            System.out.println(i);

            try

            {

                Thread.sleep(500);

            }

            catch (InterruptedException e)

            {

                System.out.println(e.getMessage());

            }

        }

    }

}

class Second extends Thread

{

    @Override

    public void run()

    {

        for (int i=11; i<=20; i++)

        {

            System.out.println(i);

            try{

                Thread.sleep(1000);

            }

            catch (InterruptedException e)

            {

                System.out.println(e.getMessage());

            }

        }

    }

}

public class ThreadInterval

{

    public static void main(String[] args)

    {

        Thread first = new First();

        Thread second= new Second();

        first.start();

        second.start();

    }

}

Java finally block is a block used to execute important code such as closing the connection, etc. It is always executed whether an exception is handled or not. Therefore, it contains all the necessary statements that need to be printed regardless of the exception occurs or not. The finally block follows the try-catch block.

• finally block in Java can be used to put "cleanup" code such as closing a file, closing connection, etc.
• The important statements to be printed can be placed in the finally block.

Example:

class TestFinallyBlock {    

  public static void main(String args[]){    

  try{    

//below code do not throw any exception  

   int data=25/5;    

   System.out.println(data);    

  }    

//catch won't be executed  

  catch(NullPointerException e){  

System.out.println(e);  

}    

//executed regardless of exception occurred or not  

 finally {  

System.out.println("finally block is always executed ");  

}      

System.out.println("rest of the code...");    

  }    

}    

Given below is a list of the exceptions classes:

1. ArithmeticException: It is thrown when an exceptional condition has occurred in an arithmetic operation like divide by zero.
2. ArrayIndexOutOfBoundsException: It is thrown to indicate that an array has been accessed with an illegal index. The index is either negative or greater than or equal to the size of the array.
3. ClassNotFoundException: This Exception is raised when we try to access a class whose definition is not found.
4. FileNotFoundException: This Exception is raised when a file is not accessible or does not open.
5. IOException: It is thrown when an input-output operation failed or interrupted.

Example of Arithmetic Exception:

Life Cycle of Thread

A thread in Java at any point of time exists in any one of the following states.

• New:  A new thread begins its life cycle in the new state. It remains in this state until the program starts the thread. It is also referred to as a born thread. In simple words, a thread has been created, but it has not yet been started. A thread is started by calling its start() method.
• Runnable: The thread is in the runnable state after the invocation of start() method, but the thread scheduler has not selected it to be the running thread. A thread starts life in the Ready-to-run state by calling the start method and wait for its turn. The thread scheduler decides which thread runs and for how long.
• Running:  When the thread starts executing, then the state is changed to a “running” state. The scheduler selects one thread from the thread pool, and it starts executing in the application.
• Dead: This is the state when the thread is terminated. The thread is in running state and as soon as it completed processing it is in “dead state”. Once a thread is in this state, the thread cannot even run again.
• Blocked (Non-runnable state):This is the state when the thread is still alive but is currently not eligible to run. A thread that is blocked waiting for a monitor lock is in this state. A running thread can transit to one of the non-runnable states depending on the situation. A thread remains in a non-runnable state until a special transition occurs. A thread doesn’t go directly to the running state from a non-runnable state but transits first to the Ready-to-run state.

Program to execute multiple threads in priority base

class First extends Thread

{

    @Override

    public void run()

    {

        for (int i = 1; i <= 10; i++)

        {

            System.out.println(i);

        }

    }

}

class Second extends Thread

{

    @Override

    public void run()

    {

        for (int i = 11; i <= 20; i++)

        {

            System.out.println(i);

        }

    }

}

class Third extends Thread

{

    @Override

    public void run()

    {

        for (int i = 21; i <= 30; i++)

        {

            System.out.println(i);

        }

    }

}

public class ThreadPriority

{

    public static void main(String[] args) throws InterruptedException

    {

        Thread t1 = new First();

        Thread t2 = new Second();

        Thread t3 = new Third();

        t1.setPriority(Thread.MAX_PRIORITY);

        t2.setPriority(Thread.MIN_PRIORITY);

        t3.setPriority(Thread.NORM_PRIORITY);

        t1.start();

        t2.start();

        t3.start();

    }

}

Multiple inheritance is where we inherit the properties and behavior of multiple classes to a single class. In java, multiple inheritance is not supported because of ambiguity problem. We can take the below example where we have two classes Class1 and Class2 which have same method display(). If multiple inheritance is possible than Test class can inherit data members and methods of both Class1 and Class2 classes. Now, Test class have two display() methods inherited from Class1 and Class2. Problem occurs in method call, when display() method will be called with Test class object which method will be called, will it be of Class1 or Class2. This is ambiguity problem because of which multiple inheritance is not allowed in java.

Example:

class Class1{

      public void display(){

            System.out.println("Class 1 Display Method");

      }

}

class Class2{

      public void display(){

            System.out.println("Class 2 Display");

      }

}

public class Test extends Class1, Class2{

      public static void main(String args[]){

            Test obj = new Test();

            //Ambiguity problem in method call which class display() method will be called.

            obj.display();

      }

}

Synchronization is a process of handling resource accessibility by multiple thread requests. The main purpose of synchronization is to avoid thread interference. At times when more than one thread try to access a shared resource, we need to ensure that resource will be used by only one thread at a time. The process by which this is achieved is called synchronization. 

If we do not use synchronization, and let two or more threads access a shared resource at the same time, it will lead to distorted results.

Consider an example, Suppose we have two different threads T1 and T2, T1 starts execution and save certain values in a file temporary.txt which will be used to calculate some result when T1 returns. Meanwhile, T2 starts and before T1 returns, T2 change the values saved by T1 in the file temporary.txt (temporary.txt is the shared resource). Now obviously T1 will return wrong result.

To prevent such problems, synchronization was introduced. With synchronization in above case, once T1 starts using temporary.txt file, this file will be locked(LOCK mode), and no other thread will be able to access or modify it until T1 returns.

a. JAVA beans and JAR file

b. MVC design pattern

MVC design pattern is also known as Model-View-Controller. It is a common architectural pattern which is used to design and create interfaces and the structure of an application. This pattern divides the application into three parts that are dependent and connected to each other. 

1. Model: The Model contains only the pure application data. It doesn’t contain any information on how to show the data to the user. It is independent of the user interface. It controls the logic and rules of application.

2. View: The View presents the model’s data to the user. The view knows how to access the model’s data, but it does not know what this data means or what the user can do to manipulate it.

3. Controller: The Controller acts as an interface between View and Model. It receives the user requests and processes them, including the necessary validations. The requests are then sent to model for data processing. Once they are processed, the data is again sent back to the controller and then displayed on the view. 

import javax.swing.*;

import java.awt.GridLayout;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

public class Addition

{

 JLabel l1, l2, l3;

 JTextField t1, t2, t3;

 JFrame f = new JFrame(); 

 Addition() 

 {

  l1 = new JLabel("First Number:");

  t1 = new JTextField();

  l2 = new JLabel("Second Number:");

  t2 = new JTextField();

  l3 = new JLabel("Press any key");

  t3 = new JTextField();

  t3.addkeyListener(new keychecker());

  f.add(l1);

  f.add(t1);

  f.add(l2);

  f.add(t2);

  f.add(l3);

  f.add(t3);

  f.setSize(250,150);

  f.setLayout(new GridLayout(3,2));

  f.setLocationRelativeTo(null);

  f.setVisible(true);

  f.setDefaultCloseOperation(f.EXIT_ON_CLOSE);  

}

class keychecker extends KeyAdapter{

   public void keyPressed(KeyEvent e)     

   {

        int num1 = Integer.parseInt(t1.getText()); 

        int num2 = Integer.parseInt(t2.getText()); 

        int sum = num1 + num2;

        JOptionPane.showMessageDialog(f, "The sum is" +sum);

        t3.setText(null);

   }

 public static void main(String args[])

 {

    new Addition();

 }

}

import javax.swing.*;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

public class Palindrome extends JFrame

{

    public static void main(String[] args)

    {

        Palindrome frame = new Palindrome();

        frame.setVisible(true);

    }

    public Palindrome()

    {

        setLayout(new GridLayout(4,1,10,20));

        JLabel inputLabel = new JLabel("Input any String: ");

        JTextField inputTextField = new JTextField(20);

        add(inputLabel);

        add(inputTextField);

        JLabel outputLabel = new JLabel("Output: ");

        JTextField outputTextField = new JTextField(20);

        add(outputLabel);

        add(outputTextField);

        outputTextField.setEditable(false);

        JButton checkPalindromeButton = new JButton("Check Palindrome");

        add(checkPalindromeButton);

        JButton reverseButton = new JButton("Reverse");

        add(reverseButton);

        JButton findVowelButton = new JButton("Find Vowel");

        add(findVowelButton);

        checkPalindromeButton.addActionListener(new ActionListener()

        {

            @Override

            public void actionPerformed(ActionEvent e)

            {

                String copyUserInput="";

                String userInput = inputTextField.getText();

                int length = userInput.length();

                for (int i = length-1; i>=0; i-- )

                {

                    copyUserInput = copyUserInput + userInput.charAt(i);

                }

                if (copyUserInput.equalsIgnoreCase(userInput))

                {

                    outputTextField.setText("String is palindrome.");

                }

                else

                {

                    outputTextField.setText("String isn't a palindrome.");

                }

            }

        });

        reverseButton.addActionListener(new ActionListener()

        {

            @Override

            public void actionPerformed(ActionEvent e)

            {

                String reverseUserInput="";

                String userInput = inputTextField.getText();

                int length = userInput.length();

                for (int i = length-1; i>=0; i-- )

                {

                    reverseUserInput = reverseUserInput + userInput.charAt(i);

                }

                    outputTextField.setText("Reverse String is: "+ reverseUserInput);

            }

        });

        findVowelButton.addActionListener(new ActionListener()

        {

            @Override

            public void actionPerformed(ActionEvent e)

            {

                char[] vowel={'a','e','i','o','u','A','E','I','O','U'};

                String userInput = inputTextField.getText();

                int length = userInput.length();

                char[] extractedVowel= new char[length];

                String showVowel="";

                for (int i =0; i<=length-1; i++ )

                {

                    for (int j = 0; j<=vowel.length-1; j++)

                    {

                        if(userInput.charAt(i)== vowel[j])

                        {

                            extractedVowel[i] = userInput.charAt(i);

                            showVowel = showVowel + String.valueOf(extractedVowel[i]); //append the extractedVowel to string variable so that it can be displayed at once in a textfield in the form of string.

                        }

                    }

                }

               outputTextField.setText("Vowels: "+showVowel);

            }

        });

        pack();

        setDefaultCloseOperation(EXIT_ON_CLOSE);

    }

}

import javax.swing.*;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

class Addition extends JFrame implements ActionListener    //implement listener interface

{

 JLabel l1, l2;

 JTextField t1, t2, t3;

 JButton b1; 

 public Addition() 

{

  l1 = new JLabel("First Number:");

  l1.setBounds(20, 10, 100, 20);    //x, y, width, height

  t1 = new JTextField(10);

  t1.setBounds(120, 10, 100, 20);

  l2 = new JLabel("Second Number:");

  l2.setBounds(20, 40, 100, 20);    

  t2 = new JTextField(10);

  t2.setBounds(120, 40, 100, 20);

  b1 = new JButton("Sum");

  b1.setBounds(20, 70, 80, 20);

  t3 = new JTextField(10);

  t3.setBounds(120, 70, 100, 120);

  add(l1);

  add(t1);

  add(l2);

  add(t2);

  add(b1);

  add(t3);

  b1.addActionListener(this);    //Registering event

  setSize(400,300);

  setLayout(null);

  setVisible(true);

  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  

}

 @Override

 public void actionPerformed(ActionEvent e)    //Handle Event

 {

    if(e.getSource()==b1){

        int num1 = Integer.parseInt(t1.getText()); 

        int num2 = Integer.parseInt(t2.getText()); 

        int sum = num1 + num2;

        t3.setText(String.valueOf(sum));

   }

 public static void main(String args[])

 {

    new Addition();

 }

}

import javax.swing.*;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

class SimpleInterest extends JFrame implements ActionListener    //implement listener interface

{

 JLabel l1, l2, l3;

 JTextField t1, t2, t3, t4;

 JButton b1; 

 public SimpleInterest() 

{

  l1 = new JLabel("Principal:");

  l1.setBounds(20, 10, 100, 20);    //x, y, width, height

  t1 = new JTextField(10);

  t1.setBounds(120, 10, 100, 20);

  l2 = new JLabel("Time:");

  l2.setBounds(20, 40, 100, 20);    

  t2 = new JTextField(10);

  t2.setBounds(120, 40, 100, 20);

  l3 = new JLabel("Rate:");

  l3.setBounds(20, 70, 100, 20);    

  t3 = new JTextField(10);

  t3.setBounds(120, 70, 100, 20);

  b1 = new JButton("Simple Interest");

  b1.setBounds(20, 100, 80, 20);

  t4 = new JTextField(10);

  t4.setBounds(120, 100, 100, 20);

  add(l1);

  add(t1);

  add(l2);

  add(t2);

  add(l1);

  add(t3);

  add(b1);

  add(t4);

  b1.addActionListener(this);    //Registering event

  setSize(400,300);

  setLayout(null);

  setVisible(true);

  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  

}

 @Override

 public void actionPerformed(ActionEvent e)    //Handle Event

 {

    if(e.getSource()==b1){

        double P = Double.parseDouble(t1.getText()); 

        double T = Double.parseDouble(t2.getText());

        double R = Double.parseDouble(t3.getText());

        double SI = (P*T*R)/100;

        t4.setText(String.valueOf(SI));

   }

 public static void main(String args[])

 {

    new SimpleInterest() ;

 }

}

import javax.swing.*;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

class Multiplication extends JFrame implements ActionListener     //implement listener interface

{

 JLabel l1, l2;

 JTextField t1, t2, t3;

 JButton b1; 

 public Multiplication() 

{

  l1 = new JLabel("First Number:");

  l1.setBounds(20, 10, 100, 20);     //x, y, width, height

  t1 = new JTextField(10);

  t1.setBounds(120, 10, 100, 20);

  l2 = new JLabel("Second Number:");

  l2.setBounds(20, 40, 100, 20);    

  t2 = new JTextField(10);

  t2.setBounds(120, 40, 100, 20);

  b1 = new JButton("Product");

  b1.setBounds(20, 70, 80, 20);

  t3 = new JTextField(10);

  t3.setBounds(120, 70, 100, 120);

  add(l1);

  add(t1);

  add(l2);

  add(t2);

  add(b1);

  add(t3);

  b1.addActionListener(this);    //Registering event

  setSize(400,300);

  setLayout(null);

  setVisible(true);

  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  

}

 @Override

 public void actionPerformed(ActionEvent e)      //Handle Event

 {

    if(e.getSource()==b1){

        int num1 = Integer.parseInt(t1.getText()); 

        int num2 = Integer.parseInt(t2.getText()); 

        int product = num1 * num2;

        t3.setText(String.valueOf(product));

   }

 public static void main(String args[])

 {

    new Multiplication();

 }

}

The layout management is used to arrange components in a particular manner. The Java LayoutManagers facilitates us to control the positioning and size of the components in GUI forms. The layout management classes are given below:

1. Border Layout

The BorderLayout is used to arrange the components in five regions: north, south, east, west and center. Each region (area) may contain one component only.

Components of the BorderLayout Manager

·         BorderLayout.NORTH

·         BorderLayout.SOUTH

·         BorderLayout..EAST

·         BorderLayout.WEST

·         BorderLayout.CENTER

BorderLayout Constructors:

Example:

import java.awt.BorderLayout;  

import javax.swing.JButton;

import javax.swing.JFrame;

public class BorderLayoutExample {  

BorderLayoutExample(){  

    JFrame f=new JFrame();  

    JButton b1=new JButton("NORTH");;  

    JButton b2=new JButton("SOUTH");;  

    JButton b3=new JButton("EAST");;  

    JButton b4=new JButton("WEST");;  

    JButton b5=new JButton("CENTER");;  

    f.add(b1,BorderLayout.NORTH);  

    f.add(b2,BorderLayout.SOUTH);  

    f.add(b3,BorderLayout.EAST);  

    f.add(b4,BorderLayout.WEST);  

    f.add(b5,BorderLayout.CENTER);  

    f.setSize(300,300);  

    f.setVisible(true);  

}  

public static void main(String[] args) {  

    new BorderLayoutExample();  

}  

}  

2. Flow Layout

The FlowLayout is used to arrange the components in a line, one after another (in a flow).  It arranges components in a line, if no space left remaining components goes to next line. Align property determines alignment of the components as left, right, center etc.

FlowLayout Constructors:

import java.awt.FlowLayout;

import javax.swing.JButton;

import javax.swing.JFrame;

public class FlowLayoutExample {

 FlowLayoutExample(){

     JFrame f = new JFrame("Flow Layout");

        JButton b1 = new JButton("button 1");

        JButton b2 = new JButton("button 2");

        JButton b3 = new JButton("button 3");

        JButton b4 = new JButton("button 4");

        JButton b5 = new JButton("button 5");

        f.add(b1);

        f.add(b2);

        f.add(b3);

        f.add(b4);

        f.add(b5);

        f.setLayout(new FlowLayout());

        f.setSize(300,300);  

        f.setVisible(true);  

    }

    public static void main(String[] args) {

        new FlowLayoutExample();

    }

}

3. Grid Layout

The GridLayout is used to arrange the components in rectangular grid. One component is displayed in each rectangle. Components are placed in columns and rows.

Every Component in a GridLayout has the same width and height. Components are added to a GridLayout starting at the top-left cell of the grid and proceeding left to right until the row is full. Then the process continues left to right on the next row of the grid, and so on.

GridLayout Constructors:

Example:

import java.awt.*;

import javax.swing.*;

public class GridDemo

{

      JButton b1, b2, b3, b4, b5, b6;

      GridDemo()

      {

           JFrame f = new JFrame("GridLayoutDemo");

           b1 = new JButton("A");

           b2 = new JButton("B");

           b3 = new JButton("C");

           b4 = new JButton("D");

           b5 = new JButton("E");

           b6 = new JButton("F");

           f.add(b1);

           f.add(b2);

           f.add(b3);

           f.add(b4);

           f.add(b5);

           f.add(b6);

           f.setLayout(new GridLayout(2, 3));

           f.setSize(200, 200);

           f.setVisible(true);

      }

      public static void main(String args[])

      {

           new GridDemo();

      }

}

import javax.swing.*;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

class SimpleInterest extends JFrame implements ActionListener    //implement listener interface

{

 JLabel l1, l2, l3;

 JTextField t1, t2, t3, t4;

 JButton b1; 

 public SimpleInterest() 

{

  l1 = new JLabel("Principal:");

  l1.setBounds(20, 10, 100, 20);    //x, y, width, height

  t1 = new JTextField(10);

  t1.setBounds(120, 10, 100, 20);

  l2 = new JLabel("Time:");

  l2.setBounds(20, 40, 100, 20);    

  t2 = new JTextField(10);

  t2.setBounds(120, 40, 100, 20);

  l3 = new JLabel("Rate:");

  l3.setBounds(20, 70, 100, 20);    

  t3 = new JTextField(10);

  t3.setBounds(120, 70, 100, 20);

  b1 = new JButton("Simple Interest");

  b1.setBounds(20, 100, 80, 20);

  t4 = new JTextField(10);

  t4.setBounds(120, 100, 100, 20);

  add(l1);

  add(t1);

  add(l2);

  add(t2);

  add(l1);

  add(t3);

  add(b1);

  add(t4);

  b1.addActionListener(this);    //Registering event

  setSize(400,300);

  setLayout(null);

  setVisible(true);

  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  

}

 @Override

 public void actionPerformed(ActionEvent e)    //Handle Event

 {

    if(e.getSource()==b1){

        double P = Double.parseDouble(t1.getText()); 

        double T = Double.parseDouble(t2.getText());

        double R = Double.parseDouble(t3.getText());

        double SI = (P*T*R)/100;

        t4.setText(String.valueOf(SI));

   }

 public static void main(String args[])

 {

    new SimpleInterest() ;

 }

}

The GridLayout is used to arrange the components in rectangular grid. One component is displayed in each rectangle. Components are placed in columns and rows.

Every Component in a GridLayout has the same width and height. Components are added to a GridLayout starting at the top-left cell of the grid and proceeding left to right until the row is full. Then the process continues left to right on the next row of the grid, and so on.

GridLayout Constructors:

Example:

import java.awt.*;

import javax.swing.*;

public class GridDemo

{

      JButton b1, b2, b3, b4, b5, b6;

      GridDemo()

      {

           JFrame f = new JFrame("GridLayoutDemo");

           b1 = new JButton("A");

           b2 = new JButton("B");

           b3 = new JButton("C");

           b4 = new JButton("D");

           b5 = new JButton("E");

           b6 = new JButton("F");

           f.add(b1);

           f.add(b2);

           f.add(b3);

           f.add(b4);

           f.add(b5);

           f.add(b6);

           f.setLayout(new GridLayout(2, 3));

           f.setSize(200, 200);

           f.setVisible(true);

      }

      public static void main(String args[])

      {

           new GridDemo();

      }

}

The BorderLayout is used to arrange the components in five regions: north, south, east, west and center. Each region (area) may contain one component only.

Components of the BorderLayout Manager

·         BorderLayout.NORTH

·         BorderLayout.SOUTH

·         BorderLayout..EAST

·         BorderLayout.WEST

·         BorderLayout.CENTER

BorderLayout Constructors:

Example:

import java.awt.BorderLayout;  

import javax.swing.JButton;

import javax.swing.JFrame;

public class BorderLayoutExample {  

BorderLayoutExample(){  

    JFrame f=new JFrame();  

    JButton b1=new JButton("NORTH");;  

    JButton b2=new JButton("SOUTH");;  

    JButton b3=new JButton("EAST");;  

    JButton b4=new JButton("WEST");;  

    JButton b5=new JButton("CENTER");;  

    f.add(b1,BorderLayout.NORTH);  

    f.add(b2,BorderLayout.SOUTH);  

    f.add(b3,BorderLayout.EAST);  

    f.add(b4,BorderLayout.WEST);  

    f.add(b5,BorderLayout.CENTER);  

    f.setSize(300,300);  

    f.setVisible(true);  

}  

public static void main(String[] args) {  

    new BorderLayoutExample();  

}  

}  

Java Swing is a lightweight Graphical User Interface (GUI) toolkit that includes a rich set of widgets. The javax.swing package provides classes for java swing API such as JButton, JTextField, JTextArea, JRadioButton, JCheckbox, JMenu etc.

The benefits of using swing components are

• Swing provides both additional components and added functionality to AWT-replacement components 
•  Swing components can change their appearance based on the current "look and feel" library that's being used. 
•  Swing components follow the Model-View-Controller (MVC) paradigm, and thus can provide a much more flexible UI. 
• Swing provides "extras" for components, such as:  Icons on many components  Decorative borders for components 
• Tool tips for components 
•  Swing components are lightweight (less resource intensive than AWT) 
•  Swing provides built-in double buffering 
• Swing provides paint debugging support for when you build your own components 

The GridLayout is used to arrange the components in rectangular grid. One component is displayed in each rectangle. Components are placed in columns and rows.

Every Component in a GridLayout has the same width and height. Components are added to a GridLayout starting at the top-left cell of the grid and proceeding left to right until the row is full. Then the process continues left to right on the next row of the grid, and so on.

GridLayout Constructors:

Example:

import java.awt.*;

import javax.swing.*;

public class GridDemo

{

      JButton b1, b2, b3, b4, b5, b6;

      GridDemo()

      {

           JFrame f = new JFrame("GridLayoutDemo");

           b1 = new JButton("A");

           b2 = new JButton("B");

           b3 = new JButton("C");

           b4 = new JButton("D");

           b5 = new JButton("E");

           b6 = new JButton("F");

           f.add(b1);

           f.add(b2);

           f.add(b3);

           f.add(b4);

           f.add(b5);