超类引用和子类对象

•
如你所知,Java是一种类型严格的语言.除了用于基本类型的标准转换和自动升级,类型兼容也是被严格执行的.因此,一个类类型的引用变量通常不能引用一个其他类型的对象.例如,考虑下面的程序:
  1. public class test2
  2. {
  3. // @param args
  4. public static void main(String args[])
  5. {
  6. X x = new X(10);
  7. X x2;
  8. Y y = new Y(5);
  10. x2 = x;//ok, both of same type
  11. x2 = y;//error not of same type
  12. }
  13. }
  14. class X
  15. {
  16. int a;
  17. X(int i){ a = i;}
  18. }
  19. class Y
  20. {
  21. int a;
  22. Y(int i){ a = i;}
  23. }
public class test2
{
    // @param args
    public static void main(String args[])
    {
     X x = new X(10);
     X x2;
     Y y = new Y(5);
     
     x2 = x;//ok, both of same type
     x2 = y;//error not of same type
    }
}
class X
{
    int a;
    X(int i){ a = i;}
}
class Y
{
    int a;
    Y(int i){ a = i;}
}
这里,尽管X类和Y类本质上是一样的,但是不能把一个Y对象赋值给一个X引用,因为他们的类型不同.总之,对象引用变量只能引用自己类型的对象.
然而,Java的严格类型却有一个例外,即可以把对超类派生子类对象的引用赋给一个超类的引用变量.换句话说,超类引用可以引用子类对象,如下所示:
  1. public class test2
  2. {
  3. // @param args
  4. public static void main(String args[])
  5. {
  6. X x = new X(10);
  7. X x2;
  8. Y y = new Y(5);
  10. x2 = x;//ok, both of same type
  11. x2 = y;//still ok,because y is derived form x
  12. // x2.b = 1; // error x doesn't have a b member
  13. }
  14. }
  15. class X
  16. {
  17. int a;
  18. X(int i){ a = i;}
  19. }
  20. class Y extends X
  21. {
  22. int b;
  23. Y(int i)
  24. {
  25. super(i);
  26. b = i;
  27. }
  28. }
public class test2
{
    // @param args
    public static void main(String args[])
    {
     X x = new X(10);
     X x2;
     Y y = new Y(5);
     
     x2 = x;//ok, both of same type
     x2 = y;//still ok,because y is derived form  x
     // x2.b = 1; // error x doesn't have a b member
    }
}
class X
{
    int a;
    X(int i){ a = i;}
}
class Y extends X
{
    int b;
    Y(int i)
    {
        super(i);
        b = i;
    }
}
这里,X派生了Y,所以允许赋给x2一个对Y对象的引用.
哪些成员可以访问是由引用变量的类型(而不是他引用的对象类型)决定的,理解这一点十分重要.也就是说,当一个子类对象的引用被赋给一个超类引用变量时,只有权访问对象的那些超类定义的部分.这就是为什么即使x2引用了一个Y对象后,还不能访问b的原因.考虑一下就会发现这是合理的,因为超类不知道子类增加了什么,这也就是程序中代码的最后一行被注释调的原因.
尽管前面的讨论看似深奥,但却有一些重要的实际用途.我们这里就其中一点进行介绍,其他的将在后面设计方法重写时讨论.
把子类引用赋给超类变量常用于在类层次结构中调用构造函数时.如你所知,对于类而言,定义一个把类的对象作为形参的构造函数是很常见的.这就允许类构造对象的副本.这种类的子类就可以利用这一功能,例如,考虑下面的X和Y.这两个类都添加了把对象作为形参的构造函数.
  1. public class test2
  2. {
  3. // @param args
  4. public static void main(String args[])
  5. {
  6. Y one = new Y(10);
  7. Y two = new Y(one);
  9. System.out.println("one.a="+one.a+" one.b="+one.b);
  10. System.out.println("two.a="+two.a+" two.b="+two.b);
  12. }
  13. }
  14. class X
  15. {
  16. int a;
  17. X(int i){ a = i;}
  18. X(X obj)
  19. {
  20. a = obj.a;
  21. }
  22. }
  23. class Y extends X
  24. {
  25. int b;
  26. Y(int i)
  27. {
  28. super(i);
  29. b = i;
  30. }
  32. Y(Y obj)
  33. {
  34. super(obj.a);
  35. b = obj.b;
  36. }
  37. }
public class test2
{
    // @param args
    public static void main(String args[])
    {
     Y one = new Y(10);
     Y two = new Y(one);
     
     System.out.println("one.a="+one.a+"  one.b="+one.b);
     System.out.println("two.a="+two.a+"  two.b="+two.b);
     
    }
}
class X
{
    int a;
    X(int i){ a = i;}
    X(X obj)
    {
        a = obj.a;
    }
}
class Y extends X
{
    int b;
    Y(int i)
    {
        super(i);
        b = i;
    }
    
    Y(Y obj)
    {
        super(obj.a);
        b = obj.b;
    }
}
输出:
  1. one.a=10 one.b=10
  2. two.a=10 two.b=10
one.a=10 one.b=10
two.a=10 two.b=10
该程序中,通过one构造了two,因此他们是一样的.