Polymorphism:

Polymorphism is the ability of an object to take on many forms. The most common use of
polymorphism in OOP occurs when a parent class reference is used to refer to a child class
object.Polymorphism is the capability of a method to do different things based on the object that it
is acting upon. In other words, polymorphism allows you define one interface and have multiple
implementations.
There are two types of polymorphism in java: compile time polymorphism(static binding) and
runtime polymorphism(dynamic binding). We can perform polymorphism in java by method
overloading and method overriding.

Compile time Polymorphism (or Static polymorphism):

Polymorphism that is resolved during compiler time is known as static polymorphism. Method
overloading is an example of compile time polymorphism.
Method Overloading: This allows us to have more than one method having the same name, if
the parameters of methods are different in number, sequence and data types of parameters.
Example:
class SimpleCalculator
{
int add(int a, int b)
{
return a+b;
}
int add(int a, int b, int c)
{
return a+b+c;
}
}
public class Demo
{
public static void main(String args[])
{
SimpleCalculator obj = new SimpleCalculator();
System.out.println(obj.add(10, 20));
System.out.println(obj.add(10, 20, 30));
}
}

Output:
30
60
Runtime Polymorphism (or Dynamic polymorphism)
It is also known as Dynamic Method Dispatch. Dynamic polymorphism is a process in which a
call to an overridden method is resolved at runtime, thats why it is called runtime
polymorphism.Method overriding is an example of Runtime polymorphism.
Method overriding:
Declaring a method in sub class which is already present in parent class is known as method
overriding. Overriding is done so that a child class can give its own implementation to a method
which is already provided by the parent class. In this case the method in parent class is called
overridden method and the method in child class is called overriding method.
Example:
class Human{
//Overridden method
public void eat()
{
System.out.println("Human is eating");
}
}
class Boy extends Human{
//Overriding method
public void eat(){
System.out.println("Boy is eating");
}
public static void main( String args[]) {
Boy obj = new Boy();
//This will call the child class version of eat()
obj.eat();
}
}
Output:
Boy is eating

Inheritance:
process by which one class acquires the properties(data members) and functionalities(methods) of
another class is called inheritance. The aim of inheritance is to provide the reusability of code so
that a class has to write only the unique features and rest of the common properties and
functionalities can be extended from the another class.
Child Class:
The class that extends the features of another class is known as child class, sub class or derived
class.
Parent Class:
The class whose properties and functionalities are used(inherited) by another class is known as
parent class, super class or Base class.
The main use of inheritance are,Code reuse and Code enhancement- built on what you have,
without altering the present functionality.
Syntax:
To inherit a class we use extends keyword. Here class XYZ is child class and class ABC is parent
class. The class XYZ is inheriting the properties and methods of ABC class.
class ABC
{
------------
------------
}
class XYZ extends ABC
{
-------------
-------------
}

Example:
In this example, we have a base class Teacher and a sub class PhysicsTeacher. Since class
PhysicsTeacher extends the designation and college properties and work() method from base class,
we need not to declare these properties and method in sub class.
Here we have collegeName, designation and work() method which are common to all the teachers
so we have declared them in the base class, this way the child classes like MathTeacher,
MusicTeacher and PhysicsTeacher do not need to write this code and can be used directly from
base class.

class Teacher {
String designation = "Teacher";
String collegeName = "PVB";
void does(){
System.out.println("Teaching");
}
}
public class PhysicsTeacher extends Teacher{
String mainSubject = "Physics";
public static void main(String args[]){
PhysicsTeacher obj = new PhysicsTeacher();
System.out.println(obj.collegeName);
System.out.println(obj.designation);
System.out.println(obj.mainSubject);
obj.does();
}
}
Output:
PVB
Teacher
Physics
Teaching

Types of inheritance
Single Inheritance: refers to a child and parent class relationship where a class extends the
another class.

Multilevel inheritance: refers to a child and parent

class relationship where a class extends the child class. For
example class C extends class B and class B extends class A.

Hierarchical inheritance:
refers to a child and parent class
relationship where more than
one classes extends the same class.
For example, classes B, C & D
extends the same class A.

Multiple Inheritance: refers to the

concept of one class extending more than one
classes, which means a child class has two
parent classes. For example class C extends both classes A and B. Java doesn’t support multiple
inheritance, read more about it here.

Hybrid inheritance: Combination of more than one types of inheritance in a single program.
For example class A & B extends class C and another class D extends class A then this is a hybrid
inheritance example because it is a combination of single and hierarchical inheritance.

Method Overloading:
Method Overloading is a feature that allows a class to have more than one method having the
same name, if their argument lists are different. It is similar to constructor overloading in Java,
that allows a class to have more than one constructor having different argument lists.
Rules for overloading:
1. Overloading can appear in the same class or a subclass
2. Overloaded methods MUST change its number of argument or its type.
When declaring two or more methods in same name complier differentiate them by its
arguments, so you cannot declare two methods with the same signature
3. Overloaded methods CAN have different return type.
The compiler does not consider return type when differentiating methods, so it is legal to
change return type of overloaded method
4. Overloaded methods CAN change the access modifier.
Similarly overloaded method can have different access modifiers also.
5. Overloaded methods CAN declare new or broader checked exceptions.

Example:
class DisplayOverloading
{
public void disp(char c)
{
System.out.println(c);
}
public void disp(char c, int num)
{
System.out.println(c + " "+num);
}
}
class Sample
{
public static void main(String args[])
{
DisplayOverloading obj = new DisplayOverloading();
obj.disp('a');
obj.disp('a',10);
}
}
Output:
a
a 10