03_继承与多态——动手动脑

1、运行代码

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

}

TestInherits.java

　　运行结果：

　　　　

　　总结：Java构造函数的调用是按照顺序来的，如果不先构造父类，又何来子类，子类是继承父类的，首先得知道父类里面有什么，才能继承，其次，父类只有自己的东西，子类的元素父类是不知道的，所以，先构造子类是不和语法的。

2.运行代码

package Test;
public class ExplorationJDKSource {

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

}

class A{}

ExplorationJDKSource.java

运行结果：

　　

总结：其实类可以做到输出，是因为我们的写每一个类，都是默认继承Object类！所以Object类里的方法名称都得到了继承！而System.out实际上是Object的一个子类PrintStream,而这个子类内部定义了一个public static void println(String ...)；的方法传进来的大类参数就会调用父类的toString方法，改成String类型并输出。而该方法如下： public String toString() { return getClass().getName() +"@" + Integer.toHexString(hashCode()); } hashCode方法是本地方法，由JVM设计者实现： public native int hashCode();所以出现上述结果。

3.运行代码

package Test;
public class TestInstanceof
{
    public static void main(String[] args) 
    {
        //声明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));
    }
}

运行结果：

4.运行代码

public class ParentChildTest {
    public static void main(String[] args) {
        Parent parent=new Parent();
        parent.printValue();//Parent.printValue(),myValue=100
        Child child=new Child();
        child.printValue();//Child.printValue(),myValue=200
        
        parent=child;
        parent.printValue();//Child.printValue(),myValue=200
        
        parent.myValue++;
        parent.printValue();//Child.printValue(),myValue=200
        
        ((Child)parent).myValue++;
        parent.printValue();//Child.printValue(),myValue=201
        
    }
}

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

ParentChildTest.java

运行结果：

结论：

当子类与父类拥有一样的方法，并且让一个父类变量引用一个子类对象时，到底调用哪个方法，由对象自己的“真实”类型所决定，这就是说：对象是子类型的，它就调用子类型的方法，是父类型的，它就调用父类型的方法。这个特性实际上就是面向对象“多态”特性的具体表现。如果子类与父类有相同的字段,则子类中的字段会代替或隐藏父类的字段，子类方法中访问的是子类中的字段（而不是父类中的字段）。如果子类方法确实想访问父类中被隐藏的同名字段，可以用super关键字来访问它。如果子类被当作父类使用,则通过子类访问的字段是父类的!

5.代码验证

package second;

class Parent

{

    public int value=100;
    
public void Introduce()
    {

            System.out.println("I'm father");

        }


}

class Son extends Parent
{

    public int value=101;

         public void Introduce()
    {

            System.out.println("I'm son");
    
}

}


class Daughter extends Parent
{

    public int value=102;
    public void Introduce()
    {

            System.out.println("I'm daughter");
    
}

}

public class TestPolymorphism
{


    public static void main(String args[])
    {

        Parent p=new Parent();

        p.Introduce();

        System.out.println(p.value);

        p=new Son();

        p.Introduce();

        System.out.println(p.value);

        p=new Daughter();

        p.Introduce();

        System.out.println(p.value);


    }


}

运行结果：