本文介绍了Java中的多态性，包括多态的概念（同一件事在不同对象上有不同表现），实现条件（继承、重写和通过父类引用调用方法），以及多态的体现。重写是子类对父类方法的重新实现。文章还讨论了向上转型（父类引用指向子类对象）和向下转型（父类引用转为子类引用）及其应用场景，强调了多态带来的代码灵活性和扩展性。
目录
1. 多态概念
2. 多态的体现和实现条件
3. 重写
4. 引用类型转换
4.1向上转型
4.2向下转型
5. 多态的好处
1.多态的概念
什么是多态?
多态是继封装, 继承之后, 面向对象的三大特性
在生活中,比如跑的动作,猫,狗和大象,跑起来都不一样.再比如飞的动作，昆虫、鸟类和飞机，飞起来也 是不一样的。通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态
概念:总的来说, 同一件事情，发生在不同对象身上，就会产生不同的结果。
2. 多态的体现和实现条件
多态体现的格式:
父类类型 变量名 = new 子类对象();
变量名.方法名();
这里的父类类型指的是子类继承了父类, 或者实现的父类接口类型.
代码如下:
F f = new Z();
f.method();
在使用多态方式调用方法时，首先检查的是是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写 后方法。
代码如下:
//苹果义父类
class Animal{
public String name;
public void eat(){
System.out.println("正在吃饭");
}
}
//定义子类
class Cat extends Animal{
public Cat(String name){
this.name = name;
}
@Override
public void eat() {
System.out.println(name+"吃鱼");
}
}
class Dog extends Animal{
public Dog(String name){
this.name = name;
}
@Override
public void eat() {
System.out.println(name+"吃狗粮");
}
}
//定义测试类
public class Test {
public static void main(String[] args) {
// 多态形式，创建对象
Animal animal = new Cat("猫");
// 调用的是 Cat 的 eat的方法
animal.eat();
Animal animal1 = new Dog("狗");
// 调用的是 都给 的 eat的方法
animal1.eat();
}
}
注意
多态的实现条件
必须满足以下几个条件, 缺一不可:
- 必须要在继承下
- 子类必须对父类中的方法进行重写
- 要通过父类的引用调用重写的方法
3. 重写
什么是重写?
重写也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程 进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定 于自己的行为。 也就是说子类能够根据需要实现父类的方法。
@Override是覆盖的意思,也就是重写的意思
方法重写的条件
- 方法名相同
- 方法的参数列表相同(指个数, 类型, 顺序相同)
- 方法的返回值相同
- 不能重写static修饰的方法
- 不能重写private修饰方法
- 子类的访问修饰符要大于等于父类的访问修饰符, 什么意思呢? 如下图:
修饰符前后大小: public > protected > default
静态绑定: 编译的时候 就确定了最终要调用的方法。重载其实就是静态绑定。比如
动态绑定: 运行时绑定，即在编译时，还是调用的是父类的方法，等到程序运行的时候,程序发生了动态绑定。比如向上转型就是发生了动态绑定
什么是向上转型下面有讲
4. 引用类型转换
多态的转型分为向上转型与向下转型两种：
4.1 向上转型
向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的
当父类类型引用子类对象时, 这个过程便是向上转型.
使用格式:
父类类型 变量名 = new 子类类型();
如：Animal a = new Dog();
使用场景:
- 直接赋值
- 方法传惨
- 方法返回
代码如下:
class Animal{
public String name;
void eat(){
System.out.println("正在吃饭");
}
}
class Cat extends Animal{
public Cat(String name) {
this.name = name;
}
@Override
void eat() { //默认修饰符为default
System.out.println(name+"吃鱼");
}
}
class Dog extends Animal {
public Dog(String name) {
this.name = name;
}
@Override
public void eat() {
System.out.println(name + "吃狗粮");
}
}
public class Test {
//第二种:方法传参,形参为父类类型引用，可以接收任意子类的对象
public static void eatFood(Animal animal) {
animal.eat();
}
//第三种: 作返回值, 返回任意子类对象
public static Animal buyAnimal(String var){
if ("狗" == var){
return new Dog("狗狗");
}else if ("猫" == var){
return new Cat("猫猫");
}else {
return null;
}
}
public static void main(String[] args) {
/*向上转型*/
//第一种:直接赋值
Animal animal1 = new Dog("狗");
animal1.eat();//动态绑定
eatFood(new Dog("狗"));//把子类作为参数传过去
animal1 = buyAnimal("狗");
animal1.eat();
}向上转型的优点：让代码实现更简单灵活。
向上转型的缺陷：不能调用到子类特有的方法。
4.2 向下转型
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
使用格式：
子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;
前面有说在使用多态方式调用方法时，首先检查的是是否有该方法，如果没有，则编译错误；也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子 类特有的方法，必须做向下转型。
转型演示，代码如下：
调用就是子类的方法
不过向下转型不安全, 转型的过程中，一不小心就会遇到这样的问题，请看如下：
可以看出来段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Dog类型对象，运行时，当然不能转换成Cat对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。
为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：
变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。
所以，转换前，我们最好先做一个判断，代码如下：
public class Test {
public static void main(String[] args) {
Animal a = new Cat();
// 向下转型
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
}
}
} 
5. 多态的好处
实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展 性与便利。代码如下：
//定义父类
public abstract class Animal {
public abstract void eat();
}
//定义子类
public void eat() {
System.out.println("吃鱼");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
}
public class Test {
public static void showCatEat (Cat c){
c.eat();
}
public static void showDogEat (Dog d){
d.eat();
}
public static void showAnimalEat (Animal a){
a.eat();
}
public static void main(String[] args) {
// 多态形式，创建对象
Cat c = new Cat();
Dog d = new Dog();
// 调用showCatEat
showCatEat(c);
// 调用showDogEat
showDogEat(d);
/*
以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代而执行效果一致
*/
showAnimalEat(c);
showAnimalEat(d);
}
}
由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当 然可以把Cat对象和Dog对象，传递给方法。 当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致， 所以showAnimalEat完全可以替代以上两方法。 不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。 所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。
总结
发生多态要:
- 完成向上转型
- 完成方法的重写
- 通过父类的引用调用这个重写的方法(也就是发生了动态绑定)
在此有那里不对, 欢迎大佬在评论区指出
扫一扫
689
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
