Dynamic method dispatch
Download as PPTX, PDF2 likes3,984 views
Dynamic method dispatch allows the determination of which version of an overridden method to execute at runtime based on the object's type. Abstract classes cannot be instantiated and can contain both abstract and concrete methods. Final methods and classes prevent inheritance and overriding.
![• /* * 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();
}
}](https://image.slidesharecdn.com/dynamicmethoddispatch-160530105332/85/Dynamic-method-dispatch-3-320.jpg)
![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();
}
}](https://image.slidesharecdn.com/dynamicmethoddispatch-160530105332/85/Dynamic-method-dispatch-6-320.jpg)
![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();
}
}](https://image.slidesharecdn.com/dynamicmethoddispatch-160530105332/85/Dynamic-method-dispatch-7-320.jpg)
![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();
}
}](https://image.slidesharecdn.com/dynamicmethoddispatch-160530105332/85/Dynamic-method-dispatch-8-320.jpg)
![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_(); }
}](https://image.slidesharecdn.com/dynamicmethoddispatch-160530105332/85/Dynamic-method-dispatch-9-320.jpg)
Dynamic method dispatch
- 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_(); } }