标签: method-hiding

在基类型" virtual"中声明方法然后使用" override"关键字在子类型中覆盖它而不是new在声明子类型中的匹配方法时简单地使用" "关键字之间有什么区别？

Javadoc说:

被调用的隐藏方法的版本是超类中的版本,被调用的重写方法的版本是子类中的版本.

不响铃给我.任何显示其含义的明确例子都将受到高度赞赏.

关于覆盖与隐藏C#中的方法有点困惑.每个人的实际用途也将被理解,以及何时使用每个人的解释.

我对重写感到困惑 - 为什么要覆盖？到目前为止我所学到的是,通过覆盖,我们可以在不改变签名的情况下为派生类的方法提供所需的实现.

如果我不覆盖超类的方法并且我对子类中的方法进行了更改,那么是否会更改超类方法？

我也对以下内容感到困惑 - 这表明了什么？

class A
{
    virtual m1()
    {
        console.writeline("Bye to all");
    }
}

class B : A
{
    override m1()
    {
        console.writeLine("Hi to all");
    }
}

class C
{
    A a = new A();
    B b = new B();
    a = b; (what is this)
    a.m1(); // what this will print and why?

    b = a; // what happens here?
}

给定以下代码片段,函数调用有何不同？什么是隐藏功能？什么是功能重写？它们如何与函数重载相关？两者有什么区别？我在一个地方找不到这些的好描述,所以我在这里问我所以我可以巩固这些信息.

class Parent {
  public:
    void doA() { cout << "doA in Parent" << endl; }
    virtual void doB() { cout << "doB in Parent" << endl; }
};

class Child : public Parent {
  public:
    void doA() { cout << "doA in Child" << endl; }
    void doB() { cout << "doB in Child" << endl; }
};

Parent* p1 = new Parent();
Parent* p2 = new Child();
Child* cp = new Child();

void testStuff() {
  p1->doA();
  p2->doA();
  cp->doA(); …

打印以下程序

A:C(A,B)
B:C(A,B)

(正如它应该)

public interface I
{
    string A();
}

public class C : I
{
    public string A()
    {
        return "A";
    }

    public string B()
    {
        return "B";
    }
}

public class A
{
    public virtual void Print(C c)
    {
        Console.WriteLine("A:C(" + c.A() + "," + c.B() + ")");
    }
}

public class B : A
{
    public new void Print(C c)
    {
        Console.WriteLine("B:C(" + c.A() + "," + c.B() + ")");
    }

    public void Print(I i)
    { …

可能重复:
使用有效示例隐藏在c#中的方法.它是否在框架中实现.？什么是真实世界的优势.

我想知道方法隐藏在c#中有用吗？如果你深入研究这个概念,你会发现隐藏的方法令人困惑,并驱使我们采用意大利面条代码风格.有一些原因:

1-如果在Derived类中需要一个新方法,则可以在派生类中使用新名称定义新方法.

2 - 在使用upcasting时以多态方式使用,将无法实现预期的行为,这可能会令人困惑.

(特别是如果Base类和Derived Class位于不同的库中并且您希望在代码中的某个位置使用它们的多态用途,这种奇怪的行为可能会非常明显和明显)

class Base
{  
    public void Method() { Console.WriteLine("I am Base Class"); }
}
class Derived: Base
{
    public new void Method() { Console.WriteLine("I am Derived Class");}
}
class Program
{
    static void Main(string[] args)
    {
        Base C = new Derived();
        C.Method(); //output:"I am Base Class"
    }
}

这样的行为可能是混乱的,但如果我们使用" 虚拟的"," 基本 "和" 覆盖在"" 派生 "(我的意思是多态的使用)的输出是:"我在派生类".这个输出是我认为我们大多数人所期望的.

换句话说,我相信在层次结构中,大多数开发人员期望在派生类中使用重写方法而不是新方法,而是希望隐藏基类实现.

我不明白为什么这样一个没有优势的坏东西有c#语言？至少我想知道隐藏在c#中的方法的最佳用法是什么？

谢谢您的帮助

为什么打印以下程序

B
B

(正如它应该)

public class A
    {
        public void Print()
        {
            Console.WriteLine("A");
        }
    }

    public class B : A
    {
        public new void Print()
        {
            Console.WriteLine("B");
        }

        public void Print2()
        {
            Print();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var b = new B();
            b.Print();
            b.Print2();
        }
    }

但如果我们删除B类中的关键字'public',就像这样:

    new void Print()
    {
        Console.WriteLine("B");
    }

它开始打印

A
B

？

我已经阅读了Overriding and Hiding Methods教程.从那以后,我收集了以下内容:

如果子类定义的类方法与超类中的类方法具有相同的签名,则子类中的方法会隐藏超类中的方法.

因此,我做了以下事情:

import javax.swing.JTextArea;

public final class JWrappedLabel extends JTextArea{
    private static final long serialVersionUID = -844167470113830283L;

    public JWrappedLabel(final String text){
        super(text);
        setOpaque(false);
        setEditable(false);
        setLineWrap(true);
        setWrapStyleWord(true);
    }

    @Override
    public void append(final String s){
        throw new UnsupportedOperationException();
    }
}

我不喜欢这个设计的是它append仍然是子类的可见方法.UnsupportedOperationException我可以把身体留空,而不是扔掉它.但两人都觉得难看.

话虽如此,有没有更好的方法来隐藏超类的方法？

根据http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Class.html#getDeclaredMethods%28%29,Class.getDeclaredMethods()应该只包含"由类声明的方法" ".但是,我在下面的测试代码中得到了一些非常令人惊讶的结果:

import java.util.Arrays;

class A {
 public static A m1() { return null; }
 public static A m2() { return null; }
 public static A m3() { return null; }
}

class B extends A {
 public static A m1() { return null; }
 public static B m2() { return null; }
// public static Object m3() { return null; } won't compile
}


public class Scratch {
 public static void main(final String[] args) {
  System.out.println(Arrays.asList(B.class.getDeclaredMethods()));
 } …

可能重复:
为什么Java不允许覆盖静态方法？

有没有合理的理由为什么人们希望派生类重写隐藏static基类的方法？