Java之多态

2021-06-07 12:05

阅读:405

标签:使用   eth   public   void   子类   system   class   动物   nbsp   

多态的概述

什么是多态
同一个对象,在不同时刻表现出来的不同形态
 
多态的前提
1.要有继承或实现关系
2.要有方法的重写
3.要有父类引用指向子类对象
 
代码演示
class Animal {
    public void eat() {
        System.out.println("动物吃饭");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class test {
    /*
    多态的前提:

    1.要有(继承 \ 实现)关系
    2.要有方法重写
    3.要有父类引用, 指向子类对象
    */
    public static void main(String[] args) {
// 当前事物, 是一只猫
        Cat c = new Cat();
// 当前事物, 是一只动物
        Animal a = new Cat();
        a.eat();
    }
}

多态中的成员访问特点

成员访问特点
 
成员变量
编译看父类,运行看父类
 
成员方法
编译看父类,运行看子类
class Fu {
    int num = 10;

    public void method() {
        System.out.println("Fu.. method");
    }
}

class Zi extends Fu {
    int num = 20;

    public void method() {
        System.out.println("Zi.. method");
    }
}

public class test {
    /*
    多态的成员访问特点:
    
    成员变量: 编译看左边 (父类), 运行看左边 (父类)
    
    成员方法: 编译看左边 (父类), 运行看右边 (子类)
    */
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);
        f.method();
    }
}

多态的好处和弊端

好处

提高程序的扩展性。定义方法时候,使用父类型作为参数,在使用的时候,使用具体的子类型参与操作
 
弊端
不能使用子类的特有成员

多态中的转型

向上转型
父类引用指向子类对象就是向上转型
 
向下转型
格式:子类型 对象名 = (子类型)父类引用;
 
代码演示
class Fu {
    public void show() {
        System.out.println("Fu..show...");
    }
}

class Zi extends Fu {
    @Override
    public void show() {
        System.out.println("Zi..show...");
    }

    public void method() {
        System.out.println("我是子类特有的方法, method");
    }
}

public class test {
    public static void main(String[] args) {
// 1. 向上转型 : 父类引用指向子类对象
        Fu f = new Zi();
        f.show();
// 多态的弊端: 不能调用子类特有的成员
// f.method();

// A: 直接创建子类对象
// B: 向下转型

// 2. 向下转型 : 从父类类型, 转换回子类类型
        Zi z = (Zi) f;
        z.method();
    }
}

多态中转型存在的风险和解决方案

风险

如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException
 
解决方案
 
关键字
instanceof
 
使用格式
变量名 instanceof 类型
 
通俗的理解:判断关键字左边的变量,是否是右边的类型,返回boolean类型结果
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 class test {
    public static void main(String[] args) {
        useAnimal(new Dog());
        useAnimal(new Cat());
    }

    public static void useAnimal(Animal a) { // Animal a = new Dog();
// Animal a = new Cat();
        a.eat();
//a.watchHome();

//    Dog dog = (Dog) a;
//    dog.watchHome(); // ClassCastException 类型转换异常

// 判断a变量记录的类型, 是否是Dog 
     if(a instanceof Dog){
Dog dog = (Dog) a; dog.watchHome(); } }

 

Java之多态

标签:使用   eth   public   void   子类   system   class   动物   nbsp   

原文地址:https://www.cnblogs.com/gonghr/p/14586402.html


评论


亲,登录后才可以留言!