Person父類

public class Person {
    private String name;
    private int age;

    public Person() {
        super();
    }   
    public Person(String name, int age) {
        super();
        setName(name);
        setAge(age);
    }

    public String getName() {
        return name;
    }
    public
 
 void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age > 0 && age < 150){
            this.age = age;
        }
        else{
            System.out.println("年齡不合理！！！");
        }
    }
    public
 
 void show(){
        System.out.println("我是" + getName() + ",今年" + getAge() + "歲了!");
    }
    public static void test(){
        System.out.println("Person類中的靜態方法");
    }

}

Student子類繼承Person父類

public class Student extends Person {
    private int id;

    public Student() {
        super();
    }

    public
 
 Student(String name, int age,int id) {
        super(name, age);
        setId(id);
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        if(id > 0){
            this.id = id;
        }else{
            System.out.println("學號不合理!!!");
        }
    }

    @Override
    public void show(){
        super.show();
        System.out.println("我的學號是: " + getId());
    }
    public static void test(){
        System.out.println("Person類中的靜態方法");
    }
}

測試類

public class TestPersonStudent {

    public static void main(String[] args){
        //使用父類的引用指向父親自己的物件
        Person p = new Person("zhangfei", 30);
        //呼叫Person類自己的show()方法
        p.show();

        System.out.println("----------------------");

        //使用子類自己的引用指向子類自己的物件
        Student s = new Student("guanyu", 35, 1001);
        //當子類中沒有show()方法時,則呼叫父類Person中的show()方法
        //當子類重寫show方法後,則呼叫子類Student自己的方法
        s.show();

        System.out.println("----------------------");
        //使用父類的引用指向子類的物件，形成多型
        //發生Student型別向Person型別的轉換，小範圍向大範圍轉換，自動型別轉換
        Person ps = new Student("liubei", 40, 1001);
        //解析:在編譯階段呼叫Person類的show()方法,在執行階段呼叫Student的show方法
        ps.show();

        System.out.println("-----------------------");

        //使用ps呼叫非靜態的方法進行測試
        //ps是Person型別自己的引用，因此可以呼叫Person型別自己的方法
        String str = ps.getName();
        System.out.println("獲取到姓名的是: " + str);//liubei

        //ps.getId(); error

        System.out.println("-----------------------");
        //使用ps呼叫靜態的方法進行測試,靜態的方法推薦使用類名. 的方式訪問
        //ps.test();
        Person.test();

        System.out.println("-----------------------");
        //如何實現子類中方法的呼叫呢?
        //Person型別向Student型別轉換,大 => 小,需要強制型別轉換
        //目標型別  變數名 = (目標型別)源型別的變數名;
        Student st = (Student)ps;
        int res = st.getId();
        System.out.println("res = " + res);

        //String sr = (String)ps; error
        //Teacher t = (Teacher)ps;//編譯通過,執行時型別轉換異常
        /* 如果修改的話
         * Person dd = new Teacher();  //使用父類的引用指向了子類的物件 這樣就正確了
         * Teacher t = (Teacher)dd; 
         * int ee = t.getSex();
         * System.out.println("性別是" + ee);
         * */       
        //判斷ps真正指向的物件型別是否為Teacher型別,若是則返回true,否則false
        if(ps instanceof Teacher){
            System.out.println("可以放心地進行強制型別轉換了...");
        }else{
            System.out.println("不能進行強制型別轉換!");
        }

    }
}

教師類

package xdl.day09;

public class Teacher extends Person {
/*    private int sex;

    public Teacher(){
        super();
    }
    public Teacher(int sex) {
        super();
        setSex(sex);
    }

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }
    public void show(){
        super.show();
        System.out.println("我的性別是"+getSex());
    }
  */  
}

多型：
多型就是指同一種事物表現出來的多種形態。
如：
飲料：可樂、雪碧、樂虎、脈動……
圖形：矩形、圓、三角形……
整數:byte b= 10; short s = 10; int i = 10;…

多型的語法格式：
父類型別 引用 = new 子類型別();
如:

Person p = new Student();
p.show();

解析：
在編譯階段p是Person型別，因此呼叫Person類自己的show()方法，若沒有則編譯報錯；
在執行階段p真正指向的物件是Student型別，因此最終呼叫Student類中自己的show()方法。

多型的效果
(1)對於指向子類物件的父類引用來說，在編譯階段只能直接呼叫父類的方法,不能直接呼叫子類。
(2)對於父子類都有的非靜態方法來說，最終呼叫子類的重寫版本；
(3)對於父子類都有的靜態方法來說，最終呼叫父類中的版本，與指向的物件型別無關；

引用型別之間的轉換
(1)引用型別之間的轉換必須發生在父子類之間，分為自動型別轉換 和 強制型別轉換；
(2)其中子類型別向父類型別的轉換需要發生自動型別轉換即可；
其中父類型別向子類型別的轉換需要發生強制型別轉換才可以；
(3)若沒有父子類關係發生強轉是則編譯報錯，當擁有父子類關係發展強轉是則編譯通過。
若目標型別不是該引用真正指向的型別時，在執行階段發生型別轉換異常；
(4)為了避免上述錯誤的發生，通常只有進行強制型別轉換就需要進行判斷，格式如下：

        if(引用變數名 instanceof 資料型別){
            System.out.println("可以放心地進行強制型別轉換了...");
        }else{
            System.out.println("不能進行強制型別轉換!");
        }
    //-判斷引用指向的物件是否為指定的資料型別，如是則返回true,否則返回false;

多型的意義
可以遮蔽不同子類的差異性編寫通用的程式碼，從而產生不同的效果。