java多态相关知识点

定义

多态： 是指同一行为，具有多个不同表现形式。

实现多态的前提

1. 继承extends或者实现implements【二选一】
2. 方法的重写【意义体现：不重写，无意义】
3. 父类引用指向子类对象【格式体现】

多态的格式

父类类型 变量名 = new 子类对象；
变量名.方法名();
//父类类型：指子类对象继承的父类类型，或者实现的父接口类型

Fu f = new Zi();
f.method();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写
后方法。（先编译看父类后运行看子类）

//定义父类
public abstract class Animal {
	public abstract void eat();
}

//定义子类一
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
}
//定义子类二
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

//定义测试类
public class Test {
    public static void main(String[] args) {
        Animal cat=new Cat();
        cat.eat();

        Animal dog=new Dog();
        dog.eat();

    }
}

多态中成员变量的使用特点

Fu obj=new Zi(); //使用多态的方法，父类引用指向子类对象
obj.num; //指的是父类的num值

访问成员变量的两种方式：

1.直接通过对象名称来访问成员变量，看等号左边是谁就优先用谁，没有则向上找。

2.简接通过成员方法访问成员变量，看该方法属于谁，就优先用谁，没有就向上找。

多态中成员方法的使用特点

在多态的代码中，成员方法的访问规则是：

​ 看new的是谁，就优先用谁，没有则向上找

注意点：

​ 编译看左边，运行看右边（指成员方法）

obj.methodZi(); //methodZi()是子类特有方法，不能通过多态定义格式来调用

成员变量是编译和运行都看左边。

多态的好处

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展
性与便利。

引用类型转换

多态的转型分为向上转型与向下转型两种：

向上转型

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型。

使用格式：

父亲类型 变量名=new 子类类型（）；
如：Animal a=new Cat();   //含义：右侧创建一个对象，把它当作父类类看待

注意事项：向上转型是安全的不会出现异常

向下转型

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：

子类类型 变量名=（子类类型）父类变量名；
如：Cat c=（Cat）a; //含义：将父类对象，【还原】成为本来的子类对象

为什么进行向下转型？

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥
**有，而父类没有的方法。**编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子
类特有的方法，必须做向下转型。

//定义父类
public abstract class Animal {
    public abstract void eat();
}

//定义子类一
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }

    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}
//定义子类二
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }

    public void watchHouse(){
        System.out.println("看家");
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        Animal a=new Cat();
        a.eat();
//     a.catchMouse();  不能调用子类独有方法

        Cat cat=(Cat)a;
        cat.catchMouse();
    }

}

转型的异常

向下转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

public class Test {
    public static void main(String[] args) {
        Animal a=new Cat();
        a.eat();   
//     a.catchMouse();  不能调用子类独有方法


        Dog d=(Dog)a;
        d.watchHouse();  //调用的是Dog的方法,产生异常
    }

}

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了
Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

解决转型的异常

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

public class Test {
    public static void main(String[] args) {
        // 向上转型
        Animal a = new Cat();
        a.eat(); // 调用的是 Cat 的 eat
        // 向下转型
        if (a instanceof Cat){
            Cat c = (Cat)a;
            c.catchMouse(); // 调用的是 Cat 的 catchMouse
        } else if (a instanceof Dog){
            Dog d = (Dog)a;
            d.watchHouse(); // 调用的是 Dog 的 watchHouse
        }
    }
}

instanceof Cat){
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
} else if (a instanceof Dog){
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse
}
}
}