如果抽象方法可以定义为静态的
那么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();
}
}
那么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();
}
}
看以下例子:
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的意义了
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
运行结果是试B.s吧!我刚才也听同事说静态方法是不能重写的,可是实际上是可以重写的。
可以覆盖
静态方法不能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的子类的对象,结果都一样.
好像是一个意思诶
纳闷!!!
在方法前只加了public修辞字,它就是虚方法!就能实现面向对象的多态性
而在方法前加了final、static、private修辞词,那就无能为力了
class A{
public static String s="A.s"; //1
}
public class B extends A{
public static String s="B.s"; //2
overload=重载:=重写同类中的方法(参数必须不同)
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);
}
}你试试这个
属性没有覆盖一说 你静态不静态一样
覆盖只是对方法说的