blocks|key|3502672|text|在Java中不能这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3502673|重载方法基本上只是另一种方法。|3502674|一次尝试可能看起来像这样。|3502675|void+yourMethod(String+arg)+{+/*+...+*/+}

void+yourMethod(String+arg,+Object...+prevent)+{
++++throw+new+IllegalArgumentException();
}|code-block|syntax|javascript|3502676|但它不会起作用，因为Java通过查看“最佳匹配”或“最具体的签名”来解决过载问题。|3502677|该方法仍然可以使用|3502678|void+yourMethod(String+arg,+String+arg2)+{+/*+...+*/+}|3502679|它将在执行yourMethod("hello",+"world")时被调用。|offset|length|style|CODE|3502680|顺便说一句，你为什么要防止过载呢？也许还有另一种方法可以做你想做的事？|3502681|entityMap^0|0|0|0|0|0|0|0|5|S|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|16|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|17|8|@$S|18|T|19|U|V]]|9|@]|A|$]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

You can't do that in Java.

An overloaded method is basically just another method.

An attempt could look (something) like this

<pre><code>void yourMethod(String arg) { /* ... */ }

void yourMethod(String arg, Object... prevent) {
 throw new IllegalArgumentException();
}
</code></pre>

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

<pre><code>void yourMethod(String arg, String arg2) { /* ... */ }
</code></pre>

which would be called when doing <code>yourMethod("hello", "world")</code>.

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

blocks|key|1309817|text|将类标记为final，并且它不能扩展。然而，这可能会破坏一些其他目的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1309818|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

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

blocks|key|3502746|text|如果你重载了一个方法，你已经创建了一个同名但参数类型不同的方法。在Java中，方法是(部分地)根据它的参数来定义的，因此，如果两个方法具有相同的名称但参数不同，那么它们就是苹果和橙子，也就是说，不是相同的。简而言之，您不能阻止某人在类中创建新方法，这本质上就是您所要求的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3502747|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

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.

blocks|key|3502786|text|重写和重载是不同的技术。重载是一种声明多个方法的方式，这些方法具有相同的名称但不同的参数类型或不同的参数数量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3502787|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

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.

blocks|key|1313737|text|您可以通过将方法设为来防止方法被重载，但不能阻止方法被重载。从技术上讲，你可以让类本身成为最终的，这样就不能通过创建一个子类来添加任何方法，但我不认为这是一个好的设计。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1313738|entityMap^0|G|B|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

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.

blocks|key|566430|text|你不能，因为这几乎毫无意义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|566431|如果您想重载方法handle(..)，但不允许这样做，那么您应该创建doHandle(..)。|offset|length|style|CODE|566432|使用哪个重载方法是在编译时确定的(与在运行时确定的重载方法不同)。因此，重载的要点是为常见操作共享一个通用名称。不允许这样做是一个代码风格的问题，而不是其他任何事情。|566433|entityMap^0|0|8|A|Y|C|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

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

If you want to overload the method <code>handle(..)</code> but you are disallowed to, you'd create <code>doHandle(..)</code> 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.

blocks|key|3502942|text|呃..。不允许重载该方法的意义是什么？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3502943|防止重写是允许的，因为它可以由另一个程序员完成，该程序员应该正在处理代码的另一部分，而他的类是从您的类继承而来的。|3502944|重载是在同一个类中完成的，从逻辑上讲，重载应该由了解此代码并且正在处理代码的同一部分的程序员来完成。所以，如果他知道这段代码(理论上)，而且重载存在一些固有的危险，那么他应该已经知道了，因为他知道这段代码。|3502945|也就是说，重载不能像其他人已经描述的那样停止。|3502946|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

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.

blocks|key|3502959|text|很简单！不要调用那个重载的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3502960|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);
}|code-block|syntax|javascript|3502961|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

simple! don't call that overloaded method.

<pre><code>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);
}
</code></pre>

Overriding a method can be prevented by using the keyword <code>final</code>, likewise how to prevent overloading?

How to prevent a method from overloading in Java?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

重写方法可以通过使用关键字final来防止，同样，如何防止重载？

问如何在Java中防止方法重载？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Java中防止方法重载？EN