blocks|key|3689699|text|不是的。您的foo方法需要Class1或Class2。您正在传递一个可以是Class1或Class2的IInterface。它不会编译，因为编译器不知道调用哪个重载方法。您必须将其强制转换为其中一种类型才能对其进行编译。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3689700|或者，IInterface将保存foo方法，该方法不接受任何参数并返回它是哪个类。然后，可以获取IInterface对象并调用obj.foo()|3689701|像这样：|3689702|interface+IInterface+
{+
++++public+string+foo();+
}

class+Class1+:+IInterface
{
+++++public+string+foo()
+++++{
+++++++++return+"Class1";
+++++}
}

class+Class2+:+IInterface
{
+++++public+string+foo()
+++++{
+++++++++return+"Class2";
+++++}
}

public+void+Something(IInterface+obj)
{
++++return+obj.foo();
}|code-block|syntax|javascript|3689703|entityMap^0|6|3|D|6|K|6|11|6|18|6|1F|A|0|3|A|G|3|1C|A|1R|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1C|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1D|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|P|$]]

No. Your <code>foo</code> methods expect either <code>Class1</code> or <code>Class2</code>. You're passing an <code>IInterface</code> which could be either <code>Class1</code> or <code>Class2</code>. It won't compile because the compiler doesn't know which overloaded method to call. You would have to cast it to one of the types to get it to compile.

Alternatively, <code>IInterface</code> would hold the <code>foo</code> method that took no arguments and returned which class it was. Then something could take the <code>IInterface</code> object and call <code>obj.foo()</code> 

Like:

<pre><code>interface IInterface 
{ 
 public string foo(); 
}

class Class1 : IInterface
{
 public string foo()
 {
 return "Class1";
 }
}

class Class2 : IInterface
{
 public string foo()
 {
 return "Class2";
 }
}

public void Something(IInterface obj)
{
 return obj.foo();
}
</code></pre>

blocks|key|3404100|text|public+string+Something+(IInterface+obj)
{
++++return+foo+((Class1)obj);+
++++OR+//+There's+no+way+compiler+to+know+with+method+to+call.
++++return+foo+((Class2)obj);+
}

public+string+foo+(Class1+bar)
{
++++return+"Class1";
}

public+string+foo+(Class2+bar)
{
++++return+"Class2";
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3404101|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public string Something (IInterface obj)
{
 return foo ((Class1)obj); 
 OR // There's no way compiler to know with method to call.
 return foo ((Class2)obj); 
}

public string foo (Class1 bar)
{
 return "Class1";
}

public string foo (Class2 bar)
{
 return "Class2";
}
</code></pre>

blocks|key|1789330|text|不，非虚调用的去向是在编译时确定的，因此您不能在运行时根据类型调用不同的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1789331|您可能正在寻找的是虚拟方法：|1789332|public+void+Start+()+{
++Class1+x+=+new+Class1();

++string+s+=+Something(x);

++Console.ReadKey();
}

public+string+Something+(BaseClass+obj)+{
++return+obj.foo();
}

abstract+class+BaseClass+{
++abstract+string+Foo();
}

class+Class1+:+BaseClass+{

++public+override+string+foo+()+{
++++return+"Class1";
++}

}

class+Class2+:+BaseClass+{

++public+override+string+foo+()+{
++++return+"Class2";
++}

}|code-block|syntax|javascript|1789333|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

No, where non-virtual calls go is determined at compile time, so you can't call different methods depending on the type at runtime.

What you might be looking for is virtual methods:

<pre><code>public void Start () {
 Class1 x = new Class1();

 string s = Something(x);

 Console.ReadKey();
}

public string Something (BaseClass obj) {
 return obj.foo();
}

abstract class BaseClass {
 abstract string Foo();
}

class Class1 : BaseClass {

 public override string foo () {
 return "Class1";
 }

}

class Class2 : BaseClass {

 public override string foo () {
 return "Class2";
 }

}
</code></pre>

Something like this should be possible in C#, right?

<pre><code> public void Start ()
 {
 Class1 x = new Class1 ();

 string s = Something (x);

 Console.ReadKey ();
 }

 public string Something (IInterface obj)
 {
 return foo (obj); // &lt;-- Problem line
 }

 public string foo (Class1 bar)
 {
 return "Class1";
 }

 public string foo (Class2 bar)
 {
 return "Class2";
 }

 interface IInterface {}

 class Class1 : IInterface {}

 class Class2 : IInterface {}
</code></pre>

Method overloading and polymorphism Revisited

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

这样的事情在C#中应该是可能的，对吧？    public void Start ()    {        Class1 x = new Class1 ();        string s = Something (x);        Console.ReadKey ();    }    public str...

问重述方法重载和多态性
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问重述方法重载和多态性EN