多态性：中的向下转型，instanceof 操作符的使用

最新推荐文章于 2024-09-19 13:19:42 发布
最新推荐文章于 2024-09-19 13:19:42 发布
阅读量323 收藏 1
点赞数
分类专栏： Java 文章标签： java 后端 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61635597/article/details/128368193
版权

多态性：中的向下转型，instanceof 操作符的使用

在这里插入图片描述

每博一文案

都说树叶不是一天变黄的，人心也不是一天变凉的，每一个现在的自己，其实都是过去的自己拼凑的。
如今我们的气质里都藏着过去走过的路，看过的书和爱过的人，曾经的好，曾经的话，曾经的眼泪和孝顺，其实一直都在，生生不息。
如今你所遇见的这个我，是被这个世界打磨过的我。正如张爱玲所说的：如果你认识从前的我，你就会
原谅现在的我呢。别人都说你变了，却没人关心你到底经历过什么。
如果我们没走过他人走过的路，经历过他人经历的事，或许真的不能懂他人的悲喜。
每个人都曾想过，要活得无忧无虑，可社会复杂，人心难测，逼的人不得不伪装将自己内心的感情藏得更深。
不敢轻易去爱，因为明白了这个迷茫的世界需要冷漠与对抗。
所以，如果你认识从前的我，也许就会理解我现在的伪装。如果你不认识从前的我，就请不要随意的随意的评判
我，因为你不知道我是怎么走到今天的往后余生。
愿你的每一次成熟都不必靠受伤才能懂得，也愿你傻傻的天真，有人会用心守。
                                                   ——————   一禅心灵庙语

文章目录

1. 多态： 对象类型转换

基本数据类型的转换

  • 自动类型转换： 小的数据类型可以自动转换成 大的数据类型
long lnum = 20;        // 在Java当中整数值默认是 int 类型
double dnum = 12.0f;   // 在Java当中小数默认是 double 类型
  • 强制类型转换： 可以把大 的数据类型 强制转换 成 小的数据类型
int inum = int(200L);     // L long 类型的后缀
float fnum = (float)12.0;

对于 Java多态 引用类型(对象) 的转换:

  • 向上转型： 子类的类类型可以自动转换成 父类的类类型，被称为 向上转型，但更多是被称为 是 多态 。
Person person = new Student();  // 向上转型 或者 多态。
  • 强制类型转换: 可以将父类的类类型 必须通过 强制类型的转换 为 子类 的类类型，这样就可以调用子类中特有的方法/属性了。
Person person = new Student();     // 多态
Student student = (Person)person;  // 强制向下转型

在这里插入图片描述

我们使用多态(向上转换) 为了 父类类型以后，如果想要调用 子类中特有的属性和方法 怎么办 ？？？

可以将 父类类型 强制转换为 对应子类 类型，从而就可以调用 子类中特有的属性和方法了。

多态：向下强制转换

如下代码:

package blogs.blog1;


public class PersonTest{
    public static void main(String[] args) {
        Person p1 = new Student();
        //p1.ncee(); // 直接编译的是父类类型，是无法调用子类中特有的属性/方法的，编译报错

        // 可以使用强制向下转型为对应 子类类型来调用其中的特有的属性/方法
        Student s1 = (Student)p1;
        System.out.println(s1.name);  // 可以调用子类中特有的属性/方法
        s1.ncee();    // 可以调用子类特有的方法


        Person p2 = new Teacher();
        Teacher t1 = (Teacher)p2;
        System.out.println(t1.name);
        t1.teach();    // 调用子类中特有的方法

    }
}

class Person {   // 父类
    String name = "Person";
    int age;

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public Person() {

    }

    public void show() {
        System.out.println("我是 Person");
    }



}

class Student extends Person{   // 子类
    int studentId;
    String name = "Student";

    @Override
    public void show() {
        System.out.println("我是 Student");
    }

    public void ncee() {
        System.out.println("高考");
    }

}


class Teacher extends  Person{  // 子类
    int teacherId;
    String name = "Teacher";

    @Override
    public void show() {
        System.out.println("我是 Teacher");
    }


    public void teach() {
        System.out.println("教书育人");
    }
}

在这里插入图片描述

通过强制向下转型，将父类转为 对应的子类的类型，从而就可以调用子类中特有的属性/方法了。

public class PersonTest{
    public static void main(String[] args) {
        Person p1 = new Student();
        //p1.ncee(); // 直接编译的是父类类型，是无法调用子类中特有的属性/方法的，编译报错

        // 可以使用强制向下转型为对应 子类类型来调用其中的特有的属性/方法
        Student s1 = (Student)p1;
        System.out.println(s1.name);  // 可以调用子类中特有的属性/方法
        s1.ncee();    // 可以调用子类特有的方法


        Person p2 = new Teacher();
        Teacher t1 = (Teacher)p2;
        System.out.println(t1.name);
        t1.teach();    // 调用子类中特有的方法

    }
}

注意的是：使用向下强制转换，存在一个问题：就是如果两个引用类型之间没有子父类继承关系/本身的实例关系 ，而是并列关系的话，编译可以通过，但是运行时，会报：java.lang.ClassCastException 类异常。

如下代码：

package blogs.blog1;


public class PersonTest{

    public static void main(String[] args) {
        Person p1 = new Student();
        Teacher t1 = (Teacher)p1;  // 编译可以通过，但是运行时会出现异常:ClassCastException
    }

}

class Person {   // 父类
    String name = "Person";
        int age;

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public Person() {

    }

    public void show() {
        System.out.println("我是 Person");
    }



}

class Student extends Person{   // 子类
    int studentId;
    String name = "Student";

    @Override
    public void show() {
        System.out.println("我是 Student");
    }

    public void ncee() {
        System.out.println("高考");
    }

}


class Teacher extends  Person{  // 子类
    int teacherId;
    String name = "Teacher";

    @Override
    public void show() {
        System.out.println("我是 Teacher");
    }


    public void teach() {
        System.out.println("教书育人");
    }
}

public class PersonTest{

    public static void main(String[] args) {
        Person p1 = new Student();
        Teacher t1 = (Teacher)p1;  // 编译可以通过，但是运行时会出现异常:ClassCastException
    }
}

在这里插入图片描述

报错原因:

  1. 编译不会报错是因为：我们将一个父类 Person 类型 强制向下转型为 了 Teacher 其中的一个子类，骗过了编译器，说这个类型就是这个。
  2. 运行报错是因为：编译器运行的时候，发现你给我 强制转换 过来的p1类型，与我本身 Teacher 没有任何关系，既不是 继承关系，也不是本身类的实例化。而是和我并列的 Student 类型，这样处理不对，报错： java.lang.ClassCastException

编译通过，运行不通过

public class PersonTest{
    public static void main(String[] args) {
        Person p1 = new Teacher();
        Student s1 = (Student)p1;  // 编译可以通过，但是运行时会出现异常：ClassCastException
    }
}

在这里插入图片描述

报错原因:

和上面一样。

编译不通过，运行不通过

public class PersonTest{
    public static void main(String[] args) {
        Student s1 = new Teacher();  
    }
}

在这里插入图片描述

报错原因:

左边赋值的 Student 与 右边 new 的 Teacher() 二者之间，没有继承关系，是两个并列不同的类类型，是无法相互强制赋值的。

编译无法通过，就像

String s1 = 123; 一样两个类型不一致，无法赋值。

编译通过，运行通过

直接使用对应的 向下强制转换为对应的类 。

public class PersonTest{
    public static void main(String[] args) {
        Person p1 = new Student();
        Student s1 = (Student)p1;   
        s1.ncee();   // Student 特有的方法

        Person p2 = new Teacher();
        Teacher t1 = (Teacher)p2;
        t1.teach();  // Teacher 特有的方法
    }
}

在这里插入图片描述

2. instanceof 操作符的使用

对应上述 强制向下转型 出现的 ClassCastException 可以预先使用 instanceof 操作符 进行一个判断。

需要注意的是： instanceof 是操作符，不是方法，所以可以直接使用，不需要导入包。

X instanceof Y 判断 X 是否是 Y的实例对象，或者 X 是否是 Y 的子类。如果是子类/是实例对象，返回 true, 不是返回 false

如下代码：

package blogs.blog1;


public class PersonTest{

    public static void main(String[] args) {
        Person p1 = new Student();
        Person p2 = new Teacher();

        System.out.println("p1 instanceof Student: "+ (p1 instanceof Student));
        System.out.println("p1 instanceof Person: "+(p1 instanceof Person));
        System.out.println("p1 instanceof Teacher: "+(p1 instanceof Teacher));

        System.out.println("***************************");

        System.out.println("p2 instanceof Teacher: "+(p2 instanceof Teacher));
        System.out.println("p2 instanceof Person: "+(p2 instanceof Person));
        System.out.println("p2 instanceof Student: "+(p2 instanceof Student));

    }

}

class Person {   // 父类
    String name = "Person";
    int age;

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public Person() {

    }

    public void show() {
        System.out.println("我是 Person");
    }


}

class Student extends Person{   // 子类
    int studentId;
    String name = "Student";

    @Override
    public void show() {
        System.out.println("我是 Student");
    }

    public void ncee() {
        System.out.println("高考");
    }

}


class Teacher extends  Person{  // 子类
    int teacherId;
    String name = "Teacher";

    @Override
    public void show() {
        System.out.println("我是 Teacher");
    }


    public void teach() {
        System.out.println("教书育人");
    }
}

重点代码：

public class PersonTest{

    public static void main(String[] args) {
        Person p1 = new Student();
        Person p2 = new Teacher();

        // 判断 p1 是否是 Student 的实例对象/子类，是返回 true, 不是返回 false
        System.out.println("p1 instanceof Student: "+ (p1 instanceof Student)); 
        // 判断 p1 是否是 Person 的实例地下/子类，是返回 true, 不是返回 false
        System.out.println("p1 instanceof Person: "+(p1 instanceof Person));
        System.out.println("p1 instanceof Teacher: "+(p1 instanceof Teacher));

        System.out.println("***************************");

        System.out.println("p2 instanceof Teacher: "+(p2 instanceof Teacher));
        System.out.println("p2 instanceof Person: "+(p2 instanceof Person));
        System.out.println("p2 instanceof Student: "+(p2 instanceof Student));


    }
}

在这里插入图片描述

举例使用 instanceof 进行一个预先的判断，再向下强制转换

public class PersonTest{
    public static void main(String[] args) {
        Person p1 = new Student();    // 向上转型，多态

        if(p1 instanceof Student) { // 判断 p1 是否是 Student 的实例/子类,是true，强制向下转换
            Student s1 = (Student)p1;
            System.out.println(s1.studentId);   // 子类特有的属性
            s1.ncee();                          // 子类特有的方法
        }
        System.out.println("*******************");

        if(p1 instanceof Teacher) { // 判断 p1 是否是 Teacher 的实例/子类，是true,强制向下转换
            Teacher t1 = (Teacher)p1;
            System.out.println(t1.teacherId);   // 子类特有的属性
            t1.teach();                         // 子类特有的方法
        }
        
        System.out.println("*******************");
        if(p1 instanceof Person) {  // 判断p1 是否是 Person 的实例/子类，是true,强制向下转换
            Person person = (Person)p1;
            person.show();
        }
    }
}

在这里插入图片描述

3. 总结：

  1. 向上转换，称为多态
  2. 多态中：想要调用子类中特有的属性/方法，可以强制向下转型 为对应的子类。
  3. 强制向下转型可能会出现：编译正常，运行异常：java.lang.ClassCastException 类异常
  4. 可以预先使用 instanceof 预先判断再强制向下转型，防止：强制向下转型失败报错：java.lang.ClassCastException 类异常

4. 最后:

限于自身水平，其中存在的错误，希望大家给予指教，韩信点兵——多多益善，谢谢大家，江湖再见，后会有期！！！

在这里插入图片描述

ChinaRainbowSea
关注
专栏目录
java instanceof操作符使用及原理解析
08-25
总之，`instanceof`是Java中用于类型检查的重要工具，它使得我们在运行时能够动态地确定对象的类型，从而根据对象的类型执行不同的操作，这是面向对象编程中多态性的体现。熟练掌握`instanceof`的使用，能够帮助我们...
Java向上转型与向下转型
Aa_Lyang的博客
05-18 703
在向下转型的时候，把p1转型为Student会成功，因为p1确实指向Student实例，把p2转型为Student会失败，因为p2的实际类型是Person，不能把父类变为子类，因为子类功能比父类多，多的功能无法凭空变出来。Person类型的变量，如果指向Student类型的实例，对它进行操作，是没有问题的！现在问题来了：如果Student是从Person继承下来的，那么，一个引用类型为Person的变量，能否指向Student类型的实例？和向上转型相反，如果把一个父类类型强制转型为子类类型，就是。
24、Java面向对象——多态、多态的使用、多态中的转型、instanceof运算符
CSDN_Loveletter的博客
10-16 433
目录 课前先导 一、多态 1、定义 2、多态的前提和体现 3、多态中成员访问特点 二、多态的使用 1、代码演示 2、多态的优缺点 三、多态中的转型 1、向上转型 2、向下转型 四、instanceof运算符 1、instanceof运算符的作用 ​编辑2、instanceof运算符使用注意事项 3、instanceof运算符效果展现 五、多态的特点（优势）
JavaSE-Java多态性
weixin_34204722的博客
01-19 86
/* * 面向对象的特征：多态性 * 1.多态性可以理解为一个事物的多种表现形态 * 1）方法的重载与重写 * 2）子类对象的多态性（主要） * 2.子类对象的多态性使用的前提：1）发生类的继承 2）要有子类对父类方法的重写3）父类引用指向子类对象 * 3.程序分为编译状态和运行状态 * 1）对于多态性来说，编译时，“看左边”，将此引用变量理解为父类的类型，所以子类特有的方法和属...
0402 向下转型 instanceof
m0_52501867的博客
04-03 86
有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。 就是多态生效之后，编译父类，执行子类，执行的子类属性，如果和父类一样，就不会用子类的，还是用父类的。但是内存中是有的。 地址值是包括类型的 在父类强转子类的过程中，改变了地址前面的类型值，后面地址值不变 类型@地址 关键字instanceof a instanceof A 判断a是否是A 的一个实例 去过是返回true 不是是false。
多态、instanceof关键字
hyw1622286744的博客
07-02 292
多态 Animal a = new Dog(); Animal a = 所有子类类型 概念：父类引用指向子类对象，从而产生多种形态。 使用场景一：使用父类作为方法形参实现多态，使方法参数的类型更为宽泛（原理：如果子类覆盖了父类的方法，则执行子类中覆盖后的方法）。 使用场景二：使用父类作为方法返回值实现多态，使方法可以返回不同子类对象。（注意：父类引用仅可以调用父类声明的属性和方法，不可调用子类独有的属性和方法） 运行时多态存在的三个必要条件：1、要有继承（包括接口的实现）2、要有重写 3、父类引用
java 中的instanceof用法详解及instanceof是什么意思(推荐)
08-28
因此，最好尽量避免过多依赖`instanceof`，而是利用面向对象设计原则和多态性来编写更清晰、更可维护的代码。 综上所述，`instanceof`在Java中是一个强大的工具，用于在运行时检查对象的类型，这对于理解对象的性质...
Java中的instanceof关键字在Android中的用法实例详解
09-02
在Java编程语言中，`instanceof`关键字是一个重要的二元操作符，用于判断一个对象是否属于特定的类或其子类（或者实现了特定接口）。在Android开发中，`instanceof`同样发挥着关键作用，尤其是在处理类之间的继承...
Android中Java instanceof关键字全面解析
09-02
然而，这样的做法并不符合面向对象设计原则，因为它违背了多态性。更好的做法是定义两个重载的方法，分别处理不同类型的账单： ```java public double calculate(PhoneBill bill) { // 计算电话账单 } public ...
Java中instanceof关键字的用法总结
09-04
6. **多态性与instanceof**：在多态编程中，`instanceof`可以帮助确定对象的实际类型，以便调用特定的方法或访问特定的属性。例如，一个方法接受一个`Animal`对象作为参数，但可能需要处理具体的`Dog`或`Cat`对象： ...
多态：向上转型及向下转型
yiXin_Chen的博客
08-24 615
多态: 面向对象3大特性之一 作用: 提高代码的可扩展性和可维护性 前提和基础: 1) 继承/实现 2) 方法重写 3) 向上转型: 父类对象 指向 子类实例 例: Pet pet = new Dog(); 注1: 向上转型后, 通过父类引用变量无法使用子类特有的属性和方法 4) 向下转型: 将父类类型的对象 转换成 子类类型 ...
关于java多态，向上转型，向下转型
m0_60178502的博客
05-15 1664
首先，java多态是建立在java继承的基础上的，它表现的是同一种行为的不同表现形式，注意，是行为，即多态是java父子类中的方法的一个特性，而不是父子类中的属性的一个特性，比如： Person p1 = new Student(); System.out.println(p1.age) //这里输出的就是父类中age属性的值 p1.eat(); //这里调用的是Student类中eat的方法，而不是Person类中的eat方法 那什么是向上转型呢？多态本身
Java-网络
2301_81543552的博客
09-14 784
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java企业面试题3
m0_74972727的博客
09-15 782
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 802
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
自动生成不重复的订单id
ClaireCheney的博客
09-13 345
【代码】自动生成不重复的订单id。
Mybatis-plus进阶篇(四)
最新发布
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
09-19 1220
nested 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于创建一个独立的查询条件块，不带默认的 AND 或 OR 逻辑。last 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它允许你直接在查询的最后添加一个 SQL 片段，而不受 MyBatis-Plus 的查询优化规则影响。exists 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于在查询中添加一个 EXISTS 子查询。这个方法特别适用于需要对数值字段进行减量操作的场景。
Gradle
xiaocaij_icai的博客
09-15 246
");
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
m0_66572126的博客
09-14 749
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值