静态方法的重写问题

Question

1,两个类具有继承关系，对于static的静态方法到底会不会被重写？2,写@override与不写有何区别？

Answer 1

1. 静态方法只与定义时所在的类相关，在编译期就已经绑定到某个类。可以继承，但不能在子类中被同名方法覆盖。2. 没区别吧，好像是。我从来没写过。一些IDE会自动加上。

Answer 2

2,写@override与不写有何区别？
mouseClicked
mouseClickad
如果你把MouseAdapter接口的方法mouseClicked写成了下面这个，你能马上发现么？
不写@override的话，编译器不会给你报错，因为它认为你自己定义了一个其他的方法。
写了@override，你就能马上发现错误。

Answer 3

理解错误。对于static方法，只有继承，重载与隐藏，没有重写。重写只是针对：对象的方法（即：实例方法）而言的。

Answer 4

问题一：可以继承，但是不能重写
问题二：@override属于Annotation,如果方法的前面写了@override，那么表示重写父类的方法。@override的作用是告诉编译器检查这个方法，并从父类中查找是否包含一个被该方法重写的方法，否则就编译出错误。

Answer 5

楼上几位正解，我补充几句，@override是注解，java5.0的新特点，但是只能表示重写 继承类的方法，java6.0 可以表现实现 继承类和实现接口的方法。

Answer 6

对于重写来说，只有方法前面加了final修饰的就不能重写，其余的都能重写，只是说非静态方法重写的话，多态时调用的是重写后的，但如果是静态的方法重写的话，因为静态方法是属于类的而不是对象的，所以多态时是调用重写前的。
其实多态的实质是：先找编译时类型的方法（这个方法当然是静态方法），如果没有找到就找运行时方法，即对象的方法。

Answer 7

标注@Override 它只是告诉编译器我下面的方法是重写的，你帮我按重写规则进行检测，并不影响什么，可加可不加的，不过使用它的时候要注意自己使用的jdk版本哟

Answer 8

1.重写可以，但是没有多态，说法不一，给你举个例子你就明白了
eg:
class Animal{
 public static void m1(){
  System.out.println("Animal m1()"); 
 }
}
class Bird extends Animal{
 public static void m1(){
  System.out.println("Bird m1()"); 
 }
}
public class Test{
 public static void main(String[] args){
  Animal a=new Brid();
 a.m1();
 
 }
}
这样打印的结果是Animal m1();
如果不是静态方法应该打印Brid m1();
不知道这么说你能不能明白2@override避免错误

Answer 9

[Java code]找到一个文章对两继承关系的类同名static方法运行作了说明，但他也并没有说是不是重写。
http://www.java3z.com/cwbwebhome/article/article2/2898.html?id=1556具体内容如下：类方法的重写？
　　 进行到这儿，对类方法与继承、重写等概念应该有较清楚的认识了。如果您不是很清楚、或者我上面介绍得不够详细，请参考Java的圣经《The Java Language Specification》　　 现在开始本文的问题吧：
public class Test {
    public static void main(String[] args) {
        Man man = new Programmer();
        Programmer pro = new Programmer();
        
        man.printName("ManCallMe");
        System.out.println();
        pro.printName("CallMeByMyself");
    }
}class Man {    
    public static void printName(String name) {
        System.out.println(name);
    }
}class Programmer extends Man {    
    public static void printName(String name) {
        System.out.println("Hey, I am a Programmer. You know, that work is an art.");
        System.out.print("My name is " + name);
    }
}　　 结果如下：
Hey, I am a Programmer. You know, that work is an art.
ManCallMeHey, I am a Programmer. You know, that work is an art.
My name is CallMeByMyself　　 “结果绝对不是这样！”如果运行过这段代码，您一定会大声的对我说。的确，结果事实上是这样的：
ManCallMeHey, I am a Programmer. You know, that work is an art.
   My name is CallMeByMyself　　 按照多态的介绍，结果应该是上一个啊！？为什么事实却是纠正的那个呢？难道重写（覆盖）没有成功？事实上，重写操作是成功的，因为第二个函数调用输出的结果证明了这点。那这一切的一切的问号是为何呢？　　 方法被加载的顺序是这一切的根本原因！　　 当一个方法被调用时，JVM首先检查其是不是类方法。如果是，则直接从调用该方法引用变量所属类中找到该方法并执行，而不再确定它是否被重写（覆盖）。如果不是，才会去进行其它操作（例如动态方法查询），具体请参考：方法的加载　　 具体到上面那段代码，因为引用man是Man类型变量，所以JVM根据上述规定，调用的是Man中的printName()，而不是Programmer中printName();而pro正是Programmer，同理，其调用是自己的printName()，出现料想外的结果也就纯属正常了。　　 最后，以一段有趣的代码结束本文。它也是本文对于类方法理解的强有力证据.它正确输出了结果，呵呵～
public class Test {
    public static void main(String[] args) {
        (Man.getMan()).printName();
    }
}class Man {    
    public static void printName() {
        System.out.println("None");
    }
    
    public static Man getMan() {
        return null;
    }
}希望板块内权威人士给出答案....
[Java code]

Answer 10

显然这位兄弟叫别人看：请参考Java的圣经《The Java Language Specification》 ，你自己为什么不去看一看？还：希望板块内权威人士给出答案....？
只要你简单翻看一下JLS的目录，就已经很清楚了：
8.4.8.1 Overriding (by Instance Methods)
8.4.8.2 Hiding (by Class Methods)
其它内容你自己看。