【Java寒假打卡】Java基础-多态
- 概述
- 多态中成员访问的特点
- 多态的好处和弊端
- 多态中转型
- 多态中转型存在的风险
概述
同一个对象在不同时刻表现出来的不同形态
多态的前提和体现
- 有继承/实现关系
- 有方法重写。子类对父类进行方法重写
- 有父类引用指向子类对象
package com.hfut.edu.test1;
public class Test1 {
public static void main(String[] args) {
// 多态三个条件
// 继承/实现关系
// 有方法重写
// 父类引用指向子类对象
Animal a = new Cat();
a.eat();// 调用子类重写之后的方法
}
}
class Animal{
public void eat(){
System.out.println("动物吃饭");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
}
多态中成员访问的特点
- 构造方法：和继承一样，子类会通过super关键字访问父类构造方法
- 成员变量：编译看左边（父类），执行看左边（父类）
- 成员方法：编译看左边 父类，执行看右边 子类
package com.hfut.edu.test1;
public class Test1 {
public static void main(String[] args) {
// 多态三个条件
// 继承/实现关系
// 有方法重写
// 父类引用指向子类对象
Animal a = new Cat();
a.eat();// 调用子类重写之后的方法
System.out.println(a.num);// 调用父类的成员变量
}
}
class Animal{
int num = 10;
public void eat(){
System.out.println("动物吃饭");
}
}
class Cat extends Animal{
int num = 20;
public void eat(){
System.out.println("猫吃鱼");
}
}
为什么成员变量和成员方法的访问不一样？
- 因为成员方法有重写，但是成员变量没有重写
多态的好处和弊端
- 好处：父类引用可以指向不同的子类对象，调用子类重写的父类方法
package com.hfut.edu.test1;
public class Test2 {
public static void main(String[] args) {
useAnimal(new Dog());
useAnimal(new Cat());
}
// 多态调用不同子类对象的方法 因为 父类引用可以接受任意的子类对象
public static void useAnimal(Animal a){
a.eat();// 子类对象调用方法 必须是子类重写的方法 父类引用才可以进行调用
// a.watchHome();// 报错 多态的父类引用 在编译期间会查看该方法是否是子类重写的方法
}
}
abstract class Animal{
public abstract void eat();
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃肉");
}
public void watchHome(){
System.out.println("看家");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
}
多态的好处和弊端：
-
多态的好处：提高了程序的扩展性
具体体现：定义方法的时候，使用父类引用作为参数，该方法就可以接受这个父类的任意子类对象 -
多态的弊端：不能使用子类的特有功能，也就是子类自己的特有的方法，父类引用不可以直接调用
多态中转型
- 向上转型：父类引用指向子类对象
- 向下转型：父类引用转为子类对象
package com.hfut.edu.test1;
public class Test2 {
public static void main(String[] args) {
Animal a = new Cat();// 向上转型 父类引用指向子类对象
a.eat();// 弊端 只能调用父类与子类共有的方法
// 向下转型：从父类类型 转换回子类类型
Cat c = (Cat)a;// 需要强制类型转换
c.method();// 转换之后 调用子类对象特有的方法
}
// 多态调用不同子类对象的方法 因为 父类引用可以接受任意的子类对象
public static void useAnimal(Animal a){
a.eat();// 子类对象调用方法 必须是子类重写的方法 父类引用才可以进行调用
// a.watchHome();// 报错 多态的父类引用 在编译期间会查看该方法是否是子类重写的方法
}
}
abstract class Animal{
public abstract void eat();
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃肉");
}
public void watchHome(){
System.out.println("看家");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
public void method()
{
System.out.println("猫抓老鼠");
}
}
多态中转型存在的风险
- 概述：如果被转换的引用类型变量，对应的实际类型和目标类型不是同一种类型，那么在转换的时候就会出现ClassCastException
package com.hfut.edu.test1;
public class Test2 {
public static void main(String[] args) {
useAnimal(new Dog());
useAnimal(new Cat());// 报错 强制类型转换出现错误 类型不匹配
}
// 多态调用不同子类对象的方法 因为 父类引用可以接受任意的子类对象
public static void useAnimal(Animal a){
a.eat();// 子类对象调用方法 必须是子类重写的方法 父类引用才可以进行调用
// a.watchHome();// 报错 多态的父类引用 在编译期间会查看该方法是否是子类重写的方法
Dog d = (Dog)a;// 强制类型转换
d.watchHome();// 调用子类对象特有的方法
}
}
abstract class Animal{
public abstract void eat();
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃肉");
}
public void watchHome(){
System.out.println("看家");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
public void method()
{
System.out.println("猫抓老鼠");
}
}
解决办法：使用关键字instanceof
使用格式：变量名 instanceof 类型
通俗的解释：判断关键字左边的变量 是否是右边的类型 返回boolean类型结果
package com.hfut.edu.test1;
public class Test2 {
public static void main(String[] args) {
useAnimal(new Dog());
useAnimal(new Cat());// 报错 强制类型转换出现错误 类型不匹配
}
// 多态调用不同子类对象的方法 因为 父类引用可以接受任意的子类对象
public static void useAnimal(Animal a){
a.eat();// 子类对象调用方法 必须是子类重写的方法 父类引用才可以进行调用
// a.watchHome();// 报错 多态的父类引用 在编译期间会查看该方法是否是子类重写的方法
if(a instanceof Dog){
Dog d = (Dog)a;// 强制类型转换
d.watchHome();// 调用子类对象特有的方法
}
}
}
abstract class Animal{
public abstract void eat();
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃肉");
}
public void watchHome(){
System.out.println("看家");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
public void method()
{
System.out.println("猫抓老鼠");
}
}
