java笔试帖 今天又栽在一个简单题目上

Question

public class TestVariableHide {
  static class t1 {
  int i=5;
  public int printA(){
  return i;
  }
  }
  static class t2 extends t1{
 int i=100;
 public int printB(){
 return i;
 }
 public void printC(){
 {System.out.println(super.i);}
  }
  }
  public static void main(String...args){
 t1  t=new t1();
 t2 tt=new t2();
 tt.printC();
 System.out.println(tt.printB());
 System.out.println(t.printA());
 System.out.println(tt.printA());
 t1 ttt=(t1)tt;
 System.out.println(ttt.printA());
  }
  } 请写出它的输出结果：
  
  先把结果写下，在自己编译运行看看正确与否……
 

Answer 1

    应该不能编译，静态的内部类不能new```

Answer 2

   啊？！编译通过了``` 为什么会这样呢？那static还有什么用呢？哪位高手给解释下，谢谢!

Answer 3

所有的问题都出现在 printA而 int i 是没有继承问题的，所以永远使用的是基类的 i, 也就是一直输出 5

Answer 4

过程是这样的：tt.printC();就是调用父类的成员变量，所以输出的5，        
              System.out.println(tt.printB());这个就是调用子类的成员变量，因为它重写了父类的成员变量，
              输出的也就是父类的成员变量。
            System.out.println(t.printA());这个就是父类去调用自己的成员变量，所以输出的就是5。
              System.out.println(tt.printA());这个是子类在调用父类的方法，所以调用的还是子类的成员变量a
            System.out.println(ttt.printA());这个地方用到了对象的上转型对象，就是说将子类对象的引用给父类，这样，相当于父类在调用子类的成员变量a.所以输出的就是5.

Answer 5

public class TestVariableHide {
static class t1 {
int i = 5; public int printA() {
return i;
}
} static class t2 extends t1 {
int i = 100; public int printB() {
return i;
} public void printC() {
{
System.out.println(super.i);
}
}
} public static void main(String... args) {
t1 t = new t1();
t2 tt = new t2();
tt.printC();//打印t1.i
System.out.println(tt.printB());//打印t2.i
System.out.println(t.printA());//打印t1.i
System.out.println(tt.printA());打印t1.i
t1 ttt = (t1) tt;
System.out.println(ttt.printA());//打印t1.i
}
}
继承的时候i并没有被继承，多疑调用父类的println()方法打印的是父类中的i

Answer 6

可以通过编译并运行，结果是
5
100
5
5
5运行环境jdk 1.5 eclipse 3.3

Answer 7

第四个System.out.println(tt.printA());
为什么？

Answer 8

因为tt是子类，继承了父类t,所以它能调用父类的方法·~
System.out.println(tt.printA());  就是子类调用父类的方法~

Answer 9

把8楼给的地址内容转抄过来一下,呵呵，加入网摘：4 分析： 
    tt.printC(); 
 //这个调用的是子类的方法，里面输出的是super.i 所以输出为5     System.out.println(tt.printB()); 
//这个调用子类方法，输出i， 所以为 100     System.out.println(t.printA()); 
// 这个是父类的方法，当然输出5     System.out.println(tt.printA()); 
// 这个是子类调用了继承自父类的方法，不过里面的i并没有继承关系，所以 
// 代码里使用的依然是父类的 i,所以输出依然是5     t1 ttt = (t1) tt; 
    System.out.println(ttt.printA()); 
// 多态的表现 
// 但是变量 i 并没有继承关系，所以 父类的方法依然使用的是自己的变量i 
// 输出还是5 

Answer 10

  tt.printC(); 
 //这个调用的是子类的方法，里面输出的是super.i 所以输出为5     System.out.println(tt.printB()); 
//这个调用子类方法，输出i， 所以为 100     System.out.println(t.printA()); 
// 这个是父类的方法，当然输出5     System.out.println(tt.printA()); 
// 这个是子类调用了继承自父类的方法，不过里面的i并没有继承关系，所以 
// 代码里使用的依然是父类的 i,所以输出依然是5     t1 ttt = (t1) tt; 
    System.out.println(ttt.printA()); 
// 多态的表现 
// 但是变量 i 并没有继承关系，所以 父类的方法依然使用的是自己的变量i 
// 输出还是5 

Answer 11

我是新手很侥幸的作对了，我平时写javascript多一些，套用了js里边的继承机制来解释，不知道是否合适。
在javascript中继承是通过继承链（或者叫原型链）来维护的，具体的表现就是访问一个对象的属性或方法
是在对象中进行查找，如果不存在就从父对象中去查找，依次类推。
     t1  t=new t1();
     t2 tt=new t2();
     tt.printC();
     System.out.println(tt.printB());//对象中存在使用对象中方法
     System.out.println(t.printA());
     System.out.println(tt.printA());//对象中不存在使用父对象中方法
     t1 ttt=(t1)tt;//修改了类型，自然调用的时访从t1的方法中搜索指定的方法
     System.out.println(ttt.printA());可能不是很正确，但学习了js以后再看这些继承，感觉比以前清晰多了

Answer 12

子类继承父类时，在没有改变父类的情况下就是父类自己的事了。因为printA()并没有被子类覆写，所以printA()里的i自然就是public class t1中的i了。
若class t2里有override printA()的话，那结果就会不同了。
  static class t2 extends t1{
     int i=100;
     @Override
      public int printA(){
          return i;
      }

     public int printB(){
         return i;
     }
     public void printC(){
     {System.out.println(super.i);}
     }
  }

Answer 13

不完全吧。正确的解释我觉得应该是overwrite只能针对方法而不能针对变量。

Answer 14

http://blog.csdn.net/dashi99/archive/2008/11/28/3400573.aspx

Answer 15

父类没有printA方法，重写不针对全局变量。

Answer 16

t1  t=new t1();
t2 tt=new t2();
tt.printC();    //super.i是5这个应该都没问题.
System.out.println(tt.printB());  //t2的i是100也没问题.
System.out.println(t.printA());   //t1的i是5大家都不会有问题.
System.out.println(tt.printA());  //tt.printA()调用的是从t1继承过来的printA方法,而printA里面的i是指t1类的i,因为变量不会被覆盖
t1 ttt=(t1)tt;
System.out.println(ttt.printA()); //ttt这个引用指向的对象和tt指向的对象是同一个对象,调用printA方法,结果毫无疑问跟第4个一样.

Answer 17

t1  t=new t1(); 
t2 tt=new t2(); 
tt.printC();    //5 
System.out.println(tt.printB());  //100 
System.out.println(t.printA());  //5 
System.out.println(tt.printA());  //5。判断子类中没有printA()方法时,子类调用父类中的printA()方法,于是输出5.
                                 //当在子类中重写了printA()方法时则输出100.
t1 ttt=(t1)tt; 
System.out.println(ttt.printA()); //5。这里虽然父类引用指向了子类对象,但没有在子类中重写printA()方法,所以不能形成多态;所以输出5.
                                  //当在子类中重写了printA()方法时则输出100.
子类重写父类的printA()方法后：
 public class TestExtend{
  static class t1 {
      int i=5;
      public int printA(){
          return i;
      }
   }
  static class t2 extends t1{
     int i=100;
     public int printA(){
         return i;
     }
     public int printB(){
         return i;
     }
     public void printC(){
         {System.out.println(super.i);}
     }
  }
 
      public static void main(String[] args){
          t1  t=new t1();
          t2 tt=new t2();
          tt.printC();//5
          System.out.println(tt.printB());//100
          System.out.println(t.printA());//5
          System.out.println(tt.printA());//100
          t1 ttt=(t1)tt;
          System.out.println(ttt.printA());//100
      }
  }
运行结果：
5
100
5
100
100
如果上面解释有不对的地方，还望高人指点下哈~~~

Answer 18

静态的类可以直接调用的，它里面的的print方法不是静态的，所以需要创建对象。。
  这代码没错。。一楼。

Answer 19

第一次见main函数这样写。

Answer 20

想要 t2的实力变量 打印100，可以看看下边的方法public class TestVariableHide {
    static class t1 {
        int i = 5;        public int printA() {
            return i;
        }
    }    static class t2 extends t1 {
     // 对父类变量的重新定义
     public t2()
       {
        i=100;
      }
       
        public int printB() {
            return i;
        }        public void printC() {
            {
                System.out.println(super.i);
            }
        }
    }    public static void main(String... args) {
        t1 t = new t1();
        t2 tt = new t2();
        tt.printC();//打印t1.i
        System.out.println(tt.printB());//打印t2.i
        System.out.println(t.printA());//打印t1.i
        System.out.println(tt.printA());打印t1.i
        t1 ttt = (t1) tt;
        System.out.println(ttt.printA());//打印t1.i
    }
}

Answer 21

package org.itstar.flowershop.utils;public class TestVariableHide {
  static class t1 {
      int i=5;
      public int printA(){
          return i;
      }
      }
  static class t2 extends t1{
     int i=100;
     public int printB(){
         return i;
     }
     public void printC(){
     {System.out.println(super.i);}
  }
  }
  public static void main(String...args){
     t1  t=new t1();
     t2 tt=new t2();
     tt.printC();  //5
     System.out.println(tt.printB()); //100
     System.out.println(t.printA()); //5
     System.out.println(tt.printA()); //5
     t1 ttt=(t1)tt;
     System.out.println(ttt.printA()); //5
  }
  }