Unit - 3

Inheritance and Polymorphism

Q1) Introduce inheritance?

A1) Inheritance is one of the main principles of OOP language. By using this principle one can inherit all the properties of other classes. Inheritance allows us to manage information in a hierarchical manner.

Inheritance use two types of class: Superclass and subclass. Superclass also known as parent or base class is the class whose properties are inherited while subclass also known as derived or child class is the class who inherits the properties.

To inherit a class we simply use the extend keyword which allows to inherit the definition of class to another as shown below:

Class subclass-name extends superclass-name {

// body of class

}

Lets look at a simple example of inheritance:

Class First {  // Superclass.

Int x, y;

Void showxy() {

System.out.println("x and y: " + x + " " + y);

}

}

Class Second extends First {  // Subclass Second by extending class First.

Int z;

Void showz() {

System.out.println("z: " + z);

}

Void sum() {

System.out.println("x+y+z: " + (x+y+z));

}

}

Class Example {

Public static void main(String args[]) {

First superOb = new First();

Second subOb = new Second();

SuperOb.x = 100;

SuperOb.y = 200;

System.out.println("Data of superclass: ");

SuperOb.showxy();

System.out.println();

/* The subclass can access all public members of its superclass. */

SubOb.x = 45;

SubOb.y = 10;

SubOb.z = 5;

System.out.println("Contents of subOb: ");

SubOb.showxy();

SubOb.showz();

System.out.println();

System.out.println("Sum of i, j and k in subOb:");

SubOb.sum();

}

}

Output

Data of superclass:

x and y: 100 200

Contents of subOb:

x and y: 45 10

z: 5

Sum of x, y and z in subOb:

x+y+z: 60

Q2) What are the significance of inheritance?

A2) Significance of Inheritance

Inheritance is one of the most significant concepts of object oriented programming which allow a class to inherit its properties to another class. This makes it easier to deploy and maintain an application.

Another benefit of using inheritance is code reusability. Code reusability means avoiding unnecessary code. In inheritance code can be used by other classes and the subclass has to write its own unique properties only and the rest of the properties will be inherited from the parent class or superclass.

Method overriding is also one benefit of using inheritance. Here a child class creates a method of the same type as in parent class. In method overriding when we call the method, the child class method will be called. To call the parent class method we have to use the super keyword.

Q3) What is constructor in inheritance?

A3) Constructor in Inheritance

In Java, when inheritance is implemented in that case constructor of base class gets automatically called in derived class.

In heritance constructors are called in the order they are derived i.e. from superclass to subclass.

The order of execution of constructor in inheritance will be from superclass to subclass in spite of the fact that super keyword is used or not.

If super() is used it will be the first statement to be executed by the subclass constructor. And if super() is not used in that case default or non parameterized constructor of each superclass will be executed first.

Example

Class P{   //Super class

P(){

System.out.println(“Superclass  constructor”);

}}

Class C1 extends P{   //Sub class1

C1(){

System.out.println(“First subclass constructor”);

}}

Class C2 extends C1{   //Sub class2

C2(){

System.out.println(“Second subclass constructor”);

}}

Class Example{

Public static void main(String[] args)

C2 c = new C2();

}

}

Output of above program is

Superclass constructor

First subclass constructor

Second subclass constructor

Q4) Define multilevel inheritance?

A4) 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…

Q5) Explain method overriding?

A5) Method overriding

If subclass (child class) has the same method as declared in the parent class, it is known as method overriding in Java.

In other words, If a subclass provides the specific implementation of the method that has been declared by one of its parent class, it is known as method overriding.

Usage of Java Method Overriding

●        Method overriding is used to provide the specific implementation of a method which is already provided by its superclass.

●        Method overriding is used for runtime polymorphism

Rules for Java Method Overriding

1. The method must have the same name as in the parent class
2. The method must have the same parameter as in the parent class.
3. There must be an IS-A relationship (inheritance).

Fig 1 – Method overriding

Q6) Write the example of method overriding?

A6) In this example, we have defined the run method in the subclass as defined in the parent class but it has some specific implementation. The name and parameter of the method are the same, and there is IS-A relationship between the classes, so there is method overriding.

1. //Java Program to illustrate the use of Java Method Overriding  
2. //Creating a parent class.  
3. Class Vehicle{  
4.  //defining a method  
5.  Void run(){System.out.println("Vehicle is running");}  
6. }  
7. //Creating a child class  
8. Class Bike2 extends Vehicle{  
9.  //defining the same method as in the parent class  
10.  Void run(){System.out.println("Bike is running safely");}  
11.  
12.  Public static void main(String args[]){  
13.  Bike2 obj = new Bike2();//creating object  
14.  Obj.run();//calling method  
15.  }  
16. }  

Output:

Bike is running safely

Q7) Describe super keyword with example?

A7) 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 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_class obj = new Sub_class();

Obj.my_method();

}

}

Compile and execute the above code using the following syntax.

Javac Super_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

Q8) Write a program to refer to the immediate parent class instance variable using super keyword?

A8) Program

Class transport

{

Int maxspeed = 200;

}

Class vehicle extends transport

{

Int maxspeed =100;

}

Class car extends vehicle

{

Int maxspeed = 120;

Void disp()

{System.out.println("Max speed= "+super.maxspeed);

}

}

Class veh

{

Public static void main(String arg[])

{

Car c = new car();

c.disp();

}

}

Output:

Max speed= 100

Q9) Write a program to invoke the immediate parent class method?

A9) Program

Class transport

{

Void message()

{

System.out.println("transport");

}

}

Class vehicle extends transport

{

Void message()

{

System.out.println("vehicle");

}

}

Class car extends vehicle

{

Int maxspeed = 120;

Void message()

{

System.out.println("car");

}

Void display()

{

Message();

Super.message();

}

}

Class veh

{

Public static void main(String arg[])

{

Car c = new car();

c.display();}

}

Output:

Car

Vehicle

Q10) Write a program to invoke immediate parent class constructor?

A10) Program

Class vehicle

{

Vehicle()

{

System.out.println("vehicle");

}

}

Class car extends vehicle

{

Car()

{

Super();

System.out.println("car");

}

}

Class veh

{

Public static void main(String arg[])

{

Car c = new car();

}

}

Output:

Vehicle

Car

Q11) Explain final keyword?

A11) In Java, the keyword final is used to limit some functionality. The final keyword can be used to declare variables, methods, and classes.

Using final with inheritance

We must declare methods with the final keyword during inheritance, and we must follow the same implementation throughout all derived classes. It's worth noting that declaring final methods at the start of inheritance isn't required (base class always). We can define a final method in any subclass to ensure that if another class extends that subclass, it must implement the method in the same way as that subclass.

Example

// Java program to illustrate

// use of final with inheritance

// base class

Abstract class Shape

{

Private double width;

Private double height;

// Shape class parameterized constructor

Public Shape(double width, double height)

{

This.width = width;

This.height = height;

}

// getWidth method is declared as final

// so any class extending

// Shape can't override it

Public final double getWidth()

{

Return width;

}

// getHeight method is declared as final

// so any class extending Shape

// can not override it

Public final double getHeight()

{

Return height;

}

// method getArea() declared abstract because

// it upon its subclasses to provide

// complete implementation

Abstract double getArea();

}

// derived class one

Class Rectangle extends Shape

{

// Rectangle class parameterized constructor

Public Rectangle(double width, double height)

{

// calling Shape class constructor

Super(width, height);

}

// getArea method is overridden and declared

// as final    so any class extending

// Rectangle can't override it

@Override

Final double getArea()

{

Return this.getHeight() * this.getWidth();

}

}

//derived class two

Class Square extends Shape

{

// Square class parameterized constructor

Public Square(double side)

{

// calling Shape class constructor

Super(side, side);

}

// getArea method is overridden and declared as

// final so any class extending

// Square can't override it

@Override

Final double getArea()

{

Return this.getHeight() * this.getWidth();

}

}

// Driver class

Public class Test

{

Public static void main(String[] args)

{

// creating Rectangle object

Shape s1 = new Rectangle(10, 20);

// creating Square object

Shape s2 = new Square(10);

// getting width and height of s1

System.out.println("width of s1 : "+ s1.getWidth());

System.out.println("height of s1 : "+ s1.getHeight());

// getting width and height of s2

System.out.println("width of s2 : "+ s2.getWidth());

System.out.println("height of s2 : "+ s2.getHeight());

//getting area of s1

System.out.println("area of s1 : "+ s1.getArea());

//getting area of s2

System.out.println("area of s2 : "+ s2.getArea());

}

}

Output

Width of s1 : 10.0

Height of s1 : 20.0

Width of s2 : 10.0

Height of s2 : 10.0

Area of s1 : 200.0

Area of s2 : 100.0

Q12) What do you mean by polymorphism?

A12) Polymorphism can be defined as the ability to take different forms. It occurs when inheritance is used to have many classes that are related to each other.

Polymorphism most commonly used when a parent class reference is made to refer to a child class object.

Being one of the most important features of OOP, it must be supported by all languages based on OOP. Polymorphism in Java gives us the flexibility to use all the inherited properties of superclass to perform a task.

In real life, the simplest example to explain the concept of polymorphism is a person class. A single person can have different relationship with other person, like a mother, a daughter, a sister, a friend, an employee etc.

To better understand the concept of polymorphism we have to take a look at an example.

Consider a superclass named “Shapes” having a method name area(). The subclasses of this superclass can be Square, Rectangle, Triangle or any other shape. Using inheritance the subclass inherits the area() method also, but each shape has its own way of calculating area. Hence we can see that method name is same but it is used in different forms.

Class Shapes {

Public void area() {

System.out.println("Area of shape can be calculated as: \n");

}

}

Class Square extends Shapes {

Public void area() {

System.out.println("Area of Square is side * side ");

}

}

Class Rectangle extends Shapes {

Public void area() {

System.out.println("Area of Rectangle is base * height ");

}

}

Class Main {

Public static void main(String[] args) {

Shapes myShape = new Shapes();  // Create a Shapes object

Shapes mySquare = new Square();  // Create a Triangle object

Shapes myRectangle = new Rectangle();  // Create a Circle object

MyShape.area();

MySquare.area();

MyRectangle.area();

}

}

Output

Area of shape can be calculated as:

Area of Square is side * side

Area of Rectangle is base * height

Q13) Write the advantages of polymorphism?

A13) Advantages

1. Code can be reusable in polymorphism, which means the classes that are already written can be used many times.
2. We can use a single variable to store data values in multiple definition of methods. It will not change the value of a variable in the superclass, in fact allows storing subclass variable data also.
3. Polymorphism allows lesser line of code, which helps the programmer to debug in case of error.

Q14) What are the types of polymorphism?

A14) Types of polymorphism

Java supports two types of polymorphism:

1. Compile time polymorphism
2. Runtime polymorphism

Compile Time Polymorphism

It is also known as static polymorphism in Java. In this type, method call is made at compile time.

Compile type polymorphism is achieved through the concept of method overloading and operator overloading. However operator overloading is not supported in Java.

Method overloading can be defined as overloading of methods having same name i.e. when a class consist of multiple methods having same name but differs in the number, types, parameters and the return type of methods.

Java gives the flexibility to the user to create as many methods of same as long as it can be differentiate between them by the type and number of parameters.

Method overloading is explained in detail below.

Runtime Polymorphism

In Java, runtime polymorphism is also referred as Dynamic Binding or Dynamic Method Dispatch. In this process, at runtime we can call to an overridden method to process dynamically rather at compile time.

To implement the runtime polymorphism we us method overridden.

Method overridden happens when the child or subclass has a method with same definition as the parent or superclass, then that function overrides the function in the superclass.

In this process, a reference variable of a superclass is used to called an overridden method.

Q15) Write about dynamic binding?

A15) The method to be called is not determined by the compiler in dynamic binding. Dynamic binding is exemplified through overriding. Both the parent and child classes have the same approach for overriding.

Dynamic binding occurs when the type of an object is determined at run-time.

Example

Class Animal{ 

Void eat(){System.out.println("animal is eating...");} 

} 

Class Dog extends Animal{ 

Void eat(){System.out.println("dog is eating...");} 

Public static void main(String args[]){ 

Animal a=new Dog(); 

a.eat(); 

} 

} 

Output

Output:dog is eating…

Because the instance of Dog is also an instance of Animal, the compiler cannot detect the object type in the previous example. As a result, the compiler only knows its basic type.

Q16) Define method overriding?

A16) In Java, method overriding is a technique through which a subclass or derived class can provide its own version of a method whose implementation is given by one its super class.

By doing this a subclass is defining a method having same name, same parameter, and same return type similar to method in the superclass. Then the method in the subclass is said to override the method in the superclass.

The concept of runtime polymorphism in Java can be implemented using Method overriding.

The next important question is which class method will be executed. So the answer is

1. When an object of a parent class makes a call to method, then the parent class method will be executed.
2. When an object of a child class makes a call to method, then the child class method will be executed.

Hence, the type of object used for referring determines which version of the method will be executed in the case of overridden method.

A simple example showing how overridden method are created and called.

//Parent class declaration

Class Parent{

Void display()  //method defined in parent class

{

System.out.println(Method of parent class”);

}

}

//Child class declaration

Class Child extends Parent{

Void display() //child class method overrides parent class method

{

System.out.println(Method of child class”);

}

}

Class Demo{

Public static void main(String[] args)

{

Parent p = new Parent();  // object of parent class

Parent o = new Child(); // object of child class

p.display();                 //reference made to parent class method by object p

o.display();               //reference made to child class method by object o

}

}

Output

Method of parent class

Method of child class

Q17) What are the rules of method overriding?

A17) Rules for Method Overriding

1. Overridden method must have same name and parameters.
2. Method which is declared as final cannot be overridden.
3. Static methods cannot be used to override.
4. Overridden is not possible in private method.
5. The return type of overriding method must be same.
6. Constructors cannot be override.
7. IS-A relationship must be fulfill in method overridden technique.

Q18) Explain abstract classes with any example?

A18) Abstraction, according to the definition, is the ability to deal with ideas rather than occurrences. When it comes to email, for example, intricate information like what happens when you send an e-mail and the protocol your e-mail server utilizes are hidden from the user. As a result, all you have to do to send an email is input the content, include the recipient's address, and click send.

Similarly, in Object-oriented programming, abstraction is the process of hiding implementation details from the user and simply providing functionality. To put it another way, the user will be given knowledge about what the object does rather than how it does it.

Abstract classes and interfaces are used in Java to achieve abstraction.

Abstract Classes

Abstract class is a type of class that has the abstract keyword in its declaration.

●      Abstract classes may or may not contain abstract methods (public void get();).

●      However, a class must be designated abstract if it has at least one abstract method.

●      A class that has been declared abstract cannot be instantiated.

●      You must inherit an abstract class from another class and supply implementations for the abstract methods in it in order to use it.

●      You must supply implementations for all abstract methods in an abstract class if you inherit it.

Example

This section shows you how to use the abstract class. Simply use the abstract keyword before the class keyword in the class definition to create an abstract class.

/* File name : Employee.java */

Public abstract class Employee {

Private String name;

Private String address;

Private int number;

Public Employee(String name, String address, int number) {

System.out.println("Constructing an Employee");

This.name = name;

This.address = address;

This.number = number;

}

Public double computePay() {

System.out.println("Inside Employee computePay");

Return 0.0;

}

Public void mailCheck() {

System.out.println("Mailing a check to " + this.name + " " + this.address);

}

Public String toString() {

Return name + " " + address + " " + number;

}

Public String getName() {

Return name;

}

Public String getAddress() {

Return address;

}

Public void setAddress(String newAddress) {

Address = newAddress;

}

Public int getNumber() {

Return number;

}

}

Except for abstract methods, the Employee class is identical to a regular Java class. The class has three fields, seven methods, and one function Object() { [native code] }, but it is now abstract.

You may now attempt to instantiate the Employee class as follows:

/* File name : AbstractDemo.java */

Public class AbstractDemo {

Public static void main(String [] args) {

/* Following is not allowed and would raise error */

Employee e = new Employee("George W.", "Houston, TX", 43);

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

e.mailCheck();

}

}

When you compile the above class, it gives you the following error −

Employee.java:46: Employee is abstract; cannot be instantiated

Employee e = new Employee("George W.", "Houston, TX", 43);

^

1 error

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) Describe Abstract Methods?

A20) If you want a class to contain a method but the actual implementation of that method to be determined by child classes, designate the method as an abstract in the parent class.

●      To declare a method abstract, use the abstract keyword.

●      In the method declaration, the abstract keyword must come before the method name.

●      There is no method body in an abstract method, only a method signature.

●      An abstract method will have a semicolon (;) at the end instead of curly braces.

The abstract technique is demonstrated in the following example.

Example

Public abstract class Employee {

Private String name;

Private String address;

Private int number;

Public abstract double computePay();

// Remainder of class definition

}

Declaring a method abstract has two ramifications.

●      It must be specified as abstract in the class that contains it.

●      Any class that inherits the current class must either override or declare the abstract method.

Note that a descendant class must implement the abstract method at some point; otherwise, you'll wind up with a hierarchy of abstract classes that can't be created.

If the Salary class derives from the Employee class, the computePay() method should be implemented as shown below.

/* File name : Salary.java */

Public class Salary extends Employee {

Private double salary; // Annual salary

Public double computePay() {

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

Return salary/52;

}

// Remainder of class definition

}

Q21) Why is multiple inheritance not supported in java?

A21) Multiple inheritance is not supported in Java to decrease complexity and simplify the language.

Consider the following scenario: A, B, and C are three different classes. The A and B classes are inherited by the C class. If A and B classes have the same method and you call it from a child class object, the method of A or B will be ambiguous.

Because compile-time errors are preferable to runtime errors, if you inherit two classes, Java generates a compile-time error. There will be a build time error whether you use the same approach or a different one.

Example

Class A{ 

Void msg(){System.out.println("Hello");} 

} 

Class B{ 

Void msg(){System.out.println("Welcome");} 

} 

Class C extends A,B{//suppose if it were 

Public static void main(String args[]){ 

C obj=new C(); 

Obj.msg();//Now which msg() method would be invoked? 

} 

} 

Output

Compile Time Error

Unit - 3

Inheritance and Polymorphism

Q1) Introduce inheritance?

A1) Inheritance is one of the main principles of OOP language. By using this principle one can inherit all the properties of other classes. Inheritance allows us to manage information in a hierarchical manner.

Inheritance use two types of class: Superclass and subclass. Superclass also known as parent or base class is the class whose properties are inherited while subclass also known as derived or child class is the class who inherits the properties.

To inherit a class we simply use the extend keyword which allows to inherit the definition of class to another as shown below:

Class subclass-name extends superclass-name {

// body of class

}

Lets look at a simple example of inheritance:

Class First {  // Superclass.

Int x, y;

Void showxy() {

System.out.println("x and y: " + x + " " + y);

}

}

Class Second extends First {  // Subclass Second by extending class First.

Int z;

Void showz() {

System.out.println("z: " + z);

}

Void sum() {

System.out.println("x+y+z: " + (x+y+z));

}

}

Class Example {

Public static void main(String args[]) {

First superOb = new First();

Second subOb = new Second();

SuperOb.x = 100;

SuperOb.y = 200;

System.out.println("Data of superclass: ");

SuperOb.showxy();

System.out.println();

/* The subclass can access all public members of its superclass. */

SubOb.x = 45;

SubOb.y = 10;

SubOb.z = 5;

System.out.println("Contents of subOb: ");

SubOb.showxy();

SubOb.showz();

System.out.println();

System.out.println("Sum of i, j and k in subOb:");

SubOb.sum();

}

}

Output

Data of superclass:

x and y: 100 200

Contents of subOb:

x and y: 45 10

z: 5

Sum of x, y and z in subOb:

x+y+z: 60

Q2) What are the significance of inheritance?

A2) Significance of Inheritance

Inheritance is one of the most significant concepts of object oriented programming which allow a class to inherit its properties to another class. This makes it easier to deploy and maintain an application.

Another benefit of using inheritance is code reusability. Code reusability means avoiding unnecessary code. In inheritance code can be used by other classes and the subclass has to write its own unique properties only and the rest of the properties will be inherited from the parent class or superclass.

Method overriding is also one benefit of using inheritance. Here a child class creates a method of the same type as in parent class. In method overriding when we call the method, the child class method will be called. To call the parent class method we have to use the super keyword.

Q3) What is constructor in inheritance?

A3) Constructor in Inheritance

In Java, when inheritance is implemented in that case constructor of base class gets automatically called in derived class.

In heritance constructors are called in the order they are derived i.e. from superclass to subclass.

The order of execution of constructor in inheritance will be from superclass to subclass in spite of the fact that super keyword is used or not.

If super() is used it will be the first statement to be executed by the subclass constructor. And if super() is not used in that case default or non parameterized constructor of each superclass will be executed first.

Example

Class P{   //Super class

P(){

System.out.println(“Superclass  constructor”);

}}

Class C1 extends P{   //Sub class1

C1(){

System.out.println(“First subclass constructor”);

}}

Class C2 extends C1{   //Sub class2

C2(){

System.out.println(“Second subclass constructor”);

}}

Class Example{

Public static void main(String[] args)

C2 c = new C2();

}

}

Output of above program is

Superclass constructor

First subclass constructor

Second subclass constructor

Q4) Define multilevel inheritance?

A4) 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…

Q5) Explain method overriding?

A5) Method overriding

If subclass (child class) has the same method as declared in the parent class, it is known as method overriding in Java.

In other words, If a subclass provides the specific implementation of the method that has been declared by one of its parent class, it is known as method overriding.

Usage of Java Method Overriding

●        Method overriding is used to provide the specific implementation of a method which is already provided by its superclass.

●        Method overriding is used for runtime polymorphism

Rules for Java Method Overriding

1. The method must have the same name as in the parent class
2. The method must have the same parameter as in the parent class.
3. There must be an IS-A relationship (inheritance).

Fig 1 – Method overriding

Q6) Write the example of method overriding?

A6) In this example, we have defined the run method in the subclass as defined in the parent class but it has some specific implementation. The name and parameter of the method are the same, and there is IS-A relationship between the classes, so there is method overriding.

1. //Java Program to illustrate the use of Java Method Overriding  
2. //Creating a parent class.  
3. Class Vehicle{  
4.  //defining a method  
5.  Void run(){System.out.println("Vehicle is running");}  
6. }  
7. //Creating a child class  
8. Class Bike2 extends Vehicle{  
9.  //defining the same method as in the parent class  
10.  Void run(){System.out.println("Bike is running safely");}  
11.  
12.  Public static void main(String args[]){  
13.  Bike2 obj = new Bike2();//creating object  
14.  Obj.run();//calling method  
15.  }  
16. }  

Output:

Bike is running safely

Q7) Describe super keyword with example?

A7) 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 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_class obj = new Sub_class();

Obj.my_method();

}

}

Compile and execute the above code using the following syntax.

Javac Super_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

Q8) Write a program to refer to the immediate parent class instance variable using super keyword?

A8) Program

Class transport

{

Int maxspeed = 200;

}

Class vehicle extends transport

{

Int maxspeed =100;

}

Class car extends vehicle

{

Int maxspeed = 120;

Void disp()

{System.out.println("Max speed= "+super.maxspeed);

}

}

Class veh

{

Public static void main(String arg[])

{

Car c = new car();

c.disp();

}

}

Output:

Max speed= 100

Q9) Write a program to invoke the immediate parent class method?

A9) Program

Class transport

{

Void message()

{

System.out.println("transport");

}

}

Class vehicle extends transport

{

Void message()

{

System.out.println("vehicle");

}

}

Class car extends vehicle

{

Int maxspeed = 120;

Void message()

{

System.out.println("car");

}

Void display()

{

Message();

Super.message();

}

}

Class veh

{

Public static void main(String arg[])

{

Car c = new car();

c.display();}

}

Output:

Car

Vehicle

Q10) Write a program to invoke immediate parent class constructor?

A10) Program

Class vehicle

{

Vehicle()

{

System.out.println("vehicle");

}

}

Class car extends vehicle

{

Car()

{

Super();

System.out.println("car");

}

}

Class veh

{

Public static void main(String arg[])

{

Car c = new car();

}

}

Output:

Vehicle

Car

Q11) Explain final keyword?

A11) In Java, the keyword final is used to limit some functionality. The final keyword can be used to declare variables, methods, and classes.

Using final with inheritance

We must declare methods with the final keyword during inheritance, and we must follow the same implementation throughout all derived classes. It's worth noting that declaring final methods at the start of inheritance isn't required (base class always). We can define a final method in any subclass to ensure that if another class extends that subclass, it must implement the method in the same way as that subclass.

Example

// Java program to illustrate

// use of final with inheritance

// base class

Abstract class Shape

{

Private double width;

Private double height;

// Shape class parameterized constructor

Public Shape(double width, double height)

{

This.width = width;

This.height = height;

}

// getWidth method is declared as final

// so any class extending

// Shape can't override it

Public final double getWidth()

{

Return width;

}

// getHeight method is declared as final

// so any class extending Shape

// can not override it

Public final double getHeight()

{

Return height;

}

// method getArea() declared abstract because

// it upon its subclasses to provide

// complete implementation

Abstract double getArea();

}

// derived class one

Class Rectangle extends Shape

{

// Rectangle class parameterized constructor

Public Rectangle(double width, double height)

{

// calling Shape class constructor

Super(width, height);

}

// getArea method is overridden and declared

// as final    so any class extending

// Rectangle can't override it

@Override

Final double getArea()

{

Return this.getHeight() * this.getWidth();

}

}

//derived class two

Class Square extends Shape

{

// Square class parameterized constructor

Public Square(double side)

{

// calling Shape class constructor

Super(side, side);

}

// getArea method is overridden and declared as

// final so any class extending

// Square can't override it

@Override

Final double getArea()

{

Return this.getHeight() * this.getWidth();

}

}

// Driver class

Public class Test

{

Public static void main(String[] args)

{

// creating Rectangle object

Shape s1 = new Rectangle(10, 20);

// creating Square object

Shape s2 = new Square(10);

// getting width and height of s1

System.out.println("width of s1 : "+ s1.getWidth());

System.out.println("height of s1 : "+ s1.getHeight());

// getting width and height of s2

System.out.println("width of s2 : "+ s2.getWidth());

System.out.println("height of s2 : "+ s2.getHeight());

//getting area of s1

System.out.println("area of s1 : "+ s1.getArea());

//getting area of s2

System.out.println("area of s2 : "+ s2.getArea());

}

}

Output

Width of s1 : 10.0

Height of s1 : 20.0

Width of s2 : 10.0

Height of s2 : 10.0

Area of s1 : 200.0

Area of s2 : 100.0

Q12) What do you mean by polymorphism?

A12) Polymorphism can be defined as the ability to take different forms. It occurs when inheritance is used to have many classes that are related to each other.

Polymorphism most commonly used when a parent class reference is made to refer to a child class object.

Being one of the most important features of OOP, it must be supported by all languages based on OOP. Polymorphism in Java gives us the flexibility to use all the inherited properties of superclass to perform a task.

In real life, the simplest example to explain the concept of polymorphism is a person class. A single person can have different relationship with other person, like a mother, a daughter, a sister, a friend, an employee etc.

To better understand the concept of polymorphism we have to take a look at an example.

Consider a superclass named “Shapes” having a method name area(). The subclasses of this superclass can be Square, Rectangle, Triangle or any other shape. Using inheritance the subclass inherits the area() method also, but each shape has its own way of calculating area. Hence we can see that method name is same but it is used in different forms.

Class Shapes {

Public void area() {

System.out.println("Area of shape can be calculated as: \n");

}

}

Class Square extends Shapes {

Public void area() {

System.out.println("Area of Square is side * side ");

}

}

Class Rectangle extends Shapes {

Public void area() {

System.out.println("Area of Rectangle is base * height ");

}

}

Class Main {

Public static void main(String[] args) {

Shapes myShape = new Shapes();  // Create a Shapes object

Shapes mySquare = new Square();  // Create a Triangle object

Shapes myRectangle = new Rectangle();  // Create a Circle object

MyShape.area();

MySquare.area();

MyRectangle.area();

}

}

Output

Area of shape can be calculated as:

Area of Square is side * side

Area of Rectangle is base * height

Q13) Write the advantages of polymorphism?

A13) Advantages

1. Code can be reusable in polymorphism, which means the classes that are already written can be used many times.
2. We can use a single variable to store data values in multiple definition of methods. It will not change the value of a variable in the superclass, in fact allows storing subclass variable data also.
3. Polymorphism allows lesser line of code, which helps the programmer to debug in case of error.

Q14) What are the types of polymorphism?

A14) Types of polymorphism

Java supports two types of polymorphism:

1. Compile time polymorphism
2. Runtime polymorphism

Compile Time Polymorphism

It is also known as static polymorphism in Java. In this type, method call is made at compile time.

Compile type polymorphism is achieved through the concept of method overloading and operator overloading. However operator overloading is not supported in Java.

Method overloading can be defined as overloading of methods having same name i.e. when a class consist of multiple methods having same name but differs in the number, types, parameters and the return type of methods.

Java gives the flexibility to the user to create as many methods of same as long as it can be differentiate between them by the type and number of parameters.

Method overloading is explained in detail below.

Runtime Polymorphism

In Java, runtime polymorphism is also referred as Dynamic Binding or Dynamic Method Dispatch. In this process, at runtime we can call to an overridden method to process dynamically rather at compile time.

To implement the runtime polymorphism we us method overridden.

Method overridden happens when the child or subclass has a method with same definition as the parent or superclass, then that function overrides the function in the superclass.

In this process, a reference variable of a superclass is used to called an overridden method.

Q15) Write about dynamic binding?

A15) The method to be called is not determined by the compiler in dynamic binding. Dynamic binding is exemplified through overriding. Both the parent and child classes have the same approach for overriding.

Dynamic binding occurs when the type of an object is determined at run-time.

Example

Class Animal{ 

Void eat(){System.out.println("animal is eating...");} 

} 

Class Dog extends Animal{ 

Void eat(){System.out.println("dog is eating...");} 

Public static void main(String args[]){ 

Animal a=new Dog(); 

a.eat(); 

} 

} 

Output

Output:dog is eating…

Because the instance of Dog is also an instance of Animal, the compiler cannot detect the object type in the previous example. As a result, the compiler only knows its basic type.

Q16) Define method overriding?

A16) In Java, method overriding is a technique through which a subclass or derived class can provide its own version of a method whose implementation is given by one its super class.

By doing this a subclass is defining a method having same name, same parameter, and same return type similar to method in the superclass. Then the method in the subclass is said to override the method in the superclass.

The concept of runtime polymorphism in Java can be implemented using Method overriding.

The next important question is which class method will be executed. So the answer is

1. When an object of a parent class makes a call to method, then the parent class method will be executed.
2. When an object of a child class makes a call to method, then the child class method will be executed.

Hence, the type of object used for referring determines which version of the method will be executed in the case of overridden method.

A simple example showing how overridden method are created and called.

//Parent class declaration

Class Parent{

Void display()  //method defined in parent class

{

System.out.println(Method of parent class”);

}

}

//Child class declaration

Class Child extends Parent{

Void display() //child class method overrides parent class method

{

System.out.println(Method of child class”);

}

}

Class Demo{

Public static void main(String[] args)

{

Parent p = new Parent();  // object of parent class

Parent o = new Child(); // object of child class

p.display();                 //reference made to parent class method by object p

o.display();               //reference made to child class method by object o

}

}

Output

Method of parent class

Method of child class

Q17) What are the rules of method overriding?

A17) Rules for Method Overriding

1. Overridden method must have same name and parameters.
2. Method which is declared as final cannot be overridden.
3. Static methods cannot be used to override.
4. Overridden is not possible in private method.
5. The return type of overriding method must be same.
6. Constructors cannot be override.
7. IS-A relationship must be fulfill in method overridden technique.

Q18) Explain abstract classes with any example?

A18) Abstraction, according to the definition, is the ability to deal with ideas rather than occurrences. When it comes to email, for example, intricate information like what happens when you send an e-mail and the protocol your e-mail server utilizes are hidden from the user. As a result, all you have to do to send an email is input the content, include the recipient's address, and click send.

Similarly, in Object-oriented programming, abstraction is the process of hiding implementation details from the user and simply providing functionality. To put it another way, the user will be given knowledge about what the object does rather than how it does it.

Abstract classes and interfaces are used in Java to achieve abstraction.

Abstract Classes

Abstract class is a type of class that has the abstract keyword in its declaration.

●      Abstract classes may or may not contain abstract methods (public void get();).

●      However, a class must be designated abstract if it has at least one abstract method.

●      A class that has been declared abstract cannot be instantiated.

●      You must inherit an abstract class from another class and supply implementations for the abstract methods in it in order to use it.

●      You must supply implementations for all abstract methods in an abstract class if you inherit it.

Example

This section shows you how to use the abstract class. Simply use the abstract keyword before the class keyword in the class definition to create an abstract class.

/* File name : Employee.java */

Public abstract class Employee {

Private String name;

Private String address;

Private int number;

Public Employee(String name, String address, int number) {

System.out.println("Constructing an Employee");

This.name = name;

This.address = address;

This.number = number;

}

Public double computePay() {

System.out.println("Inside Employee computePay");

Return 0.0;

}

Public void mailCheck() {

System.out.println("Mailing a check to " + this.name + " " + this.address);

}

Public String toString() {

Return name + " " + address + " " + number;

}

Public String getName() {

Return name;

}

Public String getAddress() {

Return address;

}

Public void setAddress(String newAddress) {

Address = newAddress;

}

Public int getNumber() {

Return number;

}

}

Except for abstract methods, the Employee class is identical to a regular Java class. The class has three fields, seven methods, and one function Object() { [native code] }, but it is now abstract.

You may now attempt to instantiate the Employee class as follows:

/* File name : AbstractDemo.java */

Public class AbstractDemo {

Public static void main(String [] args) {

/* Following is not allowed and would raise error */

Employee e = new Employee("George W.", "Houston, TX", 43);

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

e.mailCheck();

}

}

When you compile the above class, it gives you the following error −

Employee.java:46: Employee is abstract; cannot be instantiated

Employee e = new Employee("George W.", "Houston, TX", 43);

^

1 error

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) Describe Abstract Methods?

A20) If you want a class to contain a method but the actual implementation of that method to be determined by child classes, designate the method as an abstract in the parent class.

●      To declare a method abstract, use the abstract keyword.

●      In the method declaration, the abstract keyword must come before the method name.

●      There is no method body in an abstract method, only a method signature.

●      An abstract method will have a semicolon (;) at the end instead of curly braces.

The abstract technique is demonstrated in the following example.

Example

Public abstract class Employee {

Private String name;

Private String address;

Private int number;

Public abstract double computePay();

// Remainder of class definition

}

Declaring a method abstract has two ramifications.

●      It must be specified as abstract in the class that contains it.

●      Any class that inherits the current class must either override or declare the abstract method.

Note that a descendant class must implement the abstract method at some point; otherwise, you'll wind up with a hierarchy of abstract classes that can't be created.

If the Salary class derives from the Employee class, the computePay() method should be implemented as shown below.

/* File name : Salary.java */

Public class Salary extends Employee {

Private double salary; // Annual salary

Public double computePay() {

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

Return salary/52;

}

// Remainder of class definition

}

Q21) Why is multiple inheritance not supported in java?

A21) Multiple inheritance is not supported in Java to decrease complexity and simplify the language.

Consider the following scenario: A, B, and C are three different classes. The A and B classes are inherited by the C class. If A and B classes have the same method and you call it from a child class object, the method of A or B will be ambiguous.

Because compile-time errors are preferable to runtime errors, if you inherit two classes, Java generates a compile-time error. There will be a build time error whether you use the same approach or a different one.

Example

Class A{ 

Void msg(){System.out.println("Hello");} 

} 

Class B{ 

Void msg(){System.out.println("Welcome");} 

} 

Class C extends A,B{//suppose if it were 

Public static void main(String args[]){ 

C obj=new C(); 

Obj.msg();//Now which msg() method would be invoked? 

} 

} 

Output

Compile Time Error