看看这个程序

Question

class Test
{
static void show(){
System.out.println("Show method in Test class");
}
}
public class Q2 extends Test{
       
static void show(){
System.out.println("Show mehtod in Q2 class");
}
public static void main(String[] args)
{
Test t = new Test();
t.show();
Q2 q = new Q2();
q.show();


t = q;
t.show();


}
}
结果是
Show method in Test class
Show mehtod in Q2 class
Show method in Test class最后句是什么原因？？？

Answer 1

Q2 q = new Q2(); 是向上转型

Answer 2

向上转型~
可以看看http://blog.csdn.net/kao331431214/archive/2008/12/02/3430859.aspx

Answer 3

class A{
public static void testP(){
System.out.println("A");
}
public void testM(){
System.out.println("X");
}
}class B extends A{
public static void testP(){
System.out.println("B");
}
public void testM(){
System.out.println("Y");
}
}public class Test{
public static void main(String[] args){
A a=new A();
B b=new B();
a.testP();//结果是 A
b.testP();//结果是 B
a.testM();//结果是 X
b.testM();//结果是 Y
a=b;
a.testP();//结果是 A
b.testP();//结果是 B
a.testM();//结果是 Y
b.testM();//结果是 Y
}
}大家可以看到结果，但是为什么会这个样子呢？下面我就试着来解释一下这个问题：
大家都知道非静态方法的继承覆盖的原则，即向上转型时从他的实例中可而已看出来，但是静态方法却不是像非静态方法那样工作，虽然静态方法可以被继承但是为什么不能覆盖呢？
原因是这样的，静态方法跟其他非静态方法不一样的区别在于静态方法不用NEW一个实例就可以调用的，即它的调用是根据他的类型来判断的，所以我总结一句话就是：静态方法的继承和覆盖是跟着引用类型的，而非静态方法是跟着实例本身的。
静态方法在创建类以前就已经存在，是存放在类里面，而不是在对象里面，个人理解而已

Answer 4

class A{
public static void testP(){
System.out.println("A");
}
public void testM(){
System.out.println("X");
}
}class B extends A{
public static void testP(){
System.out.println("B");
}
public void testM(){
System.out.println("Y");
}
}public class Test{
public static void main(String[] args){
A a=new A();
B b=new B();
a.testP();//结果是 A
b.testP();//结果是 B
a.testM();//结果是 X
b.testM();//结果是 Y
a=b;
a.testP();//结果是 A
b.testP();//结果是 B
a.testM();//结果是 Y
b.testM();//结果是 Y
}
}大家可以看到结果，但是为什么会这个样子呢？下面我就试着来解释一下这个问题：
大家都知道非静态方法的继承覆盖的原则，即向上转型时从他的实例中可而已看出来，但是静态方法却不是像非静态方法那样工作，虽然静态方法可以被继承但是为什么不能覆盖呢？
原因是这样的，静态方法跟其他非静态方法不一样的区别在于静态方法不用NEW一个实例就可以调用的，即它的调用是根据他的类型来判断的，所以我总结一句话就是：静态方法的继承和覆盖是跟着引用类型的，而非静态方法是跟着实例本身的。
静态方法在创建类以前就已经存在，是存放在类里面，而不是在对象里面，个人理解而已

Answer 5

要注意的是静态初始化只有在必要的时候才会进行
初始化的循序是先静态，而后非静态
详细分析和例子可以在Think in java（第4版）中看到
具体位置是第五章（初始化与清理）
的5.7.2小节（静态数据的初始化）

Answer 6

之类调用自己的静态方法，父类也有个同名的静态方法，所以先执行自己的，再执行父类的看看这
package csdn;class Testa
{
public  void show()
{
System.out.println("Show method in Test class");
}
}public class Q2 extends Testa
{ public void show()
{
System.out.println("Show mehtod in Q2 class");
} public static void main(String[] args)
{
Testa t = new Testa();
t.show();
Q2 q = new Q2();
q.show(); t = q;
t.show(); }
}
我把程序修改了下
运行结果是
Show method in Test class
Show mehtod in Q2 class
Show mehtod in Q2 class

Answer 7

static 方法是类方法．是不被覆盖的。
当　Test test = new Q2();
    test.show();--还是执行Test类中的静态方法show();

Answer 8

同上~楼主还要注意java中的默认多态

Answer 9

从内存理解上来说是因为Static 成员变量和方法是在编译期就存在静态存储区了~~~~~~~~~
所以
t = q; 
t.show(); 
在编译器看来他只能看到父类的方法而不能看到子类的方法。