标签: overloading

class A {
   boolean f(A a) { return true; }
}
class B extends A {
   boolean f(A a) { return false; } // override A.f(A)
   boolean f(B b) { return true; }  // overload A.f
}

void f() {  
   A a = new A();
   A ab = new B();
   B b = new B();
   ab.f(a); ab.f(ab); ab.f(b); //(1) false, false, *false*
   b.f(a); b.f(ab); b.f(b);    //(2) false, false, true
}

你能解释一下最后一行的错误输出,为什么不是真的？

我正在尝试使用模板定义一个函数，并且我希望 typename 为 int 或 anEnum（我定义的特定枚举）。我尝试了以下方法，但失败了：

template <int | anEnum T> // or <int T, anEnum T> or <int, anEnum T>
bool isFunction(const T &aVariable){}

我想做的是使用模板，而不是定义两个重载函数。我更喜欢按如下方式调用函数，而程序员不必考虑类型

isFunction(aVariable) // and not isFunction<int> (aVariable) nor isFunction<anEnum> (aVariable)

基本上，我希望这个函数被模板化为 int 和 aNum 类型。我已经搜索过这个，但找不到答案。我可能缺少什么？谢谢，

是的,我确实理解它们之间的区别.我想知道的是:为什么OVERRIDE一个方法？这样做有什么好处？在超载的情况下:唯一的优点是你不必用不同的名称思考功能？

我想定义一个类,MyStream以便:

MyStream myStream;
myStream << 1 << 2 << 3 << std::endl << 5 << 6 << std::endl << 7 << 8 << std::endl;

给出输出

[blah]123
[blah]56
[blah]78

基本上,我想在前面插入一个"[blah]",然后在每次非终止 后插入std::endl？

这里的困难不是逻辑管理,而是检测和重载处理std::endl.有一种优雅的方式来做到这一点？

谢谢!

编辑:我不需要有关逻辑管理的建议.我需要知道如何检测/过载打印std::endl.

如果接口指定了返回另一个接口的属性或方法,为什么第一个接口的实现不允许将返回类型"更改"为更具体的类型？

我们举一个例子来说明:

interface IFoo
{
    IBar GetBar();
}
interface IBar
{ }

class Foo : IFoo
{
    // This is illegal, we are not implementing IFoo properly
    public Bar GetBar()
    {
        return new Bar();
    }
}

class Bar : IBar
{ }

我知道如何让它发挥作用,这不是我关心的问题.

我可以:

• 将返回类型更改GetFoo()为IBar,或
• 显式实现接口,只需GetBar从IFoo.GetBar()方法调用即可

我真正要问的是不仅允许上面的代码编译的原因.是否有上述情况不符合规定的合同IFoo.

我一直在学习,因为我参加了考试,而且我对大多数Java没有太多问题,但我偶然发现了一个我无法解释的规则.这是一段代码片段:

public class A {

    public int method(Object o) {
        return 1;
    }

    public int method(A a) {
        return 2;
    }
}

public class AX extends A {

    public int method(A a) {
        return 3;
    }

    public int method(AX ax) {
        return 4;
    }
}

public static void main(String[] args) {
    Object o = new A();
    A a1 = new A();
    A a2 = new AX();
    AX ax = new AX();

    System.out.println(a1.method(o));
    System.out.println(a2.method(a1));
    System.out.println(a2.method(o));
    System.out.println(a2.method(ax));
}

返回:

1 3 1 …

我对多态,重载和覆盖的概念非常困惑,因为它对我来说似乎是一样的.请解释这些概念,它们如何彼此不同

很困惑所以请指导我.

谢谢

这是一个SSCCE,它演示了描述(恕我直言,怪异)的行为:

public class Test {

   public static void print(int param) {
       System.out.println("int");
   }

   public static void print(float param) {
       System.out.println("float");
   }

   public static void print(Long param) { //<--Wrapper type
       System.out.println("Long");
   }
   public static void main(String[] args) {
       long param = 100L;
       print(param);  // output == float
   }
} 

为什么java会这样做？

我有一个C背景.我只是想知道为什么函数重载被添加到C++中？C没有函数重载但是C++没有,它需要什么？

当时语言设计师的想法是什么？

在方法重载中,是否可以为重载方法设置不同的返回类型？例如,

void foo(int x) ;
int foo(int x,int y);
double foo(String str);

在一般的面向对象编程中,有可能吗？