相关疑难解决方法(0)

为什么不能覆盖静态方法？

如果可能,请举例说明.

我正在阅读Khalid Mughal的程序员Java™SCJP认证指南.

在继承章节中,它解释了这一点

成员的继承与其声明的可访问性密切相关.如果超类成员可以通过其子类中的简单名称访问(不使用任何额外的语法,如super),则该成员被视为继承

它还提到静态方法不是继承的.但是下面的代码非常好:

class A
{
    public static void display()
    {
        System.out.println("Inside static method of superclass");
    }
}

class B extends A
{
    public void show()
    {
        // This works - accessing display() by its simple name -
        // meaning it is inherited according to the book.
        display();
    }
}

我怎么能display()在课堂上直接使用B？更重要的是,B.display()也有效.

本书的解释是否仅适用于实例方法？

我知道在Java中,静态方法就像实例方法一样继承,不同之处在于,当重新声明它们时,父实现被隐藏而不是被覆盖.好吧,这很有道理.但是,Java教程指出了这一点

接口中的静态方法永远不会被继承.

为什么？常规和接口静态方法有什么区别？

当我说静态方法可以继承时,让我澄清一下我的意思:

class Animal {
    public static void identify() {
        System.out.println("This is an animal");
    }
}
class Cat extends Animal {}

public static void main(String[] args) {
    Animal.identify();
    Cat.identify(); // This compiles, even though it is not redefined in Cat.
}

然而,

interface Animal {
    public static void identify() {
        System.out.println("This is an animal");
    }
}
class Cat implements Animal {}

public static void main(String[] args) {
    Animal.identify();
    Cat.identify(); // This does not compile, because interface …

我知道我们不能在Java中覆盖静态方法,但有人可以解释下面的代码吗？

class A {
    public static void a() { 
        System.out.println("A.a()");
    }
}   

class B extends A {
    public static void a() {
        System.out.println("B.a()");
    }
}

我怎么能a()在课堂上覆盖方法B？

为什么以下代码打印"Main"？

public class Main
{
    public static void method()
    {
        System.out.println("Main");
    }

    public static void main(String[] args)
    {
        Main m = new SubMain();
        m.method();
    }
}

class SubMain extends Main
{
    public static void method()
    {
        System.out.println("SubMain");
    }
}

在运行时,m指向一个实例Submain,因此它应该在概念上打印"SubMain".

我明白为什么 java 不允许为重写的方法设置较弱的访问权限，但为什么静态方法是一样的？我的意思是，这些方法只会互相隐藏，对吗？那么从封装的角度来看有什么问题呢？

聚苯乙烯

我知道隐藏方法有 5 条规则

1. 子类中的方法必须与父类中的方法具有相同的签名。
2. 子类中的方法必须至少与父类中的方法一样易于访问或更易于访问。
3. 子类中的方法不能抛出比父类方法中抛出的任何异常的类新的或更广泛的已检查异常。
4. 如果方法返回一个值，它必须是父类中方法的相同或子类，称为协变返回类型。
5. 子类中定义的方法如果在父类中标记为静态，则必须标记为静态（方法隐藏）。同样，如果该方法在父类中未标记为静态（方法覆盖），则该方法在子类中不得标记为静态。

但毕竟，我没有从封装的角度得到这个想法

它写在任何地方都不能覆盖静态方法,但是当我尝试减少访问说明符时,从public到protected,它会产生错误.例如

public class StaticOverrideFunda {

    public static void foo(){
        System.out.println("Parent Foo");
    }
}

public class B extends StaticOverrideFunda{


    protected static void foo(){
        System.out.println("Child Foo");
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        B.foo();            
    }
}

它说

无法降低继承方法的可见性

因此,它是遵循最重要的规则,为什么我们说foo没有在B类中被覆盖？为什么我们说它隐藏/阴影而不是覆盖？

我知道孩子不能降低非静态方法的可视性，而且我理解为什么会这样。

但是，我读过“可以通过重新声明静态方法来隐藏它”。但是我不明白如何用Java实现。

这真的有可能吗？如果是，该如何做（代码示例），为什么要引入它（这似乎与不降低接口可见性的原理相矛盾）？