关于继承的一道面试题

Question

test引用中有两个i，为什么总是输出0，而不是2

Answer 1

想要看懂这段代码其实主要要理解继承方法访问变量的可见域的问题，楼主可以看看thinking in java，里面对继承说的很好。

Answer 2

很好的体现了多态啊，多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定，所以顺序一定是0200022，不会全是0，test2()只有在T1中有

Answer 3

 test引用中有两个i，为什么总是输出0，而不是2调用的是父类中的。

Answer 4

test引用中有两个i，为什么总是输出0，而不是2调用的是父类中的。
为什么调父类？求详解

Answer 5

谢谢您的解释要想建立一个子类的对象，就肯定要调用它的构造器啊，而构造器中默认的是super，所以会调用父类的构造器

Answer 6

test引用中有两个i，为什么总是输出0，而不是2
字段不具备多态，以静态类型确定。 前面两次的i输出都是0 ， 因为它们的静态类型为T1。

Answer 7

楼主可能被误导了。注意T2类中，我新添加的两行代码。public class T2 extends T1 { int i = 2; public void Test2() {
System.out.println(i);
} public static void main(String[] args) {
T1 test = new T2();
test.Test1();
test.Test2();
System.out.println(test.i);
test = (T2)test;
System.out.println(test.i);

//新添加的两行代码。
T2 test_1 = (T2)test;
System.out.println(test_1.i);

T2 test2 = new T2();
test2.Test1();
test2.Test2();
System.out.println(test2.i);
}
}

Answer 8

test引用中有两个i，为什么总是输出0，而不是2
字段不具备多态，以静态类型确定。 前面两次的i输出都是0 ， 因为它们的静态类型为T1。
谢谢，很好理解

Answer 9

给你点简单粗暴的：类的继承的知识点：
（1）java不支持多重继承，也就是说子类至多只能有一个父类 
（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法 
（3）子类中定义的成员变量和父类中定义的成员变量相同时，则父类中的成员变量不能被继承 
（4）子类中定义的成员方法，并且这个成员方法的名字，返回类型，及参数个数和类型与父类的某个成员方法完全相同，则父类的成员方法不能被继承。 

Answer 10

这段代码主要涉及的就是继承层面的上转型对象和下转型对象
上转型对象是将子类的对象赋值给父类的引用.上转型对象不能使用子类新增成员(包括成员变量,成员方法),只能使用子类重写父类的方法,被子类隐藏的父类变量;子类未重写的父类方法,未被隐藏的父类成员变量.下转型对象是将父类的对象赋值给子类的引用
public class T1 {     
  int i = 0;      
 public void Test1() {       
  System.out.println(i);    
 }      
 public void Test2() { 
        
System.out.println(i);     }
 }T1 test = new T2(); //构造上转型对象test
test.Test1();   //调用父类T1的Test1()方法
test.Test2();    // 调用子类重写父类的方法Test2()    
System.out.println(test.i); // 调用被子类隐藏的父类变量       
test = (T2)test;    //构造下转型对象test     
System.out.println(test.i); //   调用父类变量               
T2 test2 = new T2();    //构造子类对象test2     
test2.Test1();         //调用父类T1的Test1()方法
test2.Test2();        // 调用子类重写父类的方法Test2()
System.out.println(test2.i); //调用子类的变量

Answer 11

你可以试试 将T1的属性i 使用private 封装 然后使用getter 方法访问  你就会发现  T1 test = new T2();  test 访问i 的值就是 T2自己的属性  我这样说 你再想想 应该就会明白很多了 

Answer 12

说些题外话，这题目背后的思想真差。原因：
1、T1做为父类应该以抽象类的形式出现。
2、T1做为父类，其主要作用应该是复用代码，也就是复用Test1()和Test2()，而不是让什么子类覆盖这些代码。
3、如果想体现多态，T1应该是接口，而不是类。
4、T2的代码如果容易招致程序员错误的理解，那就不是好代码。

Answer 13

和接口是一个道理。你接口的实现类里增加新的变量或者实现类，都是没用用的。只有重写的override的才能被接口调用。但是，当你直觉New的这个实现类时，那么你就可以调用这个实现类中的新变量和方法了。

Answer 14

类的继承的知识点：
（1）java不支持多重继承，也就是说子类至多只能有一个父类 
（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法 
（3）子类中定义的成员变量和父类中定义的成员变量相同时，则父类中的成员变量不能被继承 
（4）子类中定义的成员方法，并且这个成员方法的名字，返回类型，及参数个数和类型与父类的某个成员方法完全相同，则父类的成员方法不能被继承。

Answer 15

test引用中有两个i，为什么总是输出0，而不是2test是谁的对象，T1的吧。用T1代进去，很明了吧

Answer 16

这个是多态的问题的，你可以参考一下java上下转型。

Answer 17

public class T2 extends T1 {
 
    int i = 2;
    public static void m1(){
     System.out.println("T2");
    }
 
    public void Test2() {
        System.out.println(this.i);
    }
 
    public static void main(String[] args) {
        T1 test = new T2();
        test.Test1();
        test.Test2();
        System.out.println(test.i);
        test = (T2)test;
        test.m1();
        System.out.println(test.i);
         
        T2 test2 = new T2();
        test2.Test1();
        test2.Test2();
        System.out.println(test2.i);
    }
}class T1 {
 
    int i = 0;
    
    public static void m1(){
     System.out.println("T1");
    }
 
    public void Test1() {
        System.out.println(this.i);
    }
 
    public void Test2() {
        System.out.println(this.i);
    }
}
希望对你有帮助.