JAVA.SE面向對象（多態）

1.多態

1.1多態的概述

面向對象的三大特徵：
封裝，繼承，多態
多態：同一個事物的不同表現形式，同一個對象不同的表現形態

1.2多態的前提條件

必須有繼承或者實現關係
必須有方法的重寫
父類的類型指向了子類的類型

Fu f = new Zi();
接口 類名 = new 實現類（）；

1.3 多態方法的特徵

編譯看父類，運行看子類
或者說編譯看左邊，運行看右邊

	Animal 動物類  Dog 狗類 
    Animal an1 = new Dog();  

	Animal 動物類  Cat 貓類 
    Animal an2 = new Cat();
    package com.ithema.Text04;

public abstract class Fu {
    private  String name;
    private int age;

    public Fu() {
    }

    public Fu(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println("父類的喫飯！");
    }
    public void drink() {
        System.out.println("父類的喝水");

    }

    public abstract void fly();
    @Override
    public String toString() {
        return "Fu{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.ithema.Text04;

public interface Fu01 {
    public abstract void swim();

    void pingpang();
}
package com.ithema.Text04;

public class shixian implements Fu01 {

    @Override
    public void swim() {
        System.out.println("實現類的swim");
    }

    @Override
    public void pingpang() {
        System.out.println("實現類的pingpang");
    }
}
package com.ithema.Text04;

public class Zi extends Fu {
    public Zi() {
    }

    public Zi(String name, int age) {
        super(name, age);
    }

    @Override
    public void fly() {
        System.out.println("子類的實現類飛");

    }

    @Override
    public void drink() {
        super.drink();
    }

    @Override
    public void eat() {
        super.eat();
    }
}
package com.ithema.Text04;

public class Zi02 extends Fu {
    public Zi02() {
    }

    public Zi02(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        super.eat();
    }

    @Override
    public void drink() {
        super.drink();
    }

    @Override
    public void fly() {
        System.out.println("子類02的飛");
    }
}
package com.ithema.Text04;

public class Demo01 {
    public static void main(String[] args) {
        Fu f = new Zi("張三",18);
        f.drink();
        f.eat();
        f.fly();
        System.out.println(f);
        Fu f1 = new Zi02("李四",20);
        System.out.println(f1);
        f1.eat();
        f1.fly();
        f1.drink();
    }
}

1.4多態的好處

提高了代碼的靈活性
提高了代碼的拓展性

1.5多態的弊端

使用父類只能調用父類子類都有的方法，不能調用子類特有方法

1.6多態的弊端解決方案

把子類轉換爲父類（向下轉型）

	 Animal an = new Dog();
        an.eat();
        //2.向下轉型
        Dog dd = (Dog)an;
        dd.看家();

## 1.7instanceof關鍵字的作用
可以判斷是否爲指定對象

package com.ithema.Text05;

public class Animal {
    public void eat() {
        System.out.println("父類的喫");

    }

}
package com.ithema.Text05;

public class Cat extends Animal {
    public void takemouse() {
        System.out.println("捉老鼠");
    }
}
package com.ithema.Text05;

public class Dog extends Animal {
    public Dog() {
    }
    public void kanjia() {
        System.out.println("狗看家");
    }

}

package com.ithema.Text05;

public class Demo01 {
    public static void main(String[] args) {
        Animal d = new Dog();
        Animal c = new Cat();
       // Cat c2 = (Cat) c;

        d.eat();
       // Dog d2 = (Dog) d;
        //
        if (d instanceof Dog) {
            Dog d1 = (Dog) d;
            d1.kanjia();


        }
        if (c instanceof Cat) {
            Cat c1 = (Cat) c;
            c1.takemouse();
        }
    }
}