Java面对对象13：instanceof 和 多态类型转换

一、instanceof

• instanceof 可以判断俩个类之间是否存在继承关系
  ——左右两边要有关系才能判断是否有继承关系；没有任何关系时，编译会报错

• 例子：

  • 父类——Person

    public class Person {
    }
    

  • 子类——Student

    public class Student extends Person{
    }
    

  • 子类——Teacher

    public class Teacher extends Person{
    }
    

  • 测试类

    public class Application {
        public static void main(String[] args) {
    
            //1.继承关系 Object > Person > Student
            //2.继承关系 Object > Person > Teacher
            //3.继承关系 Object > String
            /*instanceof 左右要有关系才能判断是否有继承关系；没有任何关系时，编译会报错
            *     例子：new Student();————new的对象的类是哪个，就选哪条继承关系路线，在同一条继承路线上的则为true，不在则为false
            *
            *           当引用的类型为Object（祖宗类）时，所有类都跟它有关系，所以都能进行判断；
            *           Object > Person > Student :————跟引用的类型Object有关系，与Student在同一条继承线上为 true
            *           Object > Person > Teacher :————跟引用的类型Object有关系，Teacher不在同一继承线上为 false
            *           Object > String ：————跟引用的类型Object有关系，String不在同一继承线上为 false
            *
            *           当引用的类型为Person时，只有子类和Object类跟它有关系;String与Person没有任何关系，编译报错
            *           Object > Person > Student :————跟引用的类型Person有关系，与Student在同一条继承线上为 true
            *           Object > Person > Teacher :————跟引用的类型Person有关系，Teacher不在同一继承线上为 false
            *           Object > String ：————String跟引用的类型Person没有任何关系,编译报错
            *
            *           当引用的类型为Student时，只有父类和Object类跟它有关系;String、Teacher与Student没有任何关系，编译报错
            *           Object > Person > Student :————跟引用的类型Student有关系，与Student在同一条继承线上为 true
            *           Object > Person > Teacher :————Teacher跟引用的类型Student没有任何关系,编译报错
            *           Object > String ：————String跟引用的类型Student没有任何关系,编译报错
            * */
    
            Object object = new Student();
            System.out.println(object instanceof Student);//Student跟object有关系，跟Student在同一条继承线上为 true
            System.out.println(object instanceof Person);//Person跟object有关系，跟Student在同一条继承线上为 true
            System.out.println(object instanceof Object);//Object跟object有关系，跟Student在同一条继承线上为 true
            System.out.println(object instanceof Teacher);//Teacher跟object有关系，跟Student不在同一条继承线上为false
            System.out.println(object instanceof String);//String跟object有关系，跟Student不在同一条继承线上为false
    
            System.out.println("===============================================================");
    
            Person person = new Student();
            System.out.println(person instanceof Student);//Student跟person有关系，跟Student在同一条继承线上为 true
            System.out.println(person instanceof Person);//Person跟person有关系，跟Student在同一条继承线上为 true
            System.out.println(person instanceof Object);//Object跟person有关系，跟Student在同一条继承线上为 true
            System.out.println(person instanceof Teacher);//Teacher跟person有关系，跟Student不在同一条继承线上为false
    //        System.out.println(person instanceof String);//————String跟引用的类型Person没有任何关系,编译报错
    
            System.out.println("===============================================================");
    
            Student student = new Student();
            System.out.println(student instanceof Student);//Student跟student有关系，跟Student在同一条继承线上为 true
            System.out.println(student instanceof Person);//Person跟student有关系，跟Student在同一条继承线上为 true
            System.out.println(student instanceof Object);//Object跟student有关系，跟Student在同一条继承线上为 true
    //        System.out.println(student instanceof Teacher);//————Teacher跟引用的类型Student没有任何关系,编译报错
    //        System.out.println(student instanceof String);//————String跟引用的类型Student没有任何关系,编译报错
        }
    }
    

---

二、多态类型转换

• 多态类型转换与基本类型转换一样

  • 低——>高（默认）

    基本类型转换：(int) c      (byte) a,b     
    (高)int        (低)byte
       c      =      a + b; //byte转换为int
    

    多态类型转换：Person（父类---高）    Student（子类---低）
      高                   低
    Person person = new Student();//子类转换为父类
    

  • 高——>低（强制）

    基本类型转换：(int) c      (byte) a,b     
    (低)byte               (高)int
        a      =    (byte) (b + c); //int 转换为 byte
    

    多态类型转换：Person（父类---高）    Student（子类---低）
    Person person = new Student();//子类转换为父类
    （低）Student类		  （高）强制Person类转换为Student类				
    Student person1     =         (Student) person;//父类转换为子类
    

• 例子

  • 父类——Person

    public class Person {
        public void run() {
            System.out.println("run");
        }
    }
    

  • 子类——Student

    public class Student extends Person{
        public void go() {
            System.out.println("go");
        }
    }
    

  • 测试类

    public class Application {
        public static void main(String[] args) {
           /*基本类型转换
            byte a = 2;
            int b = 5;
    
           低转高（默认）
             (高)int         (低)byte
                b     =       a + b;
    
           高转低（强制）
             (低)byte        (高)int
                a     =    (byte) (a + b);
            */
    
            //类型之间的转换：父（高）     子（低）
            //高                   低
            Person person = new Student();
            //person.go(); 父类只能用自己的方法，不能直接调用子类方法
            //可以将 person类型转换为Student类型，我们就可以使用Student类型的方法了！
            Student person1 = (Student) person;
            person1.go();//go
            ((Student)person).go();//go
    
            //子类转换为父类，可能丢失一些自己本来的方法（独有的方法，父类没有的）
            Student student = new Student();
            student.go(); //子类调用自身的方法
            Person person2 = student;//子类转换为父类（低转高，默认）
    //        person2.go(); 父类调用不了子类方法
        }
    }
    

• 小结

  1. 把子类转换为父类，向上转型；（默认转换，丢失子类中原本可直接调用的特有方法）
  2. 把父类转换为子类，向下转型；（强制转换）
  3. 方便方法的调用，减少重复的代码（简洁）

• 多态的经典案例（进阶）

  简单的多态和转型，相信大家都会，最后来个复杂的，一个经典案例：

  • 内容链接：Java面向对象练习—练习三