继承与多态课后动手动脑问题总结

一、继承

1、题目

运行 TestInherits.java 示例，观察输出，注意总结父类与子类之间构造方法的调用关系修改Parent构造方法的代码，显式调用GrandParent的另一个构造函数，

注意这句调用代码是否是第一句，影响重大！

代码如下：

class Grandparent {
    public Grandparent(){
          System.out.println("GrandParent Created.");    
}
    public Grandparent(String string) {
            System.out.println("GrandParent Created.String:" + string)；    
 }
}
class Parent2 extends Grandparent{
    public Parent2(){
            super("Hello.Grandparent.");
            System.out.println("Parent Created");
       // super("Hello.Grandparent.");
      }
}
class Child2 extends Parent2 {
    public Child2()  {
        System.out.println("Child Created");
      }
}

public class TestInherits {
    public static void main(String args[]) {
            Child2 c = new Child2();
  }
}

 

2、运行截图

 

 

 

 

3、结论：

1、子类的构造方法在执行之前，必须先调用父类的构造方法

2、通过 super 调用父类构造方法，super必须是子类构造方法中编写的第一个语句

3、super本身就是调用父类的构造方法，而且可以执行父类被隐藏的成员变量和被覆盖的父类成员方法

 

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

5、解答：不能，子类拥有父类的成员变量和成员方法，如果不调用父类的构造方法，则从父类继承而来的成员变

量和成员方法不能进行初始化。而不能反过来调用原因是，因为父类不能知道子类有什么成员变量和成员方法

并且这样做子类不能在父类帮助下完成继承来的成员变量的初始化，导致成员变量无法初始化，程序就会报错，

无法执行。

 

二、探索技术的奥秘：参看ExplorationJDKSource.java示例并运行得到了一个奇特的运行结果： Test1.A@8efb846 为什么？

1、代码

package Test1;


public class test1 {

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

}

class A{}

 

 

 

 

2、使用javap –c命令反汇编ExplorationJDKSource.class；

 

 

 

3、查看字节码指令，搞清楚到底为什么输出了Test1.A@8efb846？

前面程序中，main方法实际上调用的是： public void println(Object x)，这一方法内部调用了String类的valueOf方法。

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

而Object.toString方法的代码是：

public String toString(){

return getClass().getName() +"@" + Integer.toHexString(hashCode());

}

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

 

三、神奇的“+”号

1、代码

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());
    }
}

 

2、运行结

 

 

 

3、结论

1、首先，Fruit类的toString方法覆盖了Object类的toString方法。

2、在“+”运算中,当任何一个对象与一个String对象进行连接时，会隐式地调用String对象的toString()方法，

默认情况下，toString方法返回“类名 @ + hashCode”。即Test1.A@8efb846这种形式，为了返回有意

义的信息，子类可以重写并覆盖toString()方法。

 

四、请自行编写代码测试以下特性（动手动脑）：

1、问题：在子类中，若要调用父类中被覆盖的方法，可以使用super关键字

2、代码

class test{
    void play() {
        System.out.println("我是父类test父");
    }
}

class test11 extends test{
    void play() {
        super.play();
    }
}
public class test1
{
    public static void main(String[] args) {
        test11 t=new test11();
        t.play();
    }
        
}

 

3、运行结果

 

 

五、多态

1、在实践中理解把握复杂的知识-1

（1）代码如下

public class ParentChildTest {
    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();
        
    }
}

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);
    }
}

 

（2）测试结果

 

 

2、你如何解释会得到这样的输出？

（1）原因：

前两行正常输出，父类对象调用父类的方法，子类对象调用子类的方法

第三行，当子类与父类拥有一样的方法，并且让一个父类变量引用一个子类对象时，到底调用哪个方法，由对象自己的“真实”类型所决定

第四行，当parent=child;仅仅是将parent中有的方法用child的方法代替，所以parent.myValue++;而输出的是child的printValue()，

而printValue()方法中输出的是child.myValue，所以输出的是child.myValue

第五行，强制类型转换，++作用在child的myValue，所以输出的也是child的myValue，而不是parent的myValue

 

3、计算机是不会出错的，之所以得 到这样的运行结果也是有原因的， 那么从这些运行结果中，你能总 结出Java的哪些语法特性？

(1)当子类与父类拥有一样的方法，并且让一个父类变量引用一个子类对象时，到底调用哪个方法，由对象自己的“真实”类型所决定，这就是说：对象是子类型的，它就调用子类型的方法，是父类型的，它就调用父类型的方法。

(2)这个特性实际上就是面向对象“多态”特性的具体表现。

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

(4)如果子类被当作父类使用,则通过子类访问的字段是父类的!