标签: method-hiding

假设您有以下代码

namespace a{
  struct S{};
  //void f(int){}
}

namespace b{
  struct T{};
}


struct X{};

void f(X){}
void f(b::T){}
void f(a::S){}



namespace a{
  void g(){

    S s;b::T t; 
    X x;
    f(x);
    f(s);
    f(t);
  }

}

int main(){
  a::g();
}

如果void f(int){}在名称空间中的(线3未被注释)中所定义,它阴影的后面的定义void f(b::T){}和void f(a::S){},但不是void f(X){}.为什么？

考虑以下代码:

internal class Program
   {

      private static void Main(string[] args)
         {
            var student = new Student();
            student.ShowInfo(); //output --> "I am Student"
        }
    }
    public class Person
    {
        public void ShowInfo()
        {
            Console.WriteLine("I am person");
        }
    }

    public class Student : Person
    {
        public void ShowInfo()
        {
            Console.WriteLine("I am Student");
        }
    }

在上面的代码中我们不使用方法隐藏.

当创建学生实例和调用showinfo方法我的输出是I am Student我不使用new关键字.

当我们不使用方法隐藏时,为什么不调用父方法？

我刚刚了解到,在Java中,覆盖和隐藏之间存在区别(静态方法被隐藏而不是覆盖),这意味着Java使用早期和晚期绑定.

有没有类似于方法隐藏的东西,或者它只是方法覆盖？

隐藏静态字段时,字段对子类的访问级别没有限制,它甚至可以是非静态的,也可以是其他数据类型.

另一方面,当隐藏静态方法时,从超类隐藏静态方法的子类中的静态方法可以允许比隐藏方法更多但不能更少的访问.

AFAIK,静态方法链接无论如何都是在编译时完成的,那么为什么会有这样的限制呢？

PS问题只是出于好奇.

我找不到像我这样的问题,所以我希望这不是一个重复的问题.

再次,这是关于覆盖和隐藏.我想 - 但我可能错了 - 我理解两者.

以下代码按预期运行,两种方法都已隐藏.method1因为它是一个私有方法并且私有方法不能只被隐藏,所以方法2因为它的静态和静态方法不能被覆盖,它们只能被隐藏.

public class Child extends Parent { 
    public void method1(){System.out.println("child");}     
    public static void method2(){ System.out.println("static child");}  
}

class Parent{
    private void method1(){ System.out.println("parent");}      
    public static void method2(){ System.out.println("static parent");}

    public static void main(String[] args){
            Parent p = new Child();
            p.method1(); //prints out "parent"
            p.method2(); //prints out "static parent"
    }
}

如果我读了规格,它说:

http://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.4.3.3

可以将方法声明为final以防止子类覆盖或隐藏它.

如果我将Parent类中的method1更改为"final"

private final void method1(){ System.out.println("parent");}

一切正常.编辑开始:我期望编译器错误说最终方法无法隐藏,但是没有发生.:编辑结束

问题1:这是否意味着只能隐藏静态方法？在我正在阅读的书中(OCA学习指南,Jeanne Boyarsky和Scott Selikoff,第252页),他们清楚地说隐藏了一种私人方法.

然后我将Parent类中的method2更改为

public final static void method2(){ System.out.println("static parent");}

现在编译器确实抱怨,错误说"Child不能覆盖method2()",这非常令人困惑,因为我以为我试图隐藏一个方法.

问题2:不应该是"孩子不能隐藏方法2()"？

编辑开始:我很清楚这里没有重写,但正如上面提到的规范所指出的那样:修饰符final会阻止方法被覆盖或隐藏,这就是我把它放在标题中的原因.:编辑结束

根据MSDN,用于方法隐藏的"new"关键字仅抑制警告.

http://msdn.microsoft.com/en-us/library/435f1dw2.aspx

我真的需要这个"new"关键字来执行方法隐藏吗？如果我有一个具有相同方法名但没有明确说明它是覆盖的子类,那本质上不是同一个东西,我只是得到一个警告？如果我的理解是正确的,请告诉我.谢谢

我有一个名为ImageButton的自定义按钮类,它扩展了JButton.在其中我有一个我想要调用的setEnabled方法而不是JButton的setEnabled方法.

我的代码如下.在我的另一个类中,我创建了一个ImageButton的新实例,但是当我尝试使用setEnabled方法时,它会直接进入JButton的setEnabled方法.甚至在我运行代码之前,我的IDE就告诉我从未使用过ImageButton的setEnabled方法.如果我将方法更改为"SetOn",它可以正常工作.那么为什么我不能使用与超类相同的名字呢？我认为它应该隐藏超类方法,如果它是相同的名称？

public class ImageButton extends JButton{

    public ImageButton(ImageIcon icon){
        setSize(icon.getImage().getWidth(null),icon.getImage().getHeight(null));
        setIcon(icon);
        setMargin(new Insets(0,0,0,0));
        setIconTextGap(0);
        setBorderPainted(true);
        setBackground(Color.black);
        setText(null);
    }

    public void setEnabled(Boolean b){
        if (b){
            setBackground(Color.black);
        } else {
            setBackground(Color.gray);
        }
        super.setEnabled(b);
    }
}

C#中方法隐藏和阴影有什么区别？它们是相同还是不同？我们可以将它们称为多态(编译时或运行时)吗？

我有这样一个基类:

class FooBase
{
    public bool Do(int p) { /* Return stuff. */ }
}

像这样的儿童班:

class Foo<T> : FooBase
{
    private Dictionary<T, int> Dictionary;

    public bool Do(T p)
    {
        int param;
        if (!Dictionary.TryGetValue(p, out param))
            return false;
        return base.Do(param);
    }
}

如果用户创建了一个Foo<string>名为"fooString" 的对象,那么他可以调用两者fooString.Do(5),fooString.Do("test")但如果他创建了一个Foo<int>名为"fooInt" 的对象,他只能调用派生类的Do方法.不管是什么,我更喜欢第二种T.

这两个类中的Do方法基本上都做同样的事情.派生类中的一个从Dictionary<T, int>使用给定参数的a获取一个整数,并使用它调用基类的Do方法.

这就是为什么我想要隐藏FooBasein 的Do方法Foo<T>.我怎样才能实现这个或类似的东西？任何克服这一点的设计建议也会很好.

我有一个带有一些实现方法的抽象超类。

是否可以在继承该超类的子类中隐藏该超类的方法？我不想让某些方法在某些子类中从超类中可见。最后但并非最不重要的一点是，是否可以更改子类中与超类中具有相同名称的方法的参数数量？

假设我们public void test(int a, int b)在超类中有一个方法，但现在我想public void test(int a)在子类中有一个方法来调用超类函数，而超类中的方法不再可见。