Java中隐藏的方法是什么？ 即使是JavaDoc的解释也是令人困惑的
Javadoc说：
被调用的隐藏方法的版本是超类中的版本，被调用的重写方法的版本是子类中的版本。
不要给我敲钟。 任何清楚的例子显示这个意思，将不胜感激。
public class Animal { public static void foo() { System.out.println("Animal"); } } public class Cat extends Animal { public static void foo() { // hides Animal.foo() System.out.println("Cat"); } } 这里， Cat.foo()被认为是隐藏Animal.foo() 。 隐藏不能像重写一样工作，因为静态方法不是多态的。 所以下面会发生：
Animal.foo(); // prints Animal Cat.foo(); // prints Cat Animal a = new Animal(); Animal b = new Cat(); Cat c = new Cat(); Animal d = null; a.foo(); // should not be done. Prints Animal b.foo(); // should not be done. Prints Animal because the declared type of b is Animal c.foo(); // should not be done. Prints Cat because the declared type of c is Cat d.foo(); // should not be done. Prints Animal because the declared type of b is Animal
调用实例上的静态方法而不是类是非常糟糕的做法，不应该这样做。
将它与实例方法进行比较，这些实例方法是多态的，因此被覆盖。 调用的方法取决于具体的对象的运行时types：
public class Animal { public void foo() { System.out.println("Animal"); } } public class Cat extends Animal { public void foo() { // overrides Animal.foo() System.out.println("Cat"); } }
然后会发生以下情况：
Animal a = new Animal(); Animal b = new Cat(); Animal c = new Cat(); Animal d = null; a.foo(); // prints Animal b.foo(); // prints Cat c.foo(); // prints Cat d.foo(): // throws NullPointerException
首先什么是方法隐藏的意思？
方法隐藏意味着子类在超类中定义了一个与类方法具有相同签名的类方法。 在这种情况下，超类的方法被子类隐藏。 它表示： 被执行的方法的版本不会由用于调用它的对象决定 。 实际上它将由用于调用方法的引用variables的types决定。
什么是方法重写的意思？
方法重载意味着子类已经定义了一个具有相同签名和返回types（包括协变types）的实例方法作为超类中的实例方法。 在这种情况下，超类的方法被子类覆盖（replace）。 它表示： 被执行的方法的版本将由用于调用它的对象决定 。 它不会由用于调用方法的引用variables的types决定 。
为什么不能重写静态方法？
因为静态方法是基于它们被调用的类而静态地（即在编译时）被parsing的，而不是像基于对象的运行时types被多态地parsing的实例方法那样dynamic地parsing。
应该如何访问静态方法？
静态方法应该以静态方式访问。 即通过类本身的名称而不是使用实例。
这里是方法覆盖和隐藏的简短演示：
class Super { public static void foo(){System.out.println("I am foo in Super");} public void bar(){System.out.println("I am bar in Super");} } class Child extends Super { public static void foo(){System.out.println("I am foo in Child");}//Hiding public void bar(){System.out.println("I am bar in Child");}//Overriding public static void main(String[] args) { Super sup = new Child();//Child object is reference by the variable of type Super Child child = new Child();//Child object is referenced by the variable of type Child sup.foo();//It will call the method of Super. child.foo();//It will call the method of Child. sup.bar();//It will call the method of Child. child.bar();//It will call the method of Child again. } }
输出是
I am foo in Super I am foo in Child I am bar in Child I am bar in Child
显然，正如指定的那样，由于foo是类方法，因此所调用的foo的版本将由引用Child对象的引用variables（即Super或Child）的types决定。 如果它被Supervariables引用，那么Super foo被调用。 如果它被Childvariables引用，则调用Child foo 。
鉴于 ，
由于bar是实例方法，因此被调用的bar版本完全由用于调用它的对象（即Child ）确定。 无论通过哪个引用variables（ Super或Child ）调用，将要调用的方法始终是Child 。
覆盖方法意味着无论何时在派生类的对象上调用方法，都会调用新的实现。
隐藏一个方法就意味着在这个类的范围内（即在它的任何一个方法的主体中，或者当用这个类的名字限定时）对这个名字的非限定的调用现在将调用一个完全不同的函数， 从父类访问同名的静态方法 。
更多描述Javainheritance：覆盖或隐藏的方法
例如，你可以覆盖超类的实例方法，但不是静态的。
隐藏是父类有一个名为Foo的静态方法，子类也有一个名为Foo的静态方法。
另一种情况是父级有一个名为Cat的静态方法，子类有一个名为Cat的实例方法。 （具有相同签名的静态和实例不能混合）。
public class Animal { public static String getCat() { return "Cat"; } public boolean isAnimal() { return true; } } public class Dog extends Animal { // Method hiding public static String getCat() { } // Not method hiding @Override public boolean isAnimal() { return false; } }
如果一个子类在超类中定义了一个与类方法具有相同签名的类方法，则子类中的方法隐藏了超类中的方法。
我相信隐藏的方法在静态上下文中。 静态方法本身并没有被覆盖，因为编译器在编译时自己完成方法调用的parsing。 因此，如果您在基类中定义了一个与父类中的签名相同的静态方法，那么子类中的方法将隐藏从超类inheritance的方法。
class Foo { public static void method() { System.out.println("in Foo"); } } class Bar extends Foo { public static void method() { System.out.println("in Bar"); } }
