polymorphism,overloading and overiding seems to be the same thing for me

[Vishal Hegde]

hi guys i just read polymorphism,overloading and overridding i felt that their functionalities are almost same ..if there is any difference between these things plase let me know

[Vijitha Kumara]

Vishal Hegde wrote:i just read polymorphism,overloading and overridding i felt that their functionalities are almost same ..

Overloading & overriding are two different things. Overloaded methods are resolved at compile time whereas overriden methods are resolved at the run time depending on the actual object being referenced. When you override a method you can have the advantage of polymorphic behavior.

[Radi Hadzhiyski]

polymorphism is just a term for that you can have a lot of forms for something:

Example:

if you have the classes: SomethingMobil, Car, Ferrari, Renault, Toyota, Truck, SomeTruckMark, AnotherTruckMark and so on, you want to say probably, that a truck and a car are kinds of SomethingMobil, also Toyota is a kind of SomethingMobil, but Toyota is also a kind of Car and so on. So you have a lot of forms of SomethingMobil and that thing describes the term polymorphism.

override is way to describe this behavior:

You make:

class SomethingMobil {
 public int accelerate() {
  // from 0 to 100 km/h or mp/h for about 12 seconds
   return 12;
 }
}

class Car extends SomethingMobil {
 // here you habe override
 public int accelerate() {
  // assume that a car is faster
  return 10;
 }
}

class Toyota extends Car {
 // here you habe override
 public int accelerate() {
  // assume that a car of mark Toyota is faster
  return 8;
 }
}

// and so on. Then:

class TestOverrideMethods {

 public static void main (String[] args) {
  SomethingMobil mobilA = new SomethingMobil();
  SomethingMobil mobilB = new Car();
  SomethingMobil mobilC = new Toyota();
  // so this above is kind of polymorphism for SomethingMobil
  // you have a lot of forms of SomethingMobil: it can be a Car or some special kind of Car, or even a Truck
  // and with mobilA, mobilB and mobilC you define what form you want to use
  // All the mobil variables are kind of SomethingMobil, but mobilA has the general form SomethingMobil, the mobilB has the form Car and mobilC has the form Toyota and so on.
  // now when you use the method accelerate you become exactly the behavior for the form you want. That is the thing "polymorphism" and you have made it with use of overriden methods
 
  System.out.println(mobilA.accelerate());  // 12
  System.out.println(mobilB.accelerate());  // 10
  System.out.println(mobilC.accelerate());  // 8
  
 }
}

overloading is something else. It is just the way you can write the same methodname, but have a differend kind of parameters:

public void writeThing() {
 System.out.println("general"); // if i dont have any parameters i want to see general
}

public void writeThing(int x) {
 System.out.println("wow there is a int number:"+x); // if i take an int number as parameter i want to see it
}

public void writeThing(long x) {
 System.out.println("wow there is a int number:"+x); // if i take an long number as parameter i want to see it
}

// and so on

[Seetharaman Venkatasamy]

Polymorphism is Overriding not an Overloading. Overriding is expected behavior . but Overloading is an abnormal to an Object