Unit - 3

Inheritance

Q1) What is inheritance in java?

A1) Inheritance in Java is a mechanism in which one object acquires all the properties and behaviour of a parent object. It is an important part of OOPs (Object Oriented programming system).

The idea behind inheritance in Java is that you can create new classes that are built upon existing classes. When you inherit from an existing class, you can reuse methods and fields of the parent class. Moreover, you can add new methods and fields in your current class also.

Inheritance represents the IS-A relationship which is also known as a parent-child relationship.

Why use inheritance in java

●        For Method overriding (so runtime polymorphism can be achieved).

●        For Code Reusability.

Terms used in Inheritance

●        Class: A class is a group of objects which have common properties. It is a template or blueprint from which objects are created.

●        Sub Class/Child Class: Subclass is a class which inherits the other class. It is also called a derived class, extended class, or child class.

●        Super Class/Parent Class: Superclass is the class from where a subclass inherits the features. It is also called a base class or a parent class.

●        Reusability: As the name specifies, reusability is a mechanism which facilitates you to reuse the fields and methods of the existing class when you create a new class. You can use the same fields and methods already defined in the previous class.

The syntax of Java Inheritance

1. Class Subclass-name extends Superclass-name  
2. {  
3.   //methods and fields  
4. }  

The extends keyword indicates that you are making a new class that derives from an existing class. The meaning of "extends" is to increase the functionality.

In the terminology of Java, a class which is inherited is called a parent or superclass, and the new class is called child or subclass.

Q2) Write an example of java inheritance?

A2) Java Inheritance Example

As displayed in the above figure, Programmer is the subclass and Employee is the superclass. The relationship between the two classes is Programmer IS-A Employee. It means that Programmer is a type of Employee.

1. Class Employee{  
2. Float salary=40000;  
3. }  
4. Class Programmer extends Employee{  
5. Int bonus=10000;  
6. Public static void main(String args[]){  
7.   Programmer p=new Programmer();  
8.   System.out.println("Programmer salary is:"+p.salary);  
9.   System.out.println("Bonus of Programmer is:"+p.bonus);  
10. }  
11. }  

Programmer salary is:40000.0

Bonus of programmer is:10000

In the above example, Programmer object can access the field of own class as well as of Employee class i.e. code reusability.

Q3) Explain types of inheritance in java?

A3) Types of inheritance in java

On the basis of class, there can be three types of inheritance in java: single, multilevel and hierarchical.

In java programming, multiple and hybrid inheritance is supported through interface only.

Note: Multiple inheritance is not supported in Java through class.

When one class inherits multiple classes, it is known as multiple inheritance.

For Example:

Single Inheritance Example

When a class inherits another class, it is known as a single inheritance. In the example given below, Dog class inherits the Animal class, so there is the single inheritance.

File: TestInheritance.java

1. Class Animal{  
2. Void eat(){System.out.println("eating...");}  
3. }  
4. Class Dog extends Animal{  
5. Void bark(){System.out.println("barking...");}  
6. }  
7. Class TestInheritance{  
8. Public static void main(String args[]){  
9. Dog d=new Dog();  
10. d.bark();  
11. d.eat();  
12. }}  

Output:

Barking...

Eating…

Multilevel Inheritance Example

When there is a chain of inheritance, it is known as multilevel inheritance. As you can see in the example given below, BabyDog class inherits the Dog class which again inherits the Animal class, so there is a multilevel inheritance.

File: TestInheritance2.java

1. Class Animal{  
2. Void eat(){System.out.println("eating...");}  
3. }  
4. Class Dog extends Animal{  
5. Void bark(){System.out.println("barking...");}  
6. }  
7. Class BabyDog extends Dog{  
8. Void weep(){System.out.println("weeping...");}  
9. }  
10. Class TestInheritance2{  
11. Public static void main(String args[]){  
12. BabyDog d=new BabyDog();  
13. d.weep();  
14. d.bark();  
15. d.eat();  
16. }}  

Output:

Weeping...

Barking...

Eating…

Hierarchical Inheritance Example

When two or more classes inherits a single class, it is known as hierarchical inheritance. In the example given below, Dog and Cat classes inherits the Animal class, so there is hierarchical inheritance.

File: TestInheritance3.java

1. Class Animal{  
2. Void eat(){System.out.println("eating...");}  
3. }  
4. Class Dog extends Animal{  
5. Void bark(){System.out.println("barking...");}  
6. }  
7. Class Cat extends Animal{  
8. Void meow(){System.out.println("meowing...");}  
9. }  
10. Class TestInheritance3{  
11. Public static void main(String args[]){  
12. Cat c=new Cat();  
13. c.meow();  
14. c.eat();  
15. //c.bark();//C.T.Error  
16. }}  

Output:

Meowing...

Eating...

Q4) Explain super keywords with an example?

A4) The super keyword

The super keyword is similar to this keyword. Following are the scenarios where the super keyword is used.

●        It is used to differentiate the members of superclass from the members of subclass, if they have same names.

●        It is used to invoke the superclass constructor from subclass.

Differentiating the Members

If a class is inheriting the properties of another class. And if the members of the superclass have the names same as the sub class, to differentiate these variables we use super keyword as shown below.

Super.variable

Super.method();

Sample Code

This section provides you with a program that demonstrates the usage of the super keyword.

In the given program, you have two classes namely Sub_class and Super_class, both have a method named display() with different implementations, and a variable named num with different values. We are invoking display() method of both classes and printing the value of the variable num of both classes. Here you can observe that we have used super keyword to differentiate the members of superclass from subclass.

Copy and paste the program in a file with name Sub_class.java.

Example

Class Super_class {

   int num = 20;

   // display method of superclass

   public void display() {

      System.out.println("This is the display method of superclass");

   }

}

Public class Sub_class extends Super_class {

   int num = 10;

   // display method of sub class

   public void display() {

      System.out.println("This is the display method of subclass");

   }

   public void my_method() {

      // Instantiating subclass

Sub_class sub = new Sub_class();

      // Invoking the display() method of sub class

Sub.display();

      // Invoking the display() method of superclass

Super.display();

      // printing the value of variable num of subclass

      System.out.println("value of the variable named num in sub class:"+ sub.num);

      // printing the value of variable num of superclass

      System.out.println("value of the variable named num in super class:"+ super.num);

   }

   public static void main(String args[]) {

Sub_classobj = new Sub_class();

Obj.my_method();

   }

}

Compile and execute the above code using the following syntax.

JavacSuper_Demo

Java Super

On executing the program, you will get the following result −

Output

This is the display method of subclass

This is the display method of superclass

Value of the variable named num in sub class:10

Value of the variable named num in super class:20

Q5) What is final modifier in java?

A5)

The final keyword is a non-access modifier that prevents classes, attributes, and methods from being changed (impossible to inherit or override).

When you want a variable to constantly store the same value, such as PI, the final keyword comes in handy (3.14159...).

The last keyword is referred to as a "modifier."

Example

Set a variable to final, to prevent it from being overridden/modified:

Public class Main {

  final int x = 10;

  public static void main(String[] args) {

    Main myObj = new Main();

    myObj.x = 25; // will generate an error: cannot assign a value to a final variable

    System.out.println(myObj.x);

  }

}

 Using Final with Inheritance

●      The final keyword is final, which means we can't change anything.

●      Variables, methods, and classes can all benefit from final keywords.

●      If we use the final keyword for inheritance, that is, if we declare any method in the base class with the final keyword, the final method's implementation will be the same as in the derived class.

●      If any other class extends this subclass, we can declare the final method in any subclass we wish.

Declare final variable with inheritance

// Declaring Parent class

Class Parent {

    /* Creation of final variable pa of string type i.e

    the value of this variable is fixed throughout all

    the derived classes or not overridden*/

    final String pa = "Hello , We are in parent class variable";

}

// Declaring Child class by extending Parent class

Class Child extends Parent {

    /* Creation of variable ch of string type i.e

    the value of this variable is not fixed throughout all

    the derived classes or overridden*/

    String ch = "Hello , We are in child class variable";

}

Class Test {

    public static void main(String[] args) {

        // Creation of Parent class object

        Parent p = new Parent();

        // Calling a variable pa by parent object

        System.out.println(p.pa);

        // Creation of Child class object

        Child c = new Child();

        // Calling a variable ch by Child object

        System.out.println(c.ch);

        // Calling a variable pa by Child object

        System.out.println(c.pa);

    }

}

Output

D:\Programs>javac Test.java

D:\Programs>java Test

Hello, We are in parent class variable

Hello, We are in child class variable

Hello, We are in parent class variable

Declare final methods with inheritance

// Declaring Parent class

Class Parent {

    /* Creation of final method parent of void type i.e

    the implementation of this method is fixed throughout

    all the derived classes or not overridden*/

    final void parent() {

        System.out.println("Hello , we are in parent method");

    }

}

// Declaring Child class by extending Parent class

Class Child extends Parent {

    /* Creation of final method child of void type i.e

    the implementation of this method is not fixed throughout

    all the derived classes or not overridden*/

    void child() {

        System.out.println("Hello , we are in child method");

    }

}

Class Test {

    public static void main(String[] args) {

        // Creation of Parent class object

        Parent p = new Parent();

        // Calling a method parent() by parent object

        p.parent();

        // Creation of Child class object

        Child c = new Child();

        // Calling a method child() by Child class object

        c.child();

        // Calling a method parent() by child object

        c.parent();

    }

}

Output

D:\Programs>javac Test.java

D:\Programs>java Test

Hello, we are in parent method

Hello, we are in child method

Hello, we are in parent method

Q6) Explain method overriding with example.

A6)

In Java, method overriding occurs when a subclass (child class) has the same method as the parent class.

In other words, method overriding occurs when a subclass provides a customized implementation of a method specified by one of its parent classes.

Usage of Java Method Overriding

●      Method overriding is a technique for providing a particular implementation of a method that has already been implemented by its superclass.

●      For runtime polymorphism, method overriding is employed.

Rules for method overriding

●      The argument list should match that of the overridden method exactly.

●      The return type must be the same as or a subtype of the return type stated in the superclass's original overridden method.

●      The access level must be lower than the access level of the overridden method. For instance, if the superclass method is marked public, the subclass overriding method cannot be either private or protected.

●      Instance methods can only be overridden if the subclass inherits them.

●      It is not possible to override a method that has been declared final.

●      A static method cannot be overridden, but it can be re-declared.

●      A method can't be overridden if it can't be inherited.

●      Any superclass function that is not declared private or final can be overridden by a subclass in the same package as the instance's superclass.

●      Only non-final methods labeled public or protected can be overridden by a subclass from a different package.

●      Regardless of whether the overridden method throws exceptions or not, an overriding method can throw any unchecked exceptions. The overriding method, on the other hand, should not throw any checked exceptions that aren't specified by the overridden method. In comparison to the overridden method, the overriding method can throw fewer or narrower exceptions.

●      Overriding constructors is not possible.

Example

//Java Program to illustrate the use of Java Method Overriding 

//Creating a parent class. 

Class Vehicle{ 

  //defining a method 

  void run(){System.out.println("Vehicle is running");} 

} 

//Creating a child class 

Class Bike2 extends Vehicle{ 

  //defining the same method as in the parent class 

  void run(){System.out.println("Bike is running safely");} 

  public static void main(String args[]){ 

  Bike2 obj = new Bike2();//creating object 

  obj.run();//calling method 

  } 

} 

Output

Bike is running safely

Q7) Why is Inheritance used in Java?

A7) There are various advantages of using inheritance in Java that is given below:

• Inheritance provides code reusability. The derived class does not need to redefine the method of base class unless it needs to provide the specific implementation of the method.
• Runtime polymorphism cannot be achieved without using inheritance.
• We can simulate the inheritance of classes with the real-time objects which makes OOPs more realistic.
• Inheritance provides data hiding. The base class can hide some data from the derived class by making it private.
• Method overriding cannot be achieved without inheritance. By method overriding, we can give a specific implementation of some basic method contained by the base class.

Q8) What is super in java?

A8) The super keyword in Java is a reference variable that is used to refer to the immediate parent class object.

Whenever we create the instance of the subclass, an instance of the parent class is created implicitly which is referred by super reference variable.

The super() is called in the class constructor implicitly by the compiler if there is no super or this.

Class Animal

{  Animal()

{     System.out.println("animal is created");}  

}  

Class Dog extends Animal

{  Dog()

{  

System.out.println("dog is created");  

}  

}  

Class TestSuper4   {  

Public static void main(String args[])   {  

Dog d=new Dog();  

}  

}

Output:

Animal is created

Dog is created

Q9) Introduce interface?

A9)

In Java, an interface is a reference type. It's comparable to a class. It consists of a set of abstract methods. When a class implements an interface, it inherits the interface's abstract methods.

An interface may also have constants, default methods, static methods, and nested types in addition to abstract methods. Method bodies are only available for default and static methods.

The process of creating an interface is identical to that of creating a class. A class, on the other hand, describes an object's features and behaviors. An interface, on the other hand, contains the behaviors that a class implements.

Unless the interface's implementation class is abstract, all of the interface's methods must be declared in the class.

In the following ways, an interface is analogous to a class:

●      Any number of methods can be included in an interface.

●      An interface is written in a file with the extension.java, with the interface's name matching the file's name.

●      A.class file contains the byte code for an interface.

●      Packages have interfaces, and the bytecode file for each must be in the same directory structure as the package name.

Why do we use interfaces?

There are three primary reasons to utilize an interface. Below is a list of them.

●      It's a technique for achieving abstraction.

●      We can offer various inheritance functionality via an interface.

●      It's useful for achieving loose coupling.

Q10) How to declare an interface?

A10)

The interface keyword is used to declare an interface. All methods in an interface are declared with an empty body, and all fields are public, static, and final by default. A class that implements an interface is required to implement all of the interface's functions.

Syntax

Interface <interface_name>{ 

    // declare constant fields 

    // declare methods that abstract  

    // by default. 

} 

Q11) How to implement an interface?

A11)

When a class implements an interface, it's like the class signing a contract, agreeing to perform the interface's defined actions. If a class doesn't perform all of the interface's actions, it must declare itself abstract.

To implement an interface, a class utilizes the implements keyword. Following the extends component of the declaration, the implements keyword appears in the class declaration.

Example

/* File name : MammalInt.java */

Public class MammalInt implements Animal {

   public void eat() {

      System.out.println("Mammal eats");

   }

   public void travel() {

      System.out.println("Mammal travels");

   }

   public int noOfLegs() {

      return 0;

   }

   public static void main(String args[]) {

      MammalInt m = new MammalInt();

      m.eat();

      m.travel();

   }

}

Output

Mammal eats

Mammal travels

Q12) What is the package?

A12)

A java package is a group of similar types of classes, interfaces and sub-packages.

Package in java can be categorized in two form, built-in package and user-defined package.

There are many built-in packages such as java, lang, awt, javax, swing, net, io, util, sql etc.

Fig - Package

Simple example of java package

The package keyword is used to create a package in java.

1. //save as Simple.java  
2. Package mypack;  
3. Public class Simple{  
4. Public static void main(String args[]){  
5.    System.out.println("Welcome to package");  
6.   }  
7. }  

How to compile java package

If you are not using any IDE, you need to follow the syntax given below:

1. Javac -d directory javafilename  

For example

1. Javac -d . Simple.java  

The -d switch specifies the destination where to put the generated class file. You can use any directory name like /home (in case of Linux), d:/abc (in case of windows) etc. If you want to keep the package within the same directory, you can use . (dot).

How to run java package program

You need to use fully qualified name e.g. Mypack.Simple etc to run the class.

To Compile: javac -d . Simple.java

To Run: java mypack.Simple

Output: Welcome to package

The -d is a switch that tells the compiler where to put the class file i.e. it represents destination. The . Represents the current folder.

Q13) What are the rules for method overriding?

A13) Rules for method overriding

●      The argument list should match that of the overridden method exactly.

●      The return type must be the same as or a subtype of the return type stated in the superclass's original overridden method.

●      The access level must be lower than the access level of the overridden method. For instance, if the superclass method is marked public, the subclass overriding method cannot be either private or protected.

●      Instance methods can only be overridden if the subclass inherits them.

●      It is not possible to override a method that has been declared final.

●      A static method cannot be overridden, but it can be re-declared.

●      A method can't be overridden if it can't be inherited.

●      Any superclass function that is not declared private or final can be overridden by a subclass in the same package as the instance's superclass.

●      Only non-final methods labeled public or protected can be overridden by a subclass from a different package.

●      Regardless of whether the overridden method throws exceptions or not, an overriding method can throw any unchecked exceptions. The overriding method, on the other hand, should not throw any checked exceptions that aren't specified by the overridden method. In comparison to the overridden method, the overriding method can throw fewer or narrower exceptions.

●      Overriding constructors is not possible.

Q14) What do you mean by abstract classes?

A14) Abstract classes

●      Abstract class is a class that has no direct instances but whose descendant classes have direct instances.

●      It can only be inherited by the concrete classes (descendent classes), where a concrete class can be instantiated.

●      Abstract class act as a generic class having attributes and methods which can be commonly shared and accessed by the concrete classes.

●      The attributes and methods in the abstract class are non-static, accessible by inheriting classes.

●      Abstract can be differentiated by a normal class by writing a abstract keyword in the declaration of the class

●      It can be represented as below

Abstract public class RentalCar {

// your code goes here

}

Fig: Example of abstract class

Q15) Write the advantages of package?

A15)

Advantage of Java Package

1) Java package is used to categorize the classes and interfaces so that they can be easily maintained.

2) Java package provides access protection.

3) Java package removes naming collision.

Q16) Write a program to declare the final method with inheritance?

A16) Declare final methods with inheritance

// Declaring Parent class

Class Parent {

    /* Creation of final method parent of void type i.e

    the implementation of this method is fixed throughout

    all the derived classes or not overridden*/

    final void parent() {

        System.out.println("Hello , we are in parent method");

    }

}

// Declaring Child class by extending Parent class

Class Child extends Parent {

    /* Creation of final method child of void type i.e

    the implementation of this method is not fixed throughout

    all the derived classes or not overridden*/

    void child() {

        System.out.println("Hello , we are in child method");

    }

}

Class Test {

    public static void main(String[] args) {

        // Creation of Parent class object

        Parent p = new Parent();

        // Calling a method parent() by parent object

        p.parent();

        // Creation of Child class object

        Child c = new Child();

        // Calling a method child() by Child class object

        c.child();

        // Calling a method parent() by child object

        c.parent();

    }

}

Output

D:\Programs>javac Test.java

D:\Programs>java Test

Hello, we are in parent method

Hello, we are in child method

Hello, we are in parent method

Q17) How to declare the final variable with inheritance?

A17) Declare final variable with inheritance

// Declaring Parent class

Class Parent {

    /* Creation of final variable pa of string type i.e

    the value of this variable is fixed throughout all

    the derived classes or not overridden*/

    final String pa = "Hello , We are in parent class variable";

}

// Declaring Child class by extending Parent class

Class Child extends Parent {

    /* Creation of variable ch of string type i.e

    the value of this variable is not fixed throughout all

    the derived classes or overridden*/

    String ch = "Hello , We are in child class variable";

}

Class Test {

    public static void main(String[] args) {

        // Creation of Parent class object

        Parent p = new Parent();

        // Calling a variable pa by parent object

        System.out.println(p.pa);

        // Creation of Child class object

        Child c = new Child();

        // Calling a variable ch by Child object

        System.out.println(c.ch);

        // Calling a variable pa by Child object

        System.out.println(c.pa);

    }

}

Output

D:\Programs>javac Test.java

D:\Programs>java Test

Hello, We are in parent class variable

Hello, We are in child class variable

Hello, We are in parent class variable

Q18) Write a sample program to implement an interface in Java?

A18)

Program

Interface Results

{

   final static float pi = 3.14f;

   float areaOf(float l, float b);

}

Class Rectangle implements Results

{

   public float areaOf(float l, float b)

   {

       return (l * b);

   }

}

Class Square implements Results 

{

   public float areaOf(float l, float b)

   {

      return (l * l);

   }

}

Class Circle implements Results

{

   public float areaOf(float r, float b)

   {

      return (pi * r * r);

   }

}

Public class InterfaceDemo

{

   public static void main(String args[])

   {

      Rectangle rect = new Rectangle();

      Square square = new Square();

      Circle circle = new Circle();

      System.out.println("Area of Rectangle: "+rect.areaOf(20.3f, 28.7f));

      System.out.println("Are of square: "+square.areaOf(10.0f, 10.0f));

      System.out.println("Area of Circle: "+circle.areaOf(5.2f, 0));

   }

}

Output:

Area of Rectangle: 582.61

Are of square: 100.0

Area of Circle: 84.905594

Q19) How to inherit the abstract class?

A19) Inheriting the Abstract class

We may inherit the properties of the Employee class in the same way that we can inherit the properties of concrete classes in the following method:

Example

/* File name : Salary.java */

Public class Salary extends Employee {

   private double salary; // Annual salary

   public Salary(String name, String address, int number, double salary) {

      super(name, address, number);

      setSalary(salary);

   }

   public void mailCheck() {

      System.out.println("Within mailCheck of Salary class ");

      System.out.println("Mailing check to " + getName() + " with salary " + salary);

   }

   public double getSalary() {

      return salary;

   }

   public void setSalary(double newSalary) {

      if(newSalary >= 0.0) {

         salary = newSalary;

      }

   }

   public double computePay() {

      System.out.println("Computing salary pay for " + getName());

      return salary/52;

   }

}

You can't instantiate the Employee class here, but you can instantiate the Salary Class, and you can access all three fields and seven methods of the Employee class using this instance, as seen below.

/* File name : AbstractDemo.java */

Public class AbstractDemo {

   public static void main(String [] args) {

      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);

      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);

      System.out.println("Call mailCheck using Salary reference --");

      s.mailCheck();

      System.out.println("\n Call mailCheck using Employee reference--");

      e.mailCheck();

   }

}

Output

Constructing an Employee

Constructing an Employee

Call mailCheck using Salary reference --

Within mailCheck of Salary class

Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--

Within mailCheck of Salary class

Mailing check to John Adams with salary 2400.0

Q20) Write a program to overload three methods with the same name?

A20) Program to overload three methods with the same name

Public class Add{

Public int add(int a , int b){

       return (a + b);

}

Public int add(int a , int b , int c){

       return (a + b + c) ;

}

Public double add(double a , double b){

       return (a + b);

}

Public static void main( String args[]){

Add ob = new Add();

Ob.add(15,25);

Ob.add(15,25,35);

Ob.add(11.5 , 22.5);

}

}

Output:

        40

        75

        34

Q21) Define exception handling?

A21)

Exception handling

●      The Exception Handling in Java is one of the powerful mechanisms to handle the runtime errors so that the normal flow of the application can be maintained.

●      In Java, an exception is an event that disrupts the normal flow of the program. It is an object which is thrown at runtime.

What is Exception in Java

Dictionary Meaning: Exception is an abnormal condition.

In Java, an exception is an event that disrupts the normal flow of the program. It is an object which is thrown at runtime.

What is Exception Handling?

Exception Handling is a mechanism to handle runtime errors such as ClassNotFoundException, IOException, SQLException, RemoteException, etc.

The core advantage of exception handling is to maintain the normal flow of the application. An exception normally disrupts the normal flow of the application that is why we use exception handling. Let's take a scenario:

1. Statement 1; 
2. Statement 2; 
3. Statement 3; 
4. Statement 4; 
5. Statement 5;//exception occurs 
6. Statement 6; 
7. Statement 7; 
8. Statement 8; 
9. Statement 9; 
10. Statement 10; 

Suppose there are 10 statements in your program and there occurs an exception at statement 5, the rest of the code will not be executed i.e. statement 6 to 10 will not be executed. If we perform exception handling, the rest of the statement will be executed. That is why we use exception handling in Java.

Q22) Write the types of exceptions?

A22) There are mainly two types of exceptions: checked and unchecked. Here, an error is considered as the unchecked exception. According to Oracle, there are three types of exceptions:

1. Checked Exception
2. Unchecked Exception
3. Error

Fig – Exception handling

There are mainly two types of exceptions: checked and unchecked. An error is considered as the unchecked exception. However, according to Oracle, there are three types of exceptions namely:

1) Checked Exception:

1. ClassNotFoundException: The ClassNotFoundException is a kind of checked exception that is thrown when we attempt to use a class that does not exist.

Checked exceptions are those exceptions that are checked by the Java compiler itself.

2. FileNotFoundException: The FileNotFoundException is a checked exception that is thrown when we attempt to access a non-existing file.

3. InterruptedException: InterruptedException is a checked exception that is thrown when a thread is in sleeping or waiting state and another thread attempt to interrupt it.

4. InstantiationException: This exception is also a checked exception that is thrown when we try to create an object of abstract class or interface. That is, an InstantiationException exception occurs when an abstract class or interface is instantiated.

5. IllegalAccessException: The IllegalAccessException is a checked exception and it is thrown when a method is called in another method or class but the calling method or class does not have permission to access that method.

6. CloneNotSupportedException: This checked exception is thrown when we try to clone an object without implementing the cloneable interface.

7. NoSuchFieldException: This is a checked exception that is thrown when an unknown variable is used in a program.

8. NoSuchMethodException: This checked exception is thrown when the undefined method is used in a program.

2) Unchecked Exception

Let’s see a brief description of them.

1. ArithmeticException: This exception is thrown when arithmetic problems, such as a number is divided by zero, is occurred. That is, it is caused by maths error.

2. ClassCastException: The ClassCastException is a runtime exception that is thrown by JVM when we attempt to invalid typecasting in the program. That is, it is thrown when we cast an object to a subclass of which an object is not an instance.

3. IllegalArgumentException: This runtime exception is thrown by programmatically when an illegal or appropriate argument is passed to call a method. This exception class has further two subclasses:

●        Number Format Exception

●        Illegal Thread State Exception

Numeric Format Exception: Number Format Exception is thrown by programmatically when we try to convert a string into the numeric type and the process of illegal conversion fails. That is, it occurs due to the illegal conversion of a string to a numeric format.

Illegal Thread State Exception: Illegal Thread State Exception is a runtime exception that is thrown by programmatically when we attempt to perform any operation on a thread but it is incompatible with the current thread state.

4. IndexOutOfBoundsException: This exception class is thrown by JVM when an array or string is going out of the specified index. It has two further subclasses:

●        ArrayIndexOutOfBoundsException

●        StringIndexOutOfBoundsException

ArrayIndexOutOfBoundsException: ArrayIndexOutOfBoundsException exception is thrown when an array element is accessed out of the index.

StringIndexOutOfBoundsException: StringIndexOutOfBoundsException exception is thrown when a String or StringBuffer element is accessed out of the index.

5. NullPointerException: NullPointerException is a runtime exception that is thrown by JVM when we attempt to use null instead of an object. That is, it is thrown when the reference is null.

6. ArrayStoreException: This exception occurs when we attempt to store any value in an array which is not of array type. For example, suppose, an array is of integer type but we are trying to store a value of an element of another type.

7. IllegalStateException: The IllegalStateException exception is thrown by programmatically when the runtime environment is not in an appropriate state for calling any method.

8. IllegalMonitorStateException: This exception is thrown when a thread does not have the right to monitor an object and tries to access wait(), notify(), and notifyAll() methods of the object.

9. NegativeArraySizeException: The NegativeArraySizeException exception is thrown when an array is created with a negative size.

3) Error

Error is irrecoverable. Some examples of errors are Out Of Memory Error, Virtual Machine Error, Assertion Error etc.

Q23) What are the differences between checked and unchecked exceptions?

A23) Difference between Checked and Unchecked Exceptions

Q24) Write the difference between throw and throws?

A24)

Difference between throw and throws in Java

There are many differences between throw and throws keywords. A list of differences between throw and throws are given below: