继承，多态，接口与抽象类学习总结

一，继承

动手实验_1：

题目：运行 TestInherits.java 示例，观察输出，注意总结父类与子类之间构造方法的调用关系修改Parent构造方法的代码，显式调用GrandParent的另一个构造函数，注意这句调用代码是否是第一句，影响重大！

TestInherits.java：

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

结论：

1，子类的构造方法在运行之前，必须调用父类的构造方法。

2，通过 super 调用基类构造方法，必须是子类构造方法中的第一个语句。

（注：super的用法：（1）调用父类的构造方法（2）操作被隐藏的成员变量和被覆盖的成员方法）

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

答：

构造函数（constructor）是一种特殊的方法 。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中 。构造一个对象，先调用其构造方法，来初始化其成员函数和成员变量。子类拥有父的成员变量和成员方法，如果不调用，则从父类继承而来的成员变量和成员方法得不到正确的初始化。不能反过来调用也是这个原因，因为父类根本不知道子类有神魔变量而且这样一来子类也得不到初始化的父类变量，导致程序运行出错！
2，探索技术的奥秘：参看ExplorationJDKSource.java示例并运行得到了一个奇特的运行结果： A@1c5f743版）为什么？
曲折的探索之路：
（1）使用javap –c命令反汇编ExplorationJDKSource.class；

（2）阅读字节码指令，弄明白println()那条语句到底调用了什么？

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

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

public String toString(){

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

}

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

3，神奇的“+”号

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

结论：

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

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

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

在子类中，若要调用父类中被覆盖的方法，可以使用super关键字。

Test.java

class fu{
    void fun() {
        System.out.println("父类——fun()");
    }
}
class zi extends fu{
    void fun() {
        super.fun();
    }
}
public class Test1 {
    public static void main(String[] args) {
        zi t1=new zi();
        t1.fun();
    }

}

二，多态

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

ParentChildTest.java

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

问题：

1. 上边的程序运行结果是什么？

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

前两行正常，

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

第四行，parent=child;仅仅是将parent中有的值用child的值代替，所以parent.myValue++;parent只有一个自己的myValue值，而输出的是child的myValue。

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

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

总结：

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

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

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

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

继承，多态，接口与抽象类学习总结

猜你喜欢