首页 > 编程语言 >Java多态

Java多态

时间:2024-08-22 20:24:42浏览次数:15  
标签:Java void 多态 Dog public println class

1.多态

1.1多态的概述(记忆)

  • 什么是多态

    不同类的对象在调用同一个方法时表现出来的多种不同行为

  • 多态的前提

    • 要有继承或实现关系

    • 要有方法的重写

    • 要有父类引用指向子类对象

  • 代码演示

    class Animal {
        public void eat(){
            System.out.println("动物吃肉");
        }
    }
    ​
    class Cat extends Animal {
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    class Dog extends Animal {
        @Override
        public void eat() {
            System.out.println("狗吃骨头");
        }
    }
    ​
    public class Test1Polymorphic {
        /*
            多态的前提:
    ​
                1. 要有(继承 \ 实现)关系
                2. 要有方法重写
                3. 要有父类引用, 指向子类对象
         */
        public static void main(String[] args) {
            // 当前事物, 是一只猫
            Cat c = new Cat();
            // 当前事物,是一只狗
            Dog d = new Dog();
            // 当前事物, 是一只动物(a:猫对象)
            Animal a = new Cat();
            // 当前事物, 是一只动物(b:狗对象)
            Animal b = new Dog();
            a.eat();
            b.eat();
    ​
        }
    }

    运行结果:

1.2多态中的成员访问特点(记忆)

  • 成员访问特点

    • 成员变量

      编译看父类,运行看父类

    • 成员方法

      编译看父类,运行看子类

  • 代码演示

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

1.3多态的好处和弊端(记忆)

  • 好处

    提高程序的扩展性。定义方法时候,使用父类型作为参数,在使用的时候,使用具体的子类型参与操作

  • 弊端

    不能使用子类的特有成员

1.4多态中的转型(应用)

  • 向上转型

    父类引用指向子类对象就是向上转型

  • 向下转型

    格式:子类型 对象名 = (子类型)父类引用;

  • 代码演示

    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 Test3Polymorpic {
        public static void main(String[] args) {
            // 1. 向上转型 : 父类引用指向子类对象
            Fu f = new Zi();
            f.show();
            // 多态的弊端: 不能调用子类特有的成员
            // f.method();
    ​
            // A: 直接创建子类对象
            // B: 向下转型
    ​
            // 2. 向下转型 : 从父类类型, 转换回子类类型
            Zi z = (Zi) f;
            z.method();
        }
    }

1.5多态中转型存在的风险和解决方案 (应用)

  • 风险

    如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现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 Test4Polymorpic {
        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,void,多态,Dog,public,println,class
From: https://blog.csdn.net/2302_76758195/article/details/141386602

相关文章

  • Java设计模式之代理模式:静态代理VS动态代理,与其他模式的对比分析和案例解析
    一、代理模式简介代理模式(ProxyPattern)是一种结构型设计模式,它提供了一个代理对象,用来控制对另一个对象的访问。这种模式通常用于在访问对象时引入额外的功能,而不改变对象的接口。代理模式的核心思想是为其他对象提供一种代理,以控制对这个对象的访问。在现实生活中,代理模......
  • java 面向对象4
    1.java存在抽象类,不写函数的具体实现,需要再函数前边加上abstract修饰.这个和c++语法存在差别,但是同样抽象类不可以创建对象,可以用抽象类的引用指向子类创建的对象,这个用法在一定程度上使得接口一致.利于在开发中保持接口一致,避免接口混乱的问题.同时利用抽象类可以使得一些......
  • JavaSE基础知识分享(十三)
    写在前面今天继续讲Java中的网络编程的知识!网络编程概述计算机网络计算机网络是将地理位置不同的具有独立功能的多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统、网络管理软件及网络通信协议的管理和协调下,实现资源共享和信息传递的计算机系统。例如:极域。网络......
  • Java中的static关键字
    static可以用来修饰成员变量,也能修饰成员方法。1.1static修饰成员变量Java中的成员变量按照有无static修饰分为两种:类变量、实例变量。它们的区别如下图所示: 由于静态变量是属于类的,只需要通过类名就可以调用:类名.静态变量实例变量是属于对象的,需要通过对象才能调用:对......
  • Java基础——自学习使用(static关键字)
    一、static关键字是什么?static修饰的代码属于类,定义的变量存储在方法区的静态常量池当中二、static可以修饰什么1.static修饰变量static修饰的变量叫做类变量,被所有该类产生的对象所共享,存储在方法区的静态常量池中2.static修饰方法static修饰是的方法属于静态方法,stat......
  • Java中对继承的学习
    继承目录继承继承的概念为什么需要继承继承的特性继承的优点和缺点继承的概念继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为......
  • Java并发编程(八)
    1、volatile有什么用?能否用一句话说明下volatile的应用场景volatile保证内存可见性和禁止指令重排。volatile用于多线程环境下的单次操作(单次读或者单次写)。2、为什么代码会重排序在执行程序时,为了提供性能,处理器和编译器常常会对指令进行重排序,但是不能随意重排......
  • Java 字符串转换成罗马数字
    键盘录入一个字符串要求1:长度为小于等于9要求2:只能是数字将内容变成罗马数字下面是阿拉伯数字跟罗马数字的对比关系Ⅰ-1,Ⅱ-2,Ⅲ-3,Ⅳ-4,Ⅴ-5,Ⅵ-6,Ⅶ-7,Ⅷ-8,Ⅸ-9注意点:罗马数字里面是没有0的如果键盘录入的数字包含0,可以变成""(长度为0的字符串)packagetest;......
  • Java的循环结构
     一、什么是循环语句在Java中,循环是一种控制结构,允许程序重复执行一段代码块,直到满足特定的条件为止。循环结构在编程中非常重要,因为它可以避免重复编写相同的代码,提高代码的效率和可读性。一、循环条件这是一个判断表达式,用于确定是否继续执行循环。只要循环条件为真,循......
  • 什么是JAVA
    Java发展史机器语言:电子机器能够直接识别的语言,无需经过翻译,计算机内部就有相应的电路来完成它;从使用的角度来看,机器语言是最低级的语言。高级语言:更容易被人们所理解的高级程序语言,符合人类思维模式的程序设计语言,如:C、Java,JavaScript、Python、Go等。汇编语言:面向机器......