小工具知识网

当前位置: 首页 > 行业知识 > Java中的多态

行业知识

Java中的多态

2026-11-22 12:01:52 来源:互联网转载

一、多态定义及存在条件

1.1 多态的定义

多���是什么?

  • 多态是同一个行为具有不同的表现形式或形态的能力
  • 同一方法可以根据发送对象的不同而采用不同的行为方式

    例如:打印机分为黑白打印机和彩色打印机,在黑白打印机情况下打出来为黑白,在彩色打印机情况下打印出来为彩色

     多态就是事物的多种形态,一个对象在不同条件下所表现的不同形式

    1.2 多态的存在条件

    多态存在的三个必要条件

    1. 继承或实现:在多态中必须存在有继承或实现关系的子类和父类
    2. 方法的重写:子类对父类中的某些方法进行重新定义(重写,使用@Override注解进行重写)
    3. 基类引用指向派生类对象,即父类引用指向子类对象,父类类型:指子类对象继承的父类类型,或实现的父接口类型

    1.3 多态的格式

    • 父类类型  变量名 = new 子类类型();
    • 然后通过 变量名.方法名()调用在子类中重写的方法
    • 多态体现为父类引用变量可以指向子类对象:定义了一个父类类型的引用,指向新建的子类类型的对象,由于子类是继承他的父类的,所以父类类型的引用是可以指向子类类型的对象的

      1.4多态中的成员特点

      • 多态成员变量:编译运行看左边

        此处举例Animal是父类,Dog是子类

        • Animal dog = new Dog();   //Animal是引用类型,Dog是实际类型
        • System.out.println(dog.age) //dog的引用类型是Animal,所以取到的是父类Animal中的值,说白了dog是属于Animal类,Animal中变量的值是多少就通过对象就取得多少

          父类Animal:

          //父类public class Animal {    public int age = 11;    }

          子类Dog:

          //子类public class Dog extends Animal {    public int age = 33;    }

          启动项:

          public class DemoApplication {    public static void main(String[] args) {        //父类类型 对象 = new 子类类型()        Animal dog = new Dog();        System.out.println(dog.age);    }}

          控制台打印输出:父类中定义的age 

          11  
          • 多态成员方法:编译看左边,运行看右边

            此处举例Animal是父类,Dog是子类

            • Animal  dog  =  new Dog();  //Animal是引用类型,Dog是实际类型
            • dog.eat();     //变量dog的实际类型是Dog,即是由Dog 这个实际类型new出来的,因此dog.eat() 调用的应该是子类Dog中重写的方法

              父类Animal:

              //父类public class Animal {    public void eat() {        System.out.println("午餐吃狗粮");    }}

              子类Dog:

              //子类public class Dog extends Animal {        @Override    public void eat() {        System.out.println("晚餐吃狗粮");    }}

              启动项:

              public class DemoApplication {    public static void main(String[] args) {        //父类类型 对象 = new 子类类型()        Animal dog = new Dog();        dog.eat();    }}

              控制台打印输出:调用的是子类中重写的方法

              晚餐吃狗粮

              1.5 重写方法的快捷键

              在子类Dog中右键选择Generate

               选择Override Methods然后点击生成

               1.6 多态的特点

              1. 多态情况下,子类和父类存在同名的成员变量时,访问的时父类的成员变量
              2. 多态情况下,子父类存在同名的非静态成员方法时,访问的是子类中重写的方法
              3. 多态情况下,子父类存在同名的静态成员变量成员方法时,访问的是父类的成员函数
              4. 多态情况下,不能访问子类独由的方法

              对于子类独有的方法,父类无法访问,

              父类Animal保持不变:

              //父类public class Animal {        public void eat() {        System.out.println("午餐吃狗粮");    }}

              子类Dog:增加子类读有的方法walk()

              //子类public class Dog extends Animal {        public void walk(){        System.out.println("子类独有的方法");    }            @Override    public void eat() {        System.out.println("晚餐吃狗粮");    }}

              启动项:walk()方法爆红,即编译报错,

              根据多态成员方法中编译看左边,运行看右边的原理

              Animal  dog  =  new Dog();

              可知 左边的Animal引用类型中没有walk()这个方法,故编译不通过,编译爆红

              public class DemoApplication {    public static void main(String[] args) {        //父类类型 对象 = new 子类类型()        Animal dog = new Dog();        dog.eat();  //访问的是子类中重写的方法        dog.walk();  //walk方法爆红,即编译报错,编译看左边,dog类的实例对象Animal没有walk()这个方法,所以编译报错    }}

              那么想要直接访问子类独有的方法,该如何解决呢,由此引出了引用类型转换

              二、引用类型转换

              2.1 为什么需要引用类型转换

              • 上面的例子说明了,在多态情况下,使用Animal引用类型构建出来的对象dog无法访问子类Dog所独有的方法walk();强行调用时方法会爆红,编译出错,即我们所说的编译看左边,运行看右边
              • 而且我们在多态情况下调用方法时,首先会检查等式左边的引用类型(父类)中是否有该方法存在,如果父类中没有该方法,则编译器直接报错,也就代表着,父类无法调用子类独有的方法
              • 既然编译都出错了,更别说运行了,这也是多态所造成的,因此如果我们想要调用子类的方法,必须做到向下转型

                2.2 向上转型(自动转换)

                先了解什么向上转型(儿子变父亲)

                向上转型:

                 多态本身是子类向父类向上转换(自动转换)的过程,这个过程是默许的,当父类引用指向一个子类对象时,就是向上转型

                父类引用指向子类对象:

                Animal dog  = new Dog()

                左边的Animal是引用类型,而dog是由右边的Dog实例对象new出来的,在上面这个等式中,左边的引用Animal指向了子类的对象dog,原本是子类对象的dog完成了向上转型

                对于父类和子类的关系,直接用图来描述

                 Animal父类是大范围的类型,而Cat和Dog类均属于动物类的子类,所以对于子类这种范围小的,我们可以自动转型给父类的变量,儿子向上转型,父亲是唯一的,因此是自动转换

                使用格式:

                父类类型  变量名  = new 子类类型();

                Animal       dog     = new  Dog()

                通过由实例变量Dog类new出来的变量dog作为中介,使得引用变量Animal有所指向,从而完成了向上转型

                相当于是

                Animal       dog     = (Animal) new  Dog()

                2.3 向下转型(父亲变儿子,需要强制转换)

                向上转型是一个子类变成父类的过程,下面介绍向下转型

                向下转型:

                向下转型是父类向子类转换的过程,这个过程需要强制转换(父亲变儿子肯定是需要条件的),一个可以将父类对象转换为子类对象,可以使用强制类型转换的格式,这便是向下转型

                继续拿图说话

                 

                对于Dog、Cat这些子类来说,他们只是父类Animal的一部分,而对于父类来说。他拥有更多的子类 牛、羊等,所以一旦父类要转换成子类,就必须指定要变成哪个子类,必须有指向性,所以向下转型才是强制转换

                使用格式:

                向上转型

                父类类型  变量名  = new 子类类型();

                Animal       dog     = new  Dog()

                向下转型

                子类类型 子类变量名 = (子类类型) 父类变量名

                Dog dog1 = (Dog) dog;

                dog1.walk; //此时可以使用子类独有的方法了

                代码示例如下:

                父类Animal:

                //父类public class Animal {    public void eat() {        System.out.println("午餐吃狗粮");    }}

                子类Dog:包含有子类独有的方法walk()

                //子类public class Dog extends Animal {    public void walk(){        System.out.println("子类独有的方法");    }    @Override    public void eat() {        System.out.println("晚餐吃狗粮");    }}

                启动项:

                通过

                Dog dog1 = (Dog) dog;完成向下转型

                再利用向下转型成功的子类对象dog1调用子类中独有的方法walk()

                public class DemoApplication {    public static void main(String[] args) {        //父类类型 对象 = new 子类类型()        Animal dog = new Dog();        //向下转型        //子类类型 子类变量名 = (子类类型) 父类变量名        Dog dog1 = (Dog) dog;        dog.eat();  //访问的是子类中重写的方法        //通过向下转型的子类对象调用子类独有的方法        dog1.walk();  //walk方法爆红,即编译报错,编译看左边,dog类的实例对象Animal没有walk()这个方法,所以编译报错    }}

                控制台打印输出:

                晚餐吃狗粮子类独有的方法

                所以对于多态中,无法使用子类特有的方法也通过向下转型,将父类类型强制转换为某个子类类型后,再进行方法的调用

                2.4 向下转型的问题

                虽然可以通过向下转型可以调用子类独有的方法,但也会产生下面的问题

                增加一个子类Cat类,

                Cat类中有其独有的方法sleep()

                //Cat类通过extends关键字继承父类Animalpublic class Cat extends Animal {    public void sleep(){        System.out.println("Cat类独有的方法");    }    @Override    public void eat() {        System.out.println("晚餐吃猫粮");    }}

                        

                父类Animal:

                //父类public class Animal {    public void eat() {        System.out.println("午餐吃狗粮");    }}

                子类Dog类:

                //子类public class Dog extends Animal {    public void walk(){        System.out.println("Dog类独有的方法");    }    @Override    public void eat() {        System.out.println("晚餐吃狗粮");    }}

                启动项:

                public class DemoApplication {    public static void main(String[] args) {        //向上转型        //父类类型 对象 = new 子类类型()        Animal cat = new Cat();        //向下转型        //子类类型 子类变量名 = (子类类型) 父类变量名        Dog dog1 = (Dog) cat;        //通过向下转型的子类对象调用子类独有的方法        dog1.walk();  //walk方法爆红,即编译报错,编译看左边,dog类的实例对象Animal没有walk()这个方法,所以编译报错    }}

                控制台打印输出:爆出异常ClassCastException,即类型转换异常

                 分析:为什么会爆出类型转换异常

                • 因为 在启动项中,向上转型的过程,Animal cat = new Cat(); cat对象是由子类Cat构造出来的
                • 而向下转型的过程中 Dog dog1 = (Dog) cat; 却将其变成了Dog 类的对象,
                • Dog类和Cat类都是Animal类的儿子类 ,
                • 上面的步骤中的第二步将子类Cat的对象cat变成了兄弟类的对象dog,这就不是向下转型了,因此会报类型转换异常

                  那么如何避免这种异常呢 ,就需要使用instanceof关键字

                  2.5 instanceof关键字详解

                  Java为我们提供了一个关键字instanceof,它可以帮助我们避免出现ClassCastException这样的异常,

                  格式:

                  变量名  instanceof   数据类型

                  解释:

                  • 如果变量属于该数据类型或者其子类型,返回true
                  • 如果变量不属于该数据类或者其子类型,返回false

                    直接拿启动项来进行说明,

                    代码示例如下:

                    public class DemoApplication {    public static void main(String[] args) {        //向上转型        //父类类型 对象 = new 子类类型()        Animal animal = new Cat();        //向下转型        //子类类型 子类变量名 = (子类类型) 父类变量名        if ( animal instanceof Cat){            Cat cat = (Cat) animal;            cat.sleep();        }else if(animal instanceof Dog){            Dog dog = (Dog) animal;            dog.walk();        }    }}

                    在进行了向上转型之后,在向下转型的过程中利用if语句来进行判断,而判断条件正是向上转型产生的变量与子类之间的关系

                    控制台打印输出:

                    Cat类独有的方法

上一篇:文明6手机版怎么下载?

下一篇:方舟非专用主机怎么开创造模式快捷键设置