1021课堂内容

　　一、动手实验。

1）　　　在子类调用时如果他是继承其父类时首先会先调用其父类的构造函数。

2）　　调用关系修改Parent构造方法的代码，显式调用GrandParent的另一个构造函数，注意这句调用代码是否是第一句。

public class TestInherits 
{

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

}


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("Parent Created");
            //super("Hello.Grandparent.");

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

      }

}



class Child extends Parent 
{


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

      }

}

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

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

一般在定义了一个类型之后，为了能使用它，必须把这个类型具体化，也就是指定为一个具体的对象。而构造函数就是从定义出发，建立与定义相对应的对象。用计算机语言来说，光有定义是不能使用，必须通过构造函数来分配内存空间给可使用的对象。

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

三

此示例中定义了一个类A，它没有任何成员：
class A { }
示例直接输出这个类所创建的对象
 public static void main(String[] args)    {
  System.out.println(new A());
}

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

四。神奇的+号

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

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

五 动手动脑

public class Fruit extends zo
{
        
    public void fun()
    {
        System.out.println("我jiao 这么帅气??");
    }

    public static void main(String args[])
    {
        Fruit f=new Fruit();
        f.fun();
    
    }
}
 class zo{
    public void fun()
    {
        System.out.println("ahahah");
    }
    
    
    
    
}

六

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

总结：

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

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

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

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