Java面向对象之多态

java面向对象三大特征：封装，继承，多态

多态的定义：

　　1、实现关系下的多态，接口的引用类型变量指向了接口实现类的对象

　　2、继承关系下的多态，父类的引用类型变量指向了子类的对象

继承关系下的多态：

　　我们定义一个动物类。并定义一个鸟类和老鼠类分别作为动物类的子类

public abstract class Animal {

    String name;

    public  Animal(String name){
        this.name = name;
    }

    public abstract void Run();
}
public class Bird extends Animal {

    public Bird(String name){
        super(name);
    }

    @Override
    public void Run() {
        System.out.println(name+"跑的不快。。。");
    }

    public void Fly(){
        System.out.println(name+"飞的高。。。");
    }
}

public class Mouse extends Animal {

    public Mouse(String name){
        super(name);
    }

    @Override
    public void Run() {
        System.out.println(name+"飞快的跑。。。");
    }

    public void Dig(){
        System.out.println(name+"会打洞。。。");
    }
}

　　这个时候可以使用多态：

public static  void  main(String[] args){
        Print(new Bird("百灵"));    ==  Animal a = new Bird("百灵")
        Print(new Mouse("家鼠"));   ==  Animal a = new Mouse("家鼠")       这就是多态的使用，父类的引用类型变量指向了子类的对象
    } 

    public  static  void  Print(Animal a){  、、定义一个方法，接受一个对象，根据对象类型执行对象的方法：
        if(a instanceof Mouse){
            Mouse m = (Mouse)a;    　　　　//多态情况下，因为不能访问子类特有的成员，，因为打洞是老鼠特有的成员函数，所以这里要使用强制类型转换，然后再去访问子类特有的成员。。。。。
            m.Dig();
        }else if(a instanceof Bird){
            Bird b = (Bird)a;
            b.Fly();
        }else{
            System.out.println("该动物未定义。。。");
        }
    }　

实现关系下的多态：

定义一个接口Dao，同时定义一个Dao接口的实现类UserDao

public interface Dao {　　　　//定义一个Dao接口

    public  void add();

    public  void  delete();
}

public class UserDao implements Dao{　　　　　　//定义接口的实现类，并对方法实现

    public  void  add(){
        System.out.println("添加成员成功！！");
    }

    @Override
    public void delete() {
        System.out.println("删除员工成功！！");
    }
}　　

调用该接口：

public static  void  main(String[] args){
        Dao d = new UserDao();      //实现关系下的多态  接口的引用类型变量指向了接口实现类的对象（对比于继承关系下的多态，父类的引用类型变量指向了子类的对象）
        d.add();
        d.delete();
    }

多态的注意事项：

　　1、多态情况下，子父类存在同名的成员变量时，访问的是父类的成员变量

　　2、多态情况下，子父类存在同名的非静态的成员函数时，访问的是子类的成员函数

　　3、多态情况下，子父类存在同名的静态的成员函数时，访问的是父类的成员函数

　　4、多态情况下，不能访问子类特有的成员