Java---多态

---

1. 多态的概念

=========

多态通俗的讲就是多种形态，就是不同对象完成某个行为产生不同的形态，即“一种定义，多种实现”。例如下图：

总之：同一件事情，发生在不同对象身上，就会产生不同的结果

2. 多态的实现条件

===========

Java中，多态的实现必须满足以下几个条件：

1. 必须在继承体系下

2. 子类必须要对父类方法进行重写

3. 通过父类的引用调用重写方法

多态体现：在代码运行时，当传递不同对象时，会调用对应类中的方法

看以下代码：

public abstract class Animal {

String name;

int age;

public Animal(String name,int age){

this.name = name;

this.age = age;

}

public void eat(){

System.out.println(name+“吃粮食”);

}

}

public class Dog extends Animal {

public Dog(String name, int age) {

super(name, age);

}

@Override

public void eat() {

System.out.println(name+“爱吃骨头”);

}

}

///

public class Cat extends Animal {

public Cat(String name, int age) {

super(name, age);

}

@Override

public void eat() {

System.out.println(name+“爱吃鱼”);

}

}

/

public class TestAnimal {

//编译器在编译代码时，并不知道调用Dog还是Cat中的eat方法

//等程序运行起来后，形参a引用的具体对象确定后，才知道调用哪个方法

//注意：此处的形参类型必须是父类类型才可以

public static void eat(Animal a){

a.eat();

}

public static void main(String[] args) {

Dog dog = new Dog(“旺财”,2);

Cat cat = new Cat(“糯米”,1);

eat(dog);

eat(cat);

}

}

运行结果：

当类的调用者在编写 eat 这个方法时，参数类型为父类Animal，此时在该方法内部并不知道也不关注当前的a引用指向的是哪个子类型的实例，此时 a 的这个引用调用eat方法可能会有多种不同的表现（和a引用的实例相关），这种行为称为多态。

3. 重写

======

重写（override）也称为覆盖，重写是子类对父类非静态，非private修饰，非final修饰，非构造方法等的实现过程进行重新编写，返回值和形参都不能改变，即外壳不变，核心重写。重写的好处在于子类可以根据需要定义特定于自己的行为，也就是说子类能够根据需要实现父类的方法。

方法重写规则：

· 子类重写父类方法时，一般必须与父类方法原型保持一致：修饰符 返回值类型 方法名（参数列表）要完全一致

· JDK7以后，被重写的方法返回值类型可以不同，但是必须具有父子关系

· 访问权限不能比父类父类中被重写的方法的访问权限低。

. 父类中被static private 修饰的方法，构造方法都不能被重写

· 重写的方法可以用@Override注解来显示指定

重写和重载的区别：

区别	重载	重写
参数列表	必须修改	不能修改
返回类型	可以修改	不能修改
访问限定符	可以修改	不能做更严格的限定
异常	可以修改	可以减少或删除，一定不能抛出新的或更广的异常

即：方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现

重写的设计规则：

对于已经投入使用的类，尽量不要进行修改，最好的方式是，重新定义一个类，来重复利用其中共性的内容，并且添加或者改动新的内容

**静态绑定：**也称为前期绑定（早绑定），即在编译时，根据用户所传递实参类型确定具体调用哪个方法。典型代表：重载

**动态绑定：**也成为后期绑定（晚绑定），即在编译时，不能确定方法的行为，需要等到程序运行时才能够确定调用哪个类的方法

4. 向上转型和向下转型

=============

4.1 向上转型

---

向上转型：就是创造一个子类对象，将其当成父类对象来使用

语法格式：父类类型  对象名  =   new    子类类型（）；

Animal animal = new Cat(“糯米”,1);

animal是父类类型，但可以引用一个子类对象，因为：子类对象是一个父类对象，即可以将一个子类对象当成父类对象来引用。因此：向上转型是安全的，因为是从小范围向大范围的转换。

猫和狗都是动物，因此子类对象转化为父类引用是合理的。

**使用场景：**直接赋值     方法传参     方法返回

public class TestAnimal {

//方法传参：形参为父类类型引用，可以接受任意子类对象

public static void eat(Animal a){

a.eat();

}

//作为返回值：返回任意子类对象

public static Animal buyAnimal(String var){

if(“狗” == var){

return new Dog(“小七”,2);

}else if(“猫” == var){

return new Cat(“汤圆”,1);

}else{

return null;

}

}

public static void main(String[] args) {

Animal dog = new Dog(“旺财”,2); //直接赋值:子类对象赋给父类对象

Aniaml cat = new Cat(“糯米”,1);

eat(dog);

eat(cat);

Animal animal = buyAnimal(“狗”);

animal.eat();

animal = buyAnimal(“猫”);

animal.eat();

}

}

运行结果：

向上转型的优点：让代码实现更简单灵活

向上转型的缺陷：不能调用到子类特有的方法

4.2 向下转型

---

将一个子类对象向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转型。

public class TestAnimal {

public static void eat(Animal a){

a.eat();

}

public static void main(String[] args) {

Dog dog = new Dog(“旺财”,2);

Cat cat = new Cat(“糯米”,1);

Animal animal = dog;

animal.eat();

// animal.bark(); 编译器报错，Animal类中没有bark方法

dog = (Dog)animal;

dog.bark();

animal = cat;

animal.eat();

// animal.mew(); 编译器报错，Animal类中没有mew方法

cat = (Cat)animal;

cat.mew();

}

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
友，同时减轻大家的负担。**

[外链图片转存中…(img-S0qy426d-1715348409724)]

[外链图片转存中…(img-J5iMLGfZ-1715348409725)]

[外链图片转存中…(img-smovMnn8-1715348409725)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！