How to prevent a method from overloading in Java?

Overriding a method can be prevented by using the keyword final, likewis开发者_StackOverflow中文版e how to prevent overloading?

You can't. Because it's almost pointless.

If you want to overload the method handle(..) but you are disallowed to, you'd create doHandle(..) instead.

Which overloaded method is used is determined at compile time (in contrast to overridden methods, which are determined at runtime). So the point of overloading is sharing a common name for common operations. Disallowing that is a matter of code-style, rather than anything else.

You can't do that in Java.

An overloaded method is basically just another method.

An attempt could look (something) like this

void yourMethod(String arg) { /* ... */ }

void yourMethod(String arg, Object... prevent) {
    throw new IllegalArgumentException();
}

but it won't work since Java resolves overloading by looking at the "best match" or "most specific signature".

The method could still be overloaded with a

void yourMethod(String arg, String arg2) { /* ... */ }

which would be called when doing yourMethod("hello", "world").

Btw, why would you want to prevent overloading? Perhaps there is another way of doing what you want?

Err... what's the point in not allowing to Overload the method?

Protection from Overriding is allowed because it can be done by another programmer who is supposedly working on another part of code and his class is inherited from your class.

Overloading is done in the same class and is logically supposed to be done by a programmer who knows this code and is working on the same part of the code. So, if he knows this code (theoretically) and there is some inherent danger in overloading, then he should know this already because he knows the code.

That said, overloading cannot be stopped as others have already described.

Mark the class final and it can't be extended. That may defeat some other purpose though.

If you overload a method, you've created a method with the same name but different parameter types. In Java, a method is defined (partly) in terms of its parameters, and thus if two methods have the same name but different parameters, then they are apples and oranges, i.e., not the same. In short, you can't prevent someone from creating new methods in a class, which is essentially what you're asking for.

simple! don't call that overloaded method.

public class Test
{

   public void m(int a)
     {
       *your definition*
     }
public void m(float a)
     {
       *your definition*
     }
}
public static void main(Strings [] args)
{
  Test t=new Test();
  t.m(5);
}

Overriding and Overloading are different techniques. Overloading is a way of declaring multiple methods with the same names but different parameter types or different no of parameters.

You can prevent a method from being overwritten by making it final, but you cannot prevent a method from being overloaded. Well technically you could make the class itself final, so that no methods at all can be added by creating a subclass but I don't think that's a good design.