Thread: overriding and overloading method

method of overriding and overloading

Overloading
The signature of a method is the name of the method; the number of, order of, and types of arguments of the method, as well as the return type.

The argument signature of a method is the number of, order of, and types of the arguments to a method.

In Java a method is overloaded if it has the same name as another method but different argument signature. Two methods may NOT have the same name and argument signature but differ only in return type and/or exception specifications.

Overriding
Overriding occurs only with respect to inheritance and occurs when a child has a method with the same signature as a parent's method.

Java ALWAYS invokes the most derived VIEWABLE version of a method based on the scope of the present reference. The super reference access forces the method resolution system to not consider any classes below the superclass when finding the most derived method to invoke.

Method overloading:
Overloading is a powerful feature in java. In method overloading the methods can have same name but different parameters.
Ex. sample(int a)
sample(int a, int b)

Method overriding:
Overriding is used in inheritance.Method Overriding is achieved when a subclass overrides non-static methods defined in the superclass, following which the new method implementation in the subclass that is executed.

method overriding is a different scenario.this is done when we go for inheritance.
conditions for method overriding:
1>should have same type of arguments in same number.
2>sould exactly match the same method in it's super class..including throws Exception.

java programming langauge can distinguish methods with different method signature.

Two components of method declaration comprise of method signature ie. Method name and parameter list..
That is it is possible to differentiate methods with same method name if they have different parameter list.

That means that it is possible to define two methods with the same name with in the same class as long as their parameter declarations are different and the process is defined as Method overloading.


Coming to method overriding
In a class hierachy, when a method in the subclass have the same name and signature as the method in the super class then then method in the subclass is said to override the method in the super class.
I hope this explanation is needy one.

Method Overloading:
1) In side the class you can write multipul method with the same name this is called method overloading.
2) When you overloading the methods you need to change the parameters as follows
a)Number of parameter
b)Type of parameter
c)Order of parameter

3)When you overloding the method return type of the method can any things.

Method overriding

1)The return type, method name, type and order of arguments must be identical to those of a method in a parent class.
2)The accessibility must not be more restrictive than original method.

ex:
class Superclass {
void show() { }
}
class Subclass extends Superclass {
void show() { }
}

what abt the exceptions thrown by a method while overriding and overloading ? what rules apply to these exceptions while overriding and overloading such methods?

Method Overloading refers to two or more methods having the same name
with different parameters. i.e methods should defer in number of parameters.

methods having same return type will not help in distinguishing which method to invoke.. for example

void method( int i, int j)
void method( int i, int j, int k )

are overloaded as they differ in number of parameters..

void method()
int method()
are not overloaded as return-type alone is insufficient to distinguish the method having the same name..

Overriding occurs when you redefine a super class method in subclass..
while overriding a method the signature of the method must be same...

hope you understand this.. any one can add more points are welcome..

what is the differences between method binding and late binding? can any one tell me this?

Due to late binding only JAVA was able to show polymorphism .i.e the method that has to be executed will not be known until runtime where as if you take a case where there is no overloading ( polymoprhism ) all the binding is at compile time which is called early binding.

overloading----many methods in the same class with same name ,but with different parameters

Example: sum(int a, int b)
sum (int a, float b,double c)

overriding ---- Related to Inheritenace and redefining the functionality of a method in
child class that has the same signature as defined in the parent class