Dynamic method dispatch example,Abstract class,Using Final key word usage

1. Dynamic Method Dispatch
Abstract Class
Using Final with inheritance

2. Dynamic method dispatch
• Dynamic method dispatch is one type of mechanism by which a call to an
overridden method is resolved at run time
• When an overridden method is called through the object of superclass
then Java determines which version of that method to execute, based
upon the type of the object being referred to at the time the call occurs,
hence determination is made at run time.
• Go through the example below

3. • /* * Dynamic Method Dispach */
class Class_A
{ void demo()
{ System.out.println("the class A method called"); }
}
class Class_B extends Class_A
{ void demo()
{ System.out.println("the class B method called"); }
}
public class inheritance
{ public static void main(String[] y)
{ Class_A a=new Class_A();
a.demo();
/*
* The below one is called upcasting
*/
Class_A b=new Class_B();
b.demo();
a=b;
a.demo();
}
}

4. Difference between Static binding and Dynamic
binding in java ?
• Static binding in Java occurs during compile time
• dynamic binding occurs during runtime.
• Overloaded methods are bonded using static binding
• overridden methods are bonded using dynamic binding at runtime.

5. Abstract classes
• If a class contain any abstract method then the class is declared as
abstract class.
• An abstract class is never instantiated.
• Although it does not provide 100% abstraction because it can also have
concrete method.
Syntax
• Abstract class <class_name>{}

6. Abstract method
• Method that are declared without any body within an abstract class is
known as abstract method.
• The method body will be defined by its subclass
Syntax
Abstract return_type method_name(arguments list);
/* * abstract class and method */
abstract class Demo_A
{ abstract void Demo();//abstract method }
class Demo_B extends Demo_A
{ void Demo()
{ System.out.println("hello"); }
}
public class Abstract_Demo
{ public static void main(String[] y)
{ Demo_B b=new Demo_B();
b.Demo();
}
}

7. Abstract class with Concrete methods
/* * abstract class and Concrete method */
abstract class Demo_A
{ abstract void Demo(); //abstract method
void demo_a() //concrete method
{ System.out.println("the method of abstract class concrete method"); }
}
class Demo_B extends Demo_A
{ void Demo()
{ System.out.println("hello"); }
}
public class Abstract_Demo
{ public static void main(String[] y)
{ Demo_B b=new Demo_B();
b.Demo();
b.demo_a();
//Demo_A a=new Demo_A();
//a.demo_a();
/* * try to remove the above comments to under the concept */
/* * we can create refference variable for abstract classes */
Demo_A a=new Demo_B();
a.Demo();
}
}

8. Final method
• A final method cannot be overridden
• Which means even though a sub class can call the final method of parent class without
any issues but it cannot override it
class Super
{ final void demo()
{ System.out.println("hello"); }
}
class Sub_ extends Super
{ /*void demo()
{
System.out.println("hello world");
}*/
void demo_1()
{ System.out.println("hello world"); }
}
class Demo
{ public static void main(String[] y)
{ Sub_ s=new Sub_();
s.demo();
}
}

9. Final class
• We cannot extend a final class prevent inheritance
final class Super
{ void demo()
{ System.out.println("hello"); }
}
class Sub_ extends Super
{ void demo_1()
{ System.out.println("hello world"); }
}
class Demo
{ public static void main(String[] y)
{ Sub_ s=new Sub_(); }
}