Java第七周课堂示例总结

一、super();调用基类构造方法

代码：

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("Parent2 Created");
               // super("Hello.Grandparent.");
     }
}
class Child2 extends Parent2 {
    public Child2() {
        System.out.println("Child2 Created");
      }
}
public class TestInherits {
    public static void main(String args[]){
            Child2 c = new Child2();
    }
}  

第一次运行结果：

 第二次：（super语句放在第一句）

 

 第三次运行结果：（super语句放在第二位）报错：super必须放在第一位

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

构造函数的作用是完成类的初始化，子类继承了父类的成员方法和成员变量，如果不首先调用，则从父类继承来的成员得不到初始化。

如果反过来调用，父类不知道子类的变量，并且子类中的部分从父类继承来的变量得不到正确的初始化，故顺序不能改变。

二、JVM的一种默认实现

请按照以下步骤进行技术探险：

（1）使用javap –c命令反汇编ExplorationJDKSource.class；

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

（3）依据第（2）得到的结论，使用Eclipse打开JDK源码，查看真正被执行的代码是什么

 原因：

前面示例中，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();

三、

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()方法。

四、方法覆盖

（1）覆盖方法的允许访问范围不能小于原方法。

（2）覆盖方法所抛出的异常不能比原方法更多。

（3）声明为final方法不允许覆盖。 例如，Object的getClass()方法不能覆盖。

（4）不能覆盖静态方法。

请自行编写代码测试以下特性：在子类中，若要调用父类中被覆盖的方法，可以使用super关键字。

 

 运行结果：

 五、多态

多态性的定义是：同一操作用于不同的类的实例，不同的类将进行不同的解释，最后产生不同的结果。即相同的一条语句，在不同的运行环境中可以产生不同的运行结果。

多态的最本质特征就是父类（或接口）变量可以引用子类（或实现了接口的类）对象。换句话说：子类对象可以被当成基类对象使用!

特别地，Java类库的最顶层类是Object。因此每个对象都可以赋值给Object变量。

子类对象可以直接赋给基类变量。 基类对象要赋给子类对象变量,必须执行类型转换, 其语法是: 子类对象变量=(子类名)基类对象名;

也不能乱转换。如果类型转换失败Java会抛出以下这种异常: ClassCastException

例子：

public class TestInstanceof
{
    public static void main(String[] args) 
    {
        //可以使用instanceof运算符判断一个对象是否可以转换为指定的类型：
        //声明hello时使用Object类，则hello的编译类型是Object，Object是所有类的父类
        //但hello变量的实际类型是String
        Object hello = "Hello";
        //String是Object类的子类，所以返回true。
        System.out.println("字符串是否是Object类的实例：" + (hello instanceof Object));
        //返回true。
        System.out.println("字符串是否是String类的实例：" + (hello instanceof String));
        //返回false。
        System.out.println("字符串是否是Math类的实例：" + (hello instanceof Math));
        //String实现了Comparable接口，所以返回true。
        System.out.println("字符串是否是Comparable接口的实例：" + (hello instanceof Comparable));
        String a = "Hello";
        //String类既不是Math类，也不是Math类的父类，所以下面代码编译无法通过
        //System.out.println("字符串是否是Math类的实例：" + (a instanceof Math));
    }
}

运行结果：

 

 六、“类型转换”知识点考核

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

class Mammal{}
class Dog extends Mammal {}
class Cat extends Mammal{}
public class TestCast
{
    public static void main(String args[])
    {
        Mammal m;
        Dog d=new Dog();
        Cat c=new Cat();
        m=d;
        //d=m;
        d=(Dog)m;
        //d=c;
        //c=(Cat)m;
    }
}

 解答：注释的三个语句皆会出现编译错误问题

12、14行为同一父类的子类对象不能相互转换，15行则是因为m对象之前已经被强转，所以不能再次转换。

七、子类和父类定义了一模一样的字段和方法

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. 你如何解释会得到这样的输出？ 3. 计算机是不会出错的，之所以得到这样的运行结果也是有原因的， 那么从这些运行结果中，你能总结出Java的哪些语法特性？

总结：

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

如果子类与父类有相同的字段,则子类中的字段会代替或隐藏父类的字段，子类方法中访问的是子类中的字段（而不是父类中的字段）。如果子类方法确实想访问父类中被隐藏的同名字段，可以用super关键字来访问它。 如果子类被当作父类使用,则通过子类访问的字段是父类的! 牢记：在实际开发中，要避免在子类中定义与父类同名 的字段。不要自找麻烦！——但考试除外，考试 中出这种题还是可以的。