Method Overloading Verification

[lala]

Hi.
I want to make sure I have the correct understanding of Method Overloading.

If the methods have the same name, BUT different formal parameter lists, they are method overload.
Exs.
Method Overload
public int methodABC (int a, char b, double c)
public int methodABC (char a, int b, double c)

Not Method Overload
If they have the same method name and the same formal lists they are NOT method overload.
public int methodABC (int a, char b, double c)
public int methodABC (int a, char b, double c)

What if they had same name, & they had the same formal list/signature, but the value/return type was different
public double methodABC (int a, char b, double c)
public int methodABC (int a, char b, double c)

[Tolls]

Yes that's overloaded, assuming those methods are in the same class anyway, or one of them is in a subclass.

The not overloaded methods cannot be in the same class (can't have two methods with the same signature in the same class)...so I assume you mean the second one is in a subclass? In which case that's overriding.

And finally, a method cannot be differentiated from another method solely by its return parameter, so those two examples cannot exist together in the same class hierarchy.

[lala]

Thanks for responding Tolls.

I think that there must be a one-to-one match between actual and formal parameters.

If there are 4 formal, then there should be 4 actual. Is that right?

[KevinWorkman]

What do you mean by "actual" and "formal" parameters?

[Tolls]

I was just going to ask that question...:)

An overloaded method is a method that has the same name, but different parameters. I'm pretty sure parameter count doesn't matter.

[lala]

KevinWorkman, this is my understanding.

Formal parameters are declared in the header:
public double pow (double x, double y)

Actual parameters are in the body (or when the method is called/used):

double x = 2.0;
double y = 2.0; 

z = pow(x,y) or z = pow(2.0,2.0);

If this example is not correct, will someone please let me know.

[lala]

Tolls, this is what I read:
"In a method call, the number of actual parameters, together with their dataa types, must match the formal parameters in the order given. That is, actual & formal parametes have a one-to-one correspondence." (Java Programming)

I found this on Google:
"When you call a subroutine, you must provide one actual parameter for each formal parameter in the subroutine's definition." (Java Programing: Section 4.3)

lala

Does anybody know for sure?

[Tolls]

That's got nothing to do with overloading or overriding though.
That's to do with calling a method...which is why I was confused.

[lala]

I don't know, Tolls. :confused:

Does anyone know if formal and actual parameters have to have a one-to-one match?

Thanks In Advance

[Tolls]

Of course they do, but that has nothing to do with overloading, except in so far as the compiler using the parameters supplied in a call to determine which overloaded method to use.

[lala]

Tolls, now that I re-think this, I don't think it matters if they do not match.

[Tolls]

What?
What are you talking about now?
Calling a method? If so, then the parameters have to match.
Overloading? Well, the parameters can't match.
Overriding? Then they have to match, otherwise it's overloading.

[JosAH]

I'm pretty sure parameter count doesn't matter.

Yes it does; have a look:

public void foo(double a) { ... }
public void foo(double a, double b) { ... }

Two overloaded methods with a different signature (because of their different parameter count).

kind regards,

Jos

[Tolls]

No, what I mean is the OP is saying something about parameter count matching...which is why I say parameter count doesn't matter. If the signature is different (whether through parameter types or number) then it's overloading.

This is what they said:
"I think that there must be a one-to-one match between actual and formal parameters."

Which is untrue for overloading. The count doesn't matter, it's the difference in signature that does.

In essence I think the OP is mixing different concepts and confusing matters.

[JosAH]

No, what I mean is the OP is saying something about parameter count matching...which is why I say parameter count doesn't matter. If the signature is different (whether through parameter types or number) then it's overloading.

This is what they said:
"I think that there must be a one-to-one match between actual and formal parameters."

Which is untrue for overloading. The count doesn't matter, it's the difference in signature that does.

In essence I think the OP is mixing different concepts and confusing matters.

Oops, sorry about the confusion I may have caused; b.t.w. overloading is a bit more complicated because of widening conversions; e.g.

public void foo(double a, int b) { ... }
public void foo(int a, double b) { ... }
...
foo(1.0, 2); // fine
foo(1, 2.0); // also fine
foo(1, 2); // ambiguous

kind regards,

Jos

[Tolls]

Well, yes...but there's enough confusion here without bringing that lot into it...Loretta.

[JosAH]

Well, yes...but there's enough confusion here without bringing that lot into it...Loretta.

Ooh men ... you ain't seen nothing yet! Why do you primitive species always want to keep things so simple? The answer: lack of braincells.

kindest regards,

Loretta ;-)

[couling]

FYI:

The history behind overloading was that origionally (in older languages such as c) overloading was not possible.

This had the outcome that (to bring it forward to a java example) you had to have functions of the form:

void printInt(int x) {...}
void printDouble(double x) {...}

This made the api more difficult to remember and source a little more difficult to read.

So later languages (c++ onwards) let you give different functions the same name as long as the compiler could allways figure out which function you were trying to use. But it was put there to let you give the same name to several functions which do the same thing (eg "print" or "add").

To that end it is usually considdered really bad practise to give the same name to two functions which do different things. Some people relax this rule a little if the different functions take a different number of arguements but the functions should have the same general purpose.

I bring this up because I have seen people intentionally write code as mindless as:

public void doSomething(int x) {turnLeft(x);}
public void doSomething(double x) {turnRight(x);}

[Tolls]

Ooh men ... you ain't seen nothing yet! Why do you primitive species always want to keep things so simple? The answer: lack of braincells.

kindest regards,

Loretta ;-)

Mrs Tolls says it's because we can't concentrate on more than one thing at a time.
Which, to be fair, is not too far from the truth. Is it so bad to want to actually finish something before you get dumped with another task?

[lala]

Yes Tolls, and all. The OP may have been " mixing different concepts and confusing matters." :)

Sorry about the confusion. I'm new to Java.
Many thanks to Everyone for your contributions.

:)