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