多态
什么是多态
多态：理解为一个事物的多种形态
比如在现实生活中每个人都会扮演着不同的身份，比如张三可以是学生身份，可以是一个孩子身份，可以是教师身份，可以是父亲的身份。
Java中多态的体现
子类对象多态性：父类的引用指向子类的对象（或者子类的对象赋给父类引用）
举个例子：
1 public class Test {
2 public static void main(String[] args) {
3 //通过多态的形式，将父类引用指向子类的对象
4 Person person=new Student();
5 }
6 }
7
8 class Person{
9
10 }
11 class Student extends Person{
12
13 }
在多态场景下，调用方法时分为编译时和执行时两种。
①编译时，认为声明的对象是一个父类的对象（实际上生成的是子类对象），看父类中有什么属性成员和方法成员（即被重写的方法）。
②执行时，实际上执行的方法是子类重写父类的方法。
如果出现子类没有重写相对应的方法时，才会去执行父类的方法。
简称：编译看左边，运行看右边。
举个例子：
父类：
1 class Person {
2 public void eat() {
3 System.out.println("父亲吃饭");
4 }
5 public void show(){
6 System.out.println("这是一个show方法");
7 }
8 }
子类：
1 class Student extends Person {
2 @Override
3 public void eat() {
4 System.out.println("儿子吃饭");
5 }
6 }
测试类：
1 public class Test {
2 public static void main(String[] args) {
3 //通过多态的形式，将父类引用指向子类的对象
4 Person person=new Student();
5 //子类重写了eat方法
6 person.eat();
7 //子类没有重写eat方法
8 person.show();
9 }
10 }
效果展示：
执行时会先执行子类重写父类的方法，如果没有重写方法，才调用父类的方法。
多态的缺点
①在使用多态时，子类的特有方法是会被屏蔽掉的，因为编译的时候父类并没有子类的方法所以是没办法调用的。
②创建子类对象的特有属性和特有方法也会加载到内存中，从而导致内存的浪费。
举个例子：
父类：
1 class Person {
2 public void eat() {
3 System.out.println("父亲吃饭");
4 }
5 public void show(){
6 System.out.println("这是一个show方法");
7 }
8 }
子类：
1 class Student extends Person {
2 @Override
3 public void eat() {
4 System.out.println("儿子吃饭");
5 }
6 public void play(){
7 System.out.println("儿子打游戏");
8 }
9 }
测试类：
1 public class Test {
2 public static void main(String[] args) {
3 //通过多态的形式，将父类引用指向子类的对象
4 Person person=new Student();
5 //儿子中独特的play()方法
6 //person.play() 由于父类并没有这个play()方法，所以编译时无法调用play()方法
7 }
8 }
由于父类并没有这个方法，无法调用play()方法。
多态的优点
①提高代码的维护性，比如一个饲养员有一个饲养的方法，不可能每有一种动态就写一个饲养方法这样不合理，而多态的实现只需要写一个方法里面调用不同对象的方法，代码维护性提高。
②提高代码的扩展性，只需要改变每个对象的方法即可，不需要修改饲养员的饲养方法。
多态的前提
多态的两个前提条件是：
①存在继承关系：多态是基于继承关系建立的，即一个类可以派生出另一个类。在多态中，存在一个父类和多个子类，子类继承了父类的属性和方法。
②存在重写关系：多态要求子类能够重写父类的方法。子类在重写方法时可以根据自己的需求对方法进行不同的实现，从而实现实现多态的效果。
向上转型和向下转型
举个图例：
向上转型
多态就是向上转型：将子类的对象赋值给父类（程序是自动实现的，缺点是失去子类的特有的属性和方法）
语法：
父类 对象名 = new 子类();
向下转型
把父类的对象转为子类的对象（需要强制转换）
语法：
子类类型 对象名 = (子类类型) 父类引用
举个例子：
1 public class Test {
2 public static void main(String[] args) {
3 //向上转型
4 Animal animal=new Cat();
5 //向下转型，需要强制转换
6 Cat cat = (Cat) animal;
7 cat.eat();
8 }
9 }
10
11 class Animal{
12
13 }
14 class Cat extends Animal {
15 public void eat(){
16 System.out.println("小猫吃鱼");
17 }
18 }
19 class Dog extends Animal{
20 public void eat(){
21 System.out.println("小狗吃骨头");
22 }
23 }
效果展示：
代码上是没有任何问题的，但是当两者之间没有继承关系时是没办法强转的，否则会ClassCastException类型转换异常。
举个例子：
1 public class Test {
2 public static void main(String[] args) {
3 //向上转型
4 Animal animal=new Cat();
5 Animal animal1=new Dog();
6 //向下转型，需要强制转换
7 Dog dog=(Dog) animal;//发现现在编译是没出错哦
8 }
9 }
10
11 class Animal{
12
13 }
14 class Cat extends Animal {
15 public void eat(){
16 System.out.println("小猫吃鱼");
17 }
18 }
19 class Dog extends Animal{
20 public void eat(){
21 System.out.println("小狗吃骨头");
22 }
23 }
发现编译时并没有任何问题，但是效果展示：
就是因为上面代码中，animal是猫的对象它能变成小狗对象吗？很明显，小猫怎么可能变成小狗对吧。
所以运行时会出现类型转换异常。
instanceof关键字
正因为上面向下转型可能会出现异常，所以这里用到instanceof关键字来判断左边的对象是否为右边的类。
语法：
a instanceof A ：判断对象a是否为A类的实例
当对象a是类A的实例：返回true
当对象a不是类A的实例： 返回false
举个例子：
1 public class Test {
2 public static void main(String[] args) {
3 //向上转型
4 Animal animal=new Cat();
5 Animal animal1=new Dog();
6 //向下转型，需要强制转换
7 if(animal instanceof Dog){
8 Dog dog=(Dog) animal;//发现现在编译是没出错哦
9 }else{
10 System.out.println("animal不是Dog类的实例");
11 }
12 }
13 }
14
15 class Animal{
16
17 }
18 class Cat extends Animal {
19 public void eat(){
20 System.out.println("小猫吃鱼");
21 }
22 }
23 class Dog extends Animal{
24 public void eat(){
25 System.out.println("小狗吃骨头");
26 }
27 }
效果展示：
判断出来animal并不是Dog类的实例所以不会执行
这句代码：Dog dog=(Dog) animal直接输出"animal不是Dog类的实例"
标签：Java,子类,void,多态,public,面向对象,父类,class From： https://www.cnblogs.com/gzyhrc/p/17818257.html