java中，为什么抽象方法不能定义成静态的？

Question

如果抽象方法可以定义为静态的
那么abstract class A{
          abstract static void pri();
    }
    class B extends A {
       static void pri();
    }
  class Test {
    public static void main(String[] args){
      A a= new B();
      a.pri();//这里调用的是A的pri();
   }
 }

Answer 1

静态方法与静态属性与对象是无关的，只与类有关
看以下例子：
public class A{
    public static String s="A.s";
}
public class B extends A{
    public static String s="B.s";
    public static void main(String[] args){
        B a=new B();
        System.out.println("s:"+b.s);
    }
}结果是：
A.s
所以说 ,static 属性是不能被重写的，这与abstract是矛盾的，所以abstract是不能被修饰为static，否则就失去了abstract的意义了

Answer 2

不好意思，以上有疏漏，例子应该改为：
class A{
    public static String s="A.s";
}
public class B extends A{
    public static String s="B.s";
    public static void main(String[] args){
        A a=new B();
        B b=new B();
        System.out.println("a.s:"+a.s);
        System.out.println("b.s:"+b.s);
    }
}
结果是：
a.s:A.s
b.s:B.s

Answer 3

上楼兄弟：nc201(Bricklayer)
运行结果是试B.s吧！我刚才也听同事说静态方法是不能重写的，可是实际上是可以重写的。

Answer 4

我觉得 ngqzmjmj(冷酷)  说的蛮有道理！

Answer 5

静态方法不能overriding
可以覆盖

Answer 6

不懂，覆盖和overriding都是指什么？

Answer 7

danceflash(Wine) ( ) 
静态方法不能overriding
可以覆盖
====================================
你认为overriding和覆盖有什么区分呢?静态的方法不存在覆写的问题.具上面兄度的例子改一改:class A{
    public static String s="A.s";
}
public class B extends A{
    public static String s="B.s";
    public static void main(String[] args){
        A a=new B();
        B b=new B();
        A c = new B();
        System.out.println("a.s:"+a.s);
        System.out.println("b.s:"+b.s);
        System.out.println("c.s:"+c.s);    }
}
结果是：
a.s:A.s
b.s:B.s
c.s:a.s其实调用静态方法的时候调用的只是引用的类的静态方法.静态方法跟对象没有关系.
所以不管c里放的是A的对象还是A的子类的对象,结果都一样.

Answer 8

overriding和覆盖
好像是一个意思诶
纳闷！！！

Answer 9

静态方法是不可以继承的,是这java的一个很容易出错的地方,不可继承的方法,当然不可以是虚方法.

Answer 10

在java中
在方法前只加了public修辞字，它就是虚方法！就能实现面向对象的多态性
而在方法前加了final、static、private修辞词，那就无能为力了

Answer 11

静态方法是不可以继承,如果看起来重写，其实是另外一个变量。我是这么认为的。
class A{
    public static String s="A.s";   //1
}
public class B extends A{
    public static String s="B.s";   //2

Answer 12

override=覆盖:=重写基类中的方法（参数可以相同）
overload=重载:=重写同类中的方法（参数必须不同）

Answer 13

???乱说
class A{
    public String s="A.s";
}
public class B extends A{
    public String s="B.s";
    public static void main(String[] args){
        A a=new B();
        B b=new B();
        System.out.println("a.s:"+a.s);
        System.out.println("b.s:"+b.s);
    }
}你试试这个
属性没有覆盖一说     你静态不静态一样       
覆盖只是对方法说的