一. 多态的概述

多态是某一个事物，在不同时刻表现出来的不同状态。

举例:
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种，也可以把猫称为动物
  动物 d = new 猫();
  水在不同时刻的状态

多态的前提和体现:

1. 有继承关系
2. 有方法重写
3. 有父类引用指向子类对象

二.多态中成员的访问特点

成员变量访问特点
  编译看左边，运行看左边
成员方法访问特点
  编译看左边，运行看右边

代码:
duotai1

package Java_study;
/**
 * 
 * @author  只是甲
 * @date    2021-06-25
 * @remark  动物类   多态中成员访问特点
 * 
 *           为什么成员变量和成员方法的访问不一样呢?
 * 			 因为成员方法有重写，而变量没有。
 *
 */
public class duotai1 {
	public int age = 40;
	
	public void eat() {
		System.out.println("吃东西");
	}
}

duotai2

package Java_study;
/**
 * 
 * @author  只是甲
 * @date    2021-06-25
 * @remark  动物类子类-猫   多态中成员访问特点
 *
 */
public class duotai2 extends duotai1 {
	public int age = 20;
    public int weight = 10;
    
    @Override
    public void eat() {
    	System.out.println("猫吃鱼");
    }
    
    public void playGame() {
    	System.out.println("猫捉迷藏");
    }
}

duotai3

package Java_study;
/**
 * 
 * @author  只是甲
 * @date    2021-06-25
 * @remark  动物类测试类   多态中成员访问特点
 *
 */
public class duotai3 {
	public static void main(String[] args) {
		//由父类引用指向子类对象
		duotai1 a = new duotai2();
		System.out.println(a.age);
		//System.out.println(a.weight);//不能访问
		
		a.eat();
		//a.playGame();//不能访问
	}
}

三. 多态的好处和弊端

多态的好处：
  提高了程序的扩展性
多态的弊端：
  不能访问子类特有功能
  那么如何访问子类的特有功能呢？
    通过多态中的转型

多态转型代码:
duotai_animal

package Java_study;
/**
 * 
 * @author 只是甲
 * @date    2021-06-25
 * @remark  动物类   多态的好处和弊端
 */
public class duotai_animal {
	public int age = 40;
	
	public void eat() {
		System.out.println("吃东西");
	}
}

duotai_cat

package Java_study;
/**
 * 
 * @author 只是甲
 * @date    2021-06-25
 * @remark  动物子类-猫类   多态的好处和弊端
 */
public class duotai_cat extends duotai_animal {
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

duotai_dog

package Java_study;
/**
 * 
 * @author 只是甲
 * @date    2021-06-25
 * @remark  动物子类-狗类   多态的好处和弊端
 */
public class duotai_dog extends duotai_animal {
	@Override
	public void eat() {
		System.out.println("狗吃骨头");
	}
	
	public void lookDoor() {
		System.out.println("狗看门");
	}
}

duotai_pig

package Java_study;
/**
 * 
 * @author 只是甲
 * @date    2021-06-25
 * @remark  动物子类-猪类   多态的好处和弊端
 */
public class duotai_pig extends duotai_animal {
	@Override
	public void eat() {
		System.out.println("猪吃白菜");
	}
}

duotai_operator

package Java_study;
/**
 * 
 * @author 只是甲
 * @date    2021-06-25
 * @remark  动物类的操作类   多态的好处和弊端
 */
public class duotai_operator {
	
	public void userAnimal(duotai_cat cat) {
		cat.eat();
	}
	
	public void userAnimal(duotai_dog dog) {
		dog.eat();
		dog.lookDoor();
	}
	
	public void userAnimal(duotai_pig pig) {
		pig.eat();
	}
}

duotai_test1

package Java_study;
/**
 * 
 * @author 只是甲
 * @date    2021-06-25
 * @remark  动物类的测试类  多态的好处和弊端
 */
public class duotai_test1 {
	public static void main(String[] args) {
		//由父类引用指向子类对象
		duotai_operator ao = new duotai_operator();
		duotai_cat c = new duotai_cat();
		duotai_dog d = new duotai_dog();
		duotai_pig p = new duotai_pig();
		
		ao.userAnimal(c);
		
		ao.userAnimal(d);
		
		ao.userAnimal(p);
	}
}

测试记录:

猫吃鱼
狗吃骨头
狗看门
猪吃白菜

四. 多态中的转型问题

向上转型
  从子到父
  父类引用指向子类对象
向下转型
  从父到子
  父类引用转为子类对象

代码:
duotai_animal

package Java_study;
/**
 * 
 * @author 只是甲
 * @date    2021-06-25
 * @remark  动物类   多态中的转型问题
 */
public class duotai_animal {
	public int age = 40;
	
	public void eat() {
		System.out.println("吃东西");
	}
}

Java_study

package Java_study;
/**
 * 
 * @author 只是甲
 * @date    2021-06-25
 * @remark  动物子类-猫类   多态中的转型问题
 */
public class duotai_cat extends duotai_animal {
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	public void playGame() {
		System.out.println("猫捉迷藏");
	}
}

duotai_test2

package Java_study;
/**
 * 
 * @author 只是甲
 * @date    2021-06-25
 * @remark  动物子类-猫类   多态中的转型问题
 */
public class duotai_test2 {
	public static void main(String[] args) {
		duotai_animal a = new duotai_animal();
	    a.eat();
	    
	  //a.playGame();
        /*
            不能访问
            多态的弊端：无法访问子类特有方法
            现在我就想使用子类特有方法，怎么办呢？
            创建子类对象就可以了
        */
	    
	   duotai_cat c1 = new duotai_cat();
	   c1.eat();
	   c1.playGame();
	   
	   /*
       现在代码虽然可以访问子类的特有功能，但是不合理
       因为我们发现内存中有两个猫类的对象
       这个时候，我们得想办法把多态中的猫对象还原
       这个时候就需要使用多态中的转型了
       父类引用转为子类对象
       */
	   
	   duotai_animal a2 = new duotai_cat();
      
	   duotai_cat c2 = (duotai_cat)a2;
	   c2.eat();
	   c2.playGame();
	
	}
}

测试记录:

吃东西
猫吃鱼
猫捉迷藏
猫吃鱼
猫捉迷藏

参考:

1. https://blog.csdn.net/qq_43529621/article/details/115209518