{"id":601,"date":"2021-06-19T07:08:06","date_gmt":"2021-06-19T07:08:06","guid":{"rendered":"https:\/\/rahulshettyacademy.com\/blog\/index.php\/2021\/06\/19\/oops-in-java-polymorphism-access-modifiers-super-this-keywords\/"},"modified":"2021-06-19T07:08:06","modified_gmt":"2021-06-19T07:08:06","slug":"oops-in-java-polymorphism-access-modifiers-super-this-keywords","status":"publish","type":"post","link":"https:\/\/rahulshettyacademy.com\/blog\/index.php\/2021\/06\/19\/oops-in-java-polymorphism-access-modifiers-super-this-keywords\/","title":{"rendered":"OOPs in Java: Polymorphism, Access Modifiers, super & this keywords"},"content":{"rendered":"

<\/p>\n

\n

\n

\n

\n

<\/div>\n

\n

\n

<\/div>\n<\/div>\n

<\/div>\n

\n

<\/div>\n

\n

\n

Table Of Contents<\/div>\n<\/p><\/div>\n<\/div>\n<\/div>\n

\n

\n

<\/div>\n

\n

\n

\n

\n

0.1<\/span><\/div>\n

Polymorphism<\/a><\/div>\n

\n

0.1.1<\/span><\/div>\n

What is polymorphism in JAVA? How is that achieved?<\/a><\/div>\n

\n

0.1.2<\/span><\/div>\n

What is method overloading? Explain with\u00a0examples. <\/a><\/div>\n

\n

0.1.3<\/span><\/div>\n

Why is method overloading also called compile time polymorphism?<\/a><\/div>\n

\n

0.1.4<\/span><\/div>\n

What is method overriding? Explain with\u00a0examples. <\/a><\/div>\n

\n

0.1.5<\/span><\/div>\n

What is Dynamic Method Invocation in JAVA? Or, Why method overriding is known as runtime polymorphism?<\/a><\/div>\n

\n

0.1.6<\/span><\/div>\n

How does polymorphism work together with overloading and overriding?<\/a><\/div>\n

\n

0.1.7<\/span><\/div>\n

What is reference variable casting?<\/a><\/div>\n

\n

0.1.8<\/span><\/div>\n

Upcasting Example<\/a><\/div>\n

\n

0.1.9<\/span><\/div>\n

Downcasting Example<\/a><\/div>\n

\n

0.1.10<\/span><\/div>\n

Rules for method overloading and overriding<\/a><\/div>\n

\n

0.1.11<\/span><\/div>\n

What are the different access modifiers are there in JAVA?\u00a0<\/a><\/div>\n

\n

0.1.12<\/span><\/div>\n

What is the usage of \u2018super\u2019 and \u2018this\u2019 keywords?<\/a><\/div>\n

\n

0.1.13<\/span><\/div>\n

<\/a><\/div>\n

\n

0.1.14<\/span><\/div>\n

Usage of Java super Keyword<\/a><\/div>\n

\n

0.1.15<\/span><\/div>\n

Example 1: Access parent class instance variable<\/a><\/div>\n

\n

0.1.16<\/span><\/div>\n

Example 2: Access parent class constructor<\/a><\/div>\n

\n

0.1.17<\/span><\/div>\n

Example 3: Access parent class method<\/a><\/div>\n

\n

0.2<\/span><\/div>\n

Usage of java this Keyword<\/a><\/div>\n

\n

0.2.1<\/span><\/div>\n

Example 1: Access current class instance variable<\/a><\/div>\n

\n

0.2.2<\/span><\/div>\n

Example 2: Access current class constructor<\/a><\/div>\n

\n

0.2.3<\/span><\/div>\n

Example 3: Access current class method<\/a><\/div>\n

\n

0.2.4<\/span><\/div>\n

Example 4: pass current class object reference to a method<\/a><\/div>\n<\/div>\n

\n

<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n

\n

Polymorphism<\/b><\/h3>\n
What is polymorphism in JAVA? How is that achieved?<\/b><\/h5>\n
In JAVA, if any object passes more than one IS A relation, then the object is said to be polymorphic. Any object apart from type Object is polymorphic because it passes at least 2 IS A relations, 1 for its own type and 2 for class Object.<\/p>\n
\n

\n<\/ins>\n<\/div>\n
Remember that the only way to access an object is through a reference variable, and there are a few key things to remember about references:<\/p>\n
\u25a0 A reference variable can be of only one type, and once declared, that type can never be changed (although the object it references can change).<\/p>\n
\u25a0 A reference is a variable, so it can be reassigned to other objects, (unless the reference is declared final).<\/p>\n
\u25a0 A reference variable’s type determines the methods that can be invoked on the object the variable is referencing.<\/p>\n
\u25a0 A reference variable can refer to any object of the same type as the declared reference, or\u2014this is the big one\u2014it can refer to any <\/b>subtype <\/i>of the declared type!<\/b><\/p>\n
\u25a0 A reference variable can be declared as a class type or an interface type. If the variable is declared as an interface type, it can reference any object of any class that implements <\/i>the interface.<\/p>\n
In JAVA, polymorphism is achieved via Method Overloading (Compile Time Polymorphism) & Method Overriding (Runtime Polymorphism).<\/p>\n
What is method overloading? Explain with\u00a0<\/b>examples. <\/b><\/h5>\n
Overloaded methods let you reuse the same method name in a class, but with different arguments (and optionally, a different return type).<\/p>\n
A method can be overloaded within the same class or in the inherited class.<\/p>\n
An important point to remember: The list of arguments is the deciding factor as to which overloaded method will be invoked.<\/p>\n
Example 1 : Method overload within same class<\/strong><\/p>\n<\/div>\n
\n
<\/div>\n
\n
\n
class Add{<\/p>\n
static int add(int a,int b){return a+b;}<\/p>\n
static int add(int a,int b,int c){return a+b+c;}<\/p>\n
}<\/p>\n
class TestOverloading{<\/p>\n
public static void main(String[] args){<\/p>\n
System.out.println(Add.add(11,11));<\/p>\n
System.out.println(Add.add(11,11,11));<\/p>\n
}<\/p>\n
}<\/p>\n
Output<\/span><\/p>\n
22<\/span><\/p>\n
33<\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Example 2 : Method overload between parent & child class<\/strong><\/p>\n<\/div>\n
\n
<\/div>\n
\n
\n\n\n\n
\n
class Base<\/p>\n
{<\/p>\n
public int f(int i)<\/p>\n
{<\/p>\n
System.out.print(“f (int): “);<\/p>\n
return i+3;<\/p>\n
}<\/p>\n
}<\/p>\n
class Derived extends Base<\/p>\n
{<\/p>\n
public double f(double i)<\/p>\n
{<\/p>\n
System.out.print(“f (double) : “);<\/p>\n
return i + 3.3;<\/p>\n
}<\/p>\n
}<\/p>\n
class myprogram3<\/p>\n
{<\/p>\n
public static void main(String args[])<\/p>\n
{<\/p>\n
Derived obj = new Derived();<\/p>\n
System.out.println(obj.f(3));<\/p>\n
System.out.println(obj.f(3.3));<\/p>\n
}<\/p>\n
}<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Output<\/span><\/p>\n
f (int): 6<\/span><\/p>\n
f (double): 6.6<\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Why is method overloading also called compile time polymorphism?<\/b><\/h5>\n
Let\u2019s review the below piece of code.<\/p>\n<\/div>\n
\n
<\/div>\n
\n
\n
class Animal {<\/p>\n
}<\/p>\n
class Horse extends Animal {<\/p>\n
}<\/p>\n
class UseAnimal {<\/p>\n
public void doSomething(Animal a)<\/p>\n
{<\/p>\n
System.out.println(“In Animal”);<\/p>\n
}<\/p>\n
public void doSomething(Horse h) \/\/doSomething is overloaded<\/p>\n
{<\/p>\n
System.out.println(“In horse”);<\/p>\n
}<\/p>\n
}<\/p>\n
public class Test {<\/p>\n
public static void main(String[] args) {<\/p>\n
UseAnimal UA1 = new UseAnimal();<\/p>\n
Animal a1 = new Horse();<\/p>\n
Horse h1 = new Horse();<\/p>\n
UA1.doSomething(a1);<\/p>\n
}<\/p>\n
}<\/p>\n
\u00a0 \u00a0 \u00a0Output: In Animal<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Explanation: <\/strong><\/p>\n
<\/strong>In the above example, we have created a Horse object using the Animal reference variable. When we pass that reference to the doSomething() method, because a1 refers to a Horse object, it is tempting to say it will invoke the doSomething() method which takes a Horse object as an argument; but that is not true. It will invoke the doSomething() which takes Animal object, because Method Overloading does happen on compile time.<\/p>\n
What is method overriding? Explain with\u00a0<\/b>examples. <\/b><\/h5>\n
Whenever a class inherits methods from a superclass, we can override the method. In Method Overriding, we have a huge benefit of implementing the method specific to the child class.<\/p>\n
But if a method is declared as Final in super class, that cannot be overridden.<\/p>\n
Example \u2013<\/strong><\/p>\n<\/div>\n
\n
<\/div>\n
\n
\n
public class Animal {<\/p>\n
public void eat() {<\/p>\n
System.out.println(“Generic Animal Eating Generically”);<\/p>\n
}<\/p>\n
}<\/p>\n
class Horse extends Animal {<\/p>\n
public void eat() {<\/p>\n
System.out.println(“Horse eating hay, oats and horse treats”);<\/p>\n
}<\/p>\n
}<\/p>\n
public class Test{<\/p>\n
public static void main(String[] args) {<\/p>\n
Horse h1 = new Horse();<\/p>\n
\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 h1.eat();<\/p>\n
}<\/p>\n
}<\/p>\n
Output<\/span><\/p>\n
Horse eating hay, oats and horse treats<\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Explanation-<\/strong><\/p>\n
In the above program, eat() method is overridden in Horse class. So when we call the eat() method on a horse object, the implementation of eat() in Horse class is executed.<\/p>\n
What is Dynamic Method Invocation in JAVA? Or, Why method overriding is known as runtime polymorphism?<\/b><\/h5>\n
Dynamic Method Invocation is the process of determining which version of an overridden method to use based on the actual object (not the reference type) at runtime. That is why method overriding is also referred to as runtime polymorphism.<\/p>\n
In the below example, though the reference type is of Animal, the actual object is Horse type object. So, on invoking the eat() method on reference type b, Horse specific eat() method will be invoked, not the eat() method from Animal.<\/p>\n<\/div>\n
\n
<\/div>\n
\n
\n
class Animal {<\/p>\n
public void eat()<\/p>\n
{<\/p>\n
System.out.println(“Animal eating”);<\/p>\n
}<\/p>\n
}<\/p>\n
class Horse extends Animal{<\/p>\n
public void eat()<\/p>\n
{<\/p>\n
System.out.println(“Horse eating”);<\/p>\n
}<\/p>\n
}<\/p>\n
public class Test {<\/p>\n
public static void main(String[] args) {<\/p>\n
Animal a = new Animal ();<\/p>\n
a.eat();<\/p>\n
Animal b = new Horse();<\/p>\n
b.eat();<\/p>\n
Horse h = new Horse();<\/p>\n
h.eat();<\/p>\n
}<\/p>\n
}<\/p>\n
Output<\/span><\/p>\n
Animal eating<\/span><\/p>\n
Horse eating<\/span><\/p>\n
Horse eating<\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
How does polymorphism work together with overloading and overriding?<\/b><\/h5>\n
How does polymorphism work with overloaded methods? From what we just looked at, it doesn’t appear that polymorphism matters when a method is overloaded. If you pass an Animal reference, the overloaded method that takes an Animal will be invoked, even if the actual object passed is a Horse. Once the Horse masquerading as Animal gets into the method, however, the Horse object is still a Horse despite being passed into a method expecting an Animal. So it’s true that polymorphism doesn’t determine which overloaded version is called; polymorphism does come into play when the decision is about which overridden version of a method is called. But sometimes, a method is both overloaded and overridden. Imagine the Animal and Horse classes look like this:<\/p>\n<\/div>\n
\n
<\/div>\n
\n
\n
public class Animal {<\/p>\n
public void eat() {<\/p>\n
System.out.println(“Generic Animal Eating Generically”);<\/p>\n
}<\/p>\n
}<\/p>\n
public class Horse extends Animal {<\/p>\n
public void eat() {<\/p>\n
System.out.println(“Horse eating hay “);<\/p>\n
}<\/p>\n
public void eat(String s) {<\/p>\n
System.out.println(“Horse eating ” + s);<\/p>\n
}<\/p>\n
}<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Notice that the Horse class has both overloaded and overridden the eat() method.<\/p>\n
$\"\"$ <\/p>\n
What is reference variable casting?<\/b><\/h5>\n
Reference variable casting is assigning a superclass (or Interface) variable to a subclass object or vice versa. Casting is of 2 types, Upcasting <\/strong><\/em>& Downcasting<\/strong><\/em>.<\/p>\n
Upcasting Example<\/b><\/h5>\n<\/div>\n
\n
<\/div>\n
\n
\n
class Animal{<\/p>\n
public void eat()<\/p>\n
{<\/p>\n
System.out.println(“Animal eating”);<\/p>\n
}<\/p>\n
}<\/p>\n
class Dog extends Animal{<\/p>\n
public void eat()<\/p>\n
{<\/p>\n
System.out.println(“Dog eating”);<\/p>\n
}<\/p>\n
public void makeNoise()<\/p>\n
{<\/p>\n
System.out.println(“Dog barking”);<\/p>\n
}<\/p>\n
}<\/p>\n
public class Upcasting {<\/p>\n
public static void main(String[] args) {<\/p>\n
Animal a = new Dog();\/\/Up casting<\/p>\n
a.eat(); \/<\/p>\n
Compiles fine because compiler sees that Animal class has eat() method, does not complain.But when runs, takes Dog class eat() method\/<\/p>\n
((Dog)a).makeNoise();<\/p>\n
\/<\/p>\n
\u00a0 Does not compile until we tell the compiler that Object a is really a Dog’s object. So we need to cast it to Dog. \/<\/p>\n
}<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Downcasting Example<\/b><\/h5>\n<\/div>\n
\n
<\/div>\n
\n
\n
class Animal{<\/p>\n
public void eat()<\/p>\n
{<\/p>\n
System.out.println(“Animal eating”);<\/p>\n
}<\/p>\n
}<\/p>\n
class Dog extends Animal{<\/p>\n
public void eat()<\/p>\n
{<\/p>\n
System.out.println(“Dog eating”);<\/p>\n
}<\/p>\n
public void makeNoise()<\/p>\n
{<\/p>\n
System.out.println(“Dog barking”);<\/p>\n
}<\/p>\n
}<\/p>\n
<\/p>\n
public class Downcasting {<\/p>\n
public static void main(String[] args) {<\/p>\n
Animal a = new Animal<\/p>\n
((Dog)a).makeNoise(); \/\/Downcasting<\/p>\n
\/<\/p>\n
\u00a0 * Does not compile until we tell the compiler that Object a is really a Dog’s object. So we need to cast it to * Dog.*\/<\/p>\n
}<\/p>\n
}<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
The difference in the above two examples is the actual objects which are created. In the first example, we have created a Dog object, for which calling the makeNoise() method is absolutely fine. Because, the makeNoise() method overrides and JVM looks for the original object (not the reference type) while working with Overriding. So when it finds that it\u2019s really a Dog object, the output is provided.<\/p>\n
But in the second example, we are creating an Animal object. Then we have down casted to Dog type. This down casting is fine until the program is in compilation mode, because the compiler does not complain thinking that after downcast, \u2018a\u2019 becomes a Dog object. But while JVM runs the program, it finds that \u2018a\u2019 is never a Dog object and throws a classcast exception.<\/p>\n
To avoid this problem, we can use an instance of operator to make sure that \u2018a\u2019 is really a dog object. Here is the improved version of the code:<\/p>\n<\/div>\n
\n
<\/div>\n
\n
\n
class Animal{<\/p>\n
public void eat()<\/p>\n
{<\/p>\n
System.out.println(“Animal eating”);<\/p>\n
}<\/p>\n
}<\/p>\n
class Dog extends Animal{<\/p>\n
public void eat()<\/p>\n
{<\/p>\n
System.out.println(“Dog eating”);<\/p>\n
}<\/p>\n
public void makeNoise()<\/p>\n
{<\/p>\n
System.out.println(“Dog barking”);<\/p>\n
}<\/p>\n
}<\/p>\n
<\/p>\n
public class ObjType {<\/p>\n
public static void main(String[] args) {<\/p>\n
Animal [] a ={new Animal, new Dog, new Animal}<\/p>\n
For(Animal a1:a)<\/p>\n
{<\/p>\n
if(a1 instanceof Dog)<\/p>\n
((Dog)a1).makeNoise();<\/p>\n
}<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Rules for method overloading and overriding<\/b><\/h5>\n
$\"\"$ <\/b><\/p>\n
What are the different access modifiers are there in JAVA?\u00a0<\/b><\/h5>\n
The access modifiers in Java specifies the accessibility or scope of a field, method, constructor, or class. We can change the access level of fields, constructors, methods, and class by applying the access modifier on it.<\/p>\n
Let\u2019s understand the access level of each access modifier using a single table.<\/p>\n
$\"\"$ <\/p>\n
What is the usage of \u2018super\u2019 and \u2018this\u2019 keywords?<\/b><\/h5>\n
<\/b><\/h5>\n
The super keyword in java is used to refer immediate parent class object. Whenever we create the object of a subclass, an instance of the parent class is created implicitly and members of the parent instance can be accessed via super keyword.<\/p>\n
Usage of Java super Keyword<\/b><\/h5>\n
\n
super is used to refer to the immediate parent class instance.<\/li>\n
variable.super is used to invoke immediate parent class.<\/li>\n
constructor.super is used to invoke immediate parent class method.<\/li>\n<\/ul>\n
Example 1<\/b>: Access parent class instance variable<\/h5>\n<\/div>\n
\n
<\/div>\n
\n
\n
class Vehicle{<\/p>\n
int speed=50;<\/p>\n
}<\/p>\n
class Bike extends Vehicle{<\/p>\n
int speed=100;<\/p>\n
void display(){<\/p>\n
System.out.println(super.speed);<\/p>\n
}<\/p>\n
public static void main(String args[]){<\/p>\n
Bike b=new Bike();<\/p>\n
b.display();<\/p>\n
}<\/p>\n
}<\/p>\n
Output<\/span><\/p>\n
50 \/\/ Superclass instance variable is accessed in child class using super keyword.<\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Example 2<\/b>: Access parent class constructor<\/h5>\n<\/div>\n
\n
<\/div>\n
\n
\n
class Vehicle{<\/p>\n
Vehicle(){System.out.println(“Vehicle is created”);}<\/p>\n
}<\/p>\n
class Bike extends Vehicle{<\/p>\n
Bike(){<\/p>\n
super();\/\/will invoke parent class constructor<\/p>\n
System.out.println(“Bike is created”);<\/p>\n
}<\/p>\n
public static void main(String args[]){<\/p>\n
Bike b=new Bike();<\/p>\n
}<\/p>\n
}<\/p>\n
Output<\/span><\/p>\n
Vehicle is created<\/span><\/p>\n
Bike is created<\/span><\/p>\n
*** This call to super class constructor is implicit, meaning if we do not include the call; still, it will execute super class constructor before it executes the current class\u2019s constructor.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Example 3<\/b>: Access parent class method<\/h5>\n<\/div>\n
\n
<\/div>\n
\n
\n
class Person{<\/p>\n
void message(){System.out.println(“welcome”);}<\/p>\n
}<\/p>\n
class Student extends Person{<\/p>\n
void message(){System.out.println(“welcome to java”);}<\/p>\n
void display(){<\/p>\n
message();\/\/will invoke current class message() method<\/p>\n
super.message();\/\/will invoke parent class message() method<\/p>\n
}<\/p>\n
public static void main(String args[]){<\/p>\n
Student s=new Student();<\/p>\n
s.display();<\/p>\n
}<\/p>\n
}<\/p>\n
Output<\/span><\/p>\n
welcome to java<\/span><\/p>\n
welcome<\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Usage of java this Keyword<\/b><\/h3>\n
\n
this is used to refer to the current class instance variable.<\/li>\n
this is used to refer to the current class constructor.<\/li>\n
this is used to refer to the current class method.<\/li>\n
pass current class object reference to a method<\/li>\n<\/ul>\n
Example 1<\/b>: Access current class instance variable<\/h5>\n<\/div>\n
\n
<\/div>\n
\n
\n
private String javaFAQ;<\/p>\n
void methodName(String javaFAQ) {<\/p>\n
this.javaFAQ = javaFAQ; \/\/this refers to instance variable javaFAQ<\/p>\n
}<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Example 2<\/b>: Access current class constructor<\/h5>\n<\/div>\n
\n
<\/div>\n
\n
\n
public class Keywords {<\/p>\n
public Keywords(String s)<\/p>\n
{<\/p>\n
System.out.println(“String type args”);<\/p>\n
}<\/p>\n
public Keywords(int i)<\/p>\n
{<\/p>\n
this(“str”);\/\/ the second constructor is calling the first one, using proper argument.<\/p>\n
System.out.println(“int type args”);<\/p>\n
}<\/p>\n
public static void main(String[] args) {<\/p>\n
new Keywords(5);<\/p>\n
}<\/p>\n
}<\/p>\n
Output<\/span><\/p>\n
String type args<\/span><\/p>\n
int type args<\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Example 3:<\/b> Access current class method<\/h5>\n<\/div>\n
\n
<\/div>\n
\n
\n
public class Keywords {<\/p>\n
public void m()<\/p>\n
{<\/p>\n
System.out.println(“In first method”);<\/p>\n
}<\/p>\n
public void n()<\/p>\n
{<\/p>\n
this.m(); \/\/It calls m()<\/p>\n
}<\/p>\n
public void p()<\/p>\n
{<\/p>\n
this.n();\/\/It calls n()<\/p>\n
}<\/p>\n
public static void main(String[] args) {<\/p>\n
\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 (new Keywords()).p();\/\/Final call to m(), sequentially towards top.<\/p>\n
}<\/p>\n
}<\/p>\n
Output<\/span><\/p>\n
In first method<\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
Example 4<\/b>: pass current class object reference to a method<\/h5>\n<\/div>\n
\n
<\/div>\n
\n
\n
public class Keywords {<\/p>\n
public void m(Keywords ks)<\/p>\n
{<\/p>\n
System.out.println(“Passing object reference”);<\/p>\n
}<\/p>\n
public void p()<\/p>\n
{<\/p>\n
\u00a0 this.m(this); \/\/Passing current class object to method using this keyword<\/p>\n
}<\/p>\n
public static void main(String[] args) {<\/p>\n
(new Keywords()).p();<\/p>\n
}<\/p>\n
}<\/p>\n
Output<\/span><\/p>\n
Passing object reference<\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
With this article, we have Java OOPs series. Let me know your thoughts and feedbacks in the comment section.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
<\/div>\n<\/section>\n
<\/body><\/html><\/p>\n","protected":false},"excerpt":{"rendered":"
Table Of Contents 0.1 Polymorphism 0.1.1 What is polymorphism in JAVA? How is that achieved? 0.1.2 What is method overloading? Explain with\u00a0examples. 0.1.3 Why is method overloading also called compile time polymorphism? 0.1.4 What is method overriding? Explain with\u00a0examples. 0.1.5 What is Dynamic Method Invocation in JAVA? Or, Why method overriding is known as runtime […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5],"tags":[],"class_list":["post-601","post","type-post","status-publish","format-standard","hentry","category-java","post-wrapper","thrv_wrapper"],"_links":{"self":[{"href":"https:\/\/rahulshettyacademy.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/601","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/rahulshettyacademy.com\/blog\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/rahulshettyacademy.com\/blog\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/rahulshettyacademy.com\/blog\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/rahulshettyacademy.com\/blog\/index.php\/wp-json\/wp\/v2\/comments?post=601"}],"version-history":[{"count":0,"href":"https:\/\/rahulshettyacademy.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/601\/revisions"}],"wp:attachment":[{"href":"https:\/\/rahulshettyacademy.com\/blog\/index.php\/wp-json\/wp\/v2\/media?parent=601"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/rahulshettyacademy.com\/blog\/index.php\/wp-json\/wp\/v2\/categories?post=601"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/rahulshettyacademy.com\/blog\/index.php\/wp-json\/wp\/v2\/tags?post=601"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}