Java课堂疑问解答与思考5

一：运行 TestInherits.java 示例，观察输出，总结。

TestInherits.java

class Grandparent
{

　　public Grandparent()
　　{

　　　　System.out.println("GrandParent Created."）;

　　}

public Grandparent(String string)
　　{

　　　　System.out.println("GrandParent Created.String:" + string);
　　}

}

class Parent extends Grandparent
{

public Parent()

　　{

　　　//super("Hello.Grandparent.");

　　　System.out.println("Parent Created");
　　// super("Hello.Grandparent.");

　　}

}

 

class Child extends Parent
{

public Child()
　　{
　　　System.out.println("Child Created");

　　}

}

 

public class TestInherits
{

　　public static void main(String args[])
　　{

　　　　Child c = new Child();
　　}

}

总结：

通过 super 调用基类构造方法，必须是子类构造方法中的第一个语句。否则会报错。运行结果如下：

为什么子类的构造方法在运行之前，必须调用父类的构造方法？能不能反过来？为什么不能反过来？

答：

构造一个对象，先调用其构造方法，来初始化其成员函数和成员变量。
子类拥有父类所有的变量及方法，父类没有子类的部分变量和方法。
如果不调用，则从父类继承而来的成员变量和成员方法得不到正确的初始化。
不能反过来调用也是这个原因，因为父类根本不知道子类有神魔变量而且这样一来子类也得不到初始化的父类变量，导致程序运行出错！

 二、直接输出一个不可变的类的对象，会有什么结果？

程序源码示例：

class A{}

public class ExplorationJDKSource {

　　public static void main(String[] args) {
　　　　System.out.println(new A());
　　}

}

运行结果：类型名+@+随机数

原因：

main方法实际上调用的是祖类函数： public void println(Object x)，这一方法内部调用了String类的valueOf方法。

valueOf方法内部又调用Object.toString方法：

hashCode()方法是本地方法，由JVM设计者实现： public native int hashCode();

所以通过层层调用结果就显示出了      类名+@+哈希值。

三、我们来看Fruit.java 代码，总结原因。

Fruit.java

public class Fruit
{
　　public String toString()
　　{
　　　　return "Fruit toString.";
　　}

　　public static void main(String args[])
　　{
　　　　Fruit f=new Fruit();
　　　　System.out.println("f="+f);
　　　　// System.out.println("f="+f.toString());
　　}
}

运行结果：

总结：

Fruit类覆盖了Object类的toString方法。

在“+”运算中,当任何一个对象与一个String对象，连接时，会隐式地调用其toString()方法，默认情况下，此方法返回“类名 @ + hashCode”。为了返回有意义的信息，子类可以重写toString()方法。

四、

现在有三个类:

class Mammal{}

class Dog extends Mammal {}

class Cat extends Mammal{}

针对每个类定义三个变量并进行初始化

Mammal m=null ;

Dog d=new Dog();

Cat c=new Cat();

下列语句哪一个将引起编译错误?为什么?哪一个会引起运行时错误?为什么?

m=d;

d=m;

d=(Dog)m;

d=c;

c=(Cat)m;

答：程序运行结果

第二行与第四行出错。

将父类赋值给子类时需要强制转化，子类赋值给父类时不用强制转化。父类的两个子类相互赋值时也必须强制转化。

五、请看下面的“变态”类。程序运行结果是什么？你如何解释会得到这样的输出？ 计算机是不会出错的，之所以得 到这样的运行结果也是有原因的， 那么从这些运行结果中，你能总 结出Java的哪些语法特性？

程序源码：

class Parent{
　　public int myValue=100;
　　public void printValue() {
　　　　System.out.println("Parent.printValue(),myValue="+myValue);
　　}
}
class Child extends Parent{
　　public int myValue=200;
　　public void printValue() {
　　System.out.println("Child.printValue(),myValue="+myValue);
　　}
}
public class Fruit
{
　　public static void main(String[] args) {
　　　　Parent parent=new Parent();
　　　　parent.printValue();
　　　　Child child=new Child();
　　　　child.printValue();

　　　　parent=child;
　　　　parent.printValue();

　　　　parent.myValue++;
　　　　parent.printValue();
　　
　　　　((Child)parent).myValue++;
　　　　parent.printValue();

　　}
}

运行结果：

总结：

当子类与父类拥有一样的方法，并且让一个父类变量引用一个子类对象时，到底调用哪个方法，由对象自己的“真实”类型所决定，这就是说：对象是子类型的，它就调用子类型的方法，是父类型的，它就调用父类型的方法。 这个特性实际上就是面向对象“多态”特性的具体表现。

如果子类与父类有相同的字段,则子类中的字段会代替或隐藏父类的字段，子类方法中访问的是子类中的字段（而不是父类中的字段）。如果子类方法确实想访问父类中被隐藏的同名字段，可以用super关键字来访问它。 如果子类被当作父类使用,则通过子类访问的字段是父类的!