Polymorphism concepts

1. Polymorphism in java

2. Polymorphism:-
It is the ability of an object to take on many forms.
In java language, polymorphism is essentially considered into two versions.
• Compile time polymorphism (method overloading/ static binding )
• Runtime polymorphism (method overriding/ dynamic binding )

3. Compile time polymorphism (method overloading):-
This is used to write the program in such a way, that flow of control is decided in compile
time itself. It is achieved using method overloading(implicitly).
In method overloading, an object can have two or more methods with same name but with
their method parameters different. These parameters may be different on two bases:
 Parameter type: Type of method parameters can be different.
public void num(double a, double b){..}
public void num (float a, float b){..}
public void num (int a, int b){..}
 Parameter count: Functions accepting different number of parameters.
EmployeeFactory.create(String firstName, String lastName){...}
EmployeeFactory.create(Integer id, String firstName, String lastName){...}
o Both methods have same name “create” but actual method invoked will be
based on parameters passed in program.

4. Runtime polymorphism (method overriding):-
Feature that allows a subclass or child class to provide a specific implementation of
a method that is already provided by one of its super classes or parent classes.
public class students {
public void study(){
System.out.println(“OOP"); }
}
class Ghazanfar extends students{
public void study(){
System.out.println(“OOP,Discrete"); }
}
class Rafah extends students{
public void study(){
System.out.println(“Report writing"); }
}
Now which study() method will be called?

5. Depends on type of actual instance created on runtime.
public class Demo
{
public static void main(String[] args) {
students a1 = new Ghazanfar();
a1.study();
students a2 = new rafah();
a2.study();
}
}

6. ABSTRACTION:-
 Abstraction means hiding the implementation details and showing only the
functionality.
 Abstraction is the process of abstraction in Java is used to hide certain details and
only show the essential features of the object.
Abstract keyword
 Abstract keyword is used to declare the method or class as abstract.
 You have to place the abstract keyword before the method or class name in the
method declaration.
 An abstract method contains a method signature, but no method body.
 Instead of curly braces an abstract method will have a semi colon ( ; ) at the end.

7. Abstract Class :
A class which contains the abstract keyword in its declaration is known as abstract class.
Syntax:
abstract class <class-name>{}
 An abstract class is something which is incomplete and you cannot create instance of
abstract class.
 If you want to use it you need to make it complete or concrete by extending it.
 A class is called concrete if it does not contain any abstract method and implements
all abstract method inherited from abstract class or interface it has implemented or
extended.

8. Abstract Methods:
 If we want a class to contain a particular method but we want the actual
implementation of that method to be determined by child classes, we can declare
the method in the parent class as abstract.
 Abstract methods do not have body, they just have prototype(method signature).
 Abstract methods must be implemented in the child class (if the class is not
abstract) otherwise program will throw compilation error
Syntax:
abstract return type method name ();
 An abstract method in Java doesn't have body, it’s just a declaration. In order to
use abstract method you need to override that method in Subclass.
 A method that is declare as abstract and does not have implementation is known
as abstract method.
If you define abstract method than class must be abstract.

9. package program;
//abstract class
abstract class Sum{
//abstract methods
public abstract int SumOfTwo(int n1, int n2);
public abstract int SumOfThree(int n1, int n2, int n3);
//Regular method
public void disp(){ System.out.println("Method of class Sum");
} }
class AbstractDemo extends Sum{
public int SumOfTwo(int num1, int num2){
return num1+num2;
}
public int SumOfThree(int num1, int num2, int num3){
return num1+num2+num3;
}
public static void main(String args[]){
AbstractDemo obj = new AbstractDemo();
System.out.println(obj.SumOfTwo(3, 7));
System.out.println(obj.SumOfThree(4, 3, 19));
obj.disp();
} }

10. package presentation;
//Interface
interface Multiply{
//abstract methods
public abstract int multiplyTwo(int n1, int n2);
int multiplyThree(int n1, int n2, int n3);
}
class AbstractDemo2 implements Multiply{
public int multiplyTwo(int num1, int num2){
return num1*num2; }
public int multiplyThree(int num1, int num2, int num3){
return num1*num2*num3; }
public static void main(String args[]){
AbstractDemo2 obj = new AbstractDemo2();
System.out.println(obj.multiplyTwo(3, 7));
System.out.println(obj.multiplyThree(1, 9, 0)); } }