Day35--instanceof和类型转换

Day35--instanceof和类型转换

要掌握的是：

1.instanceof判断

2.对象的类型强制转换

instanceof 是一个二元操作符，用于判断一个对象是否是某个特定类型（类、接口、抽象类等）的实例。

语法：
object instanceof type其中，object 是一个对象引用，type 是一个类型（可以是类、接口、抽象类等）。

可以这样理解。

在 Java 中，instanceof 操作符用于判断一个对象是否是某个特定类（或接口）的实例，或者是这个类的子类的实例。如果对象 x 的实际类型是 Y 或者是 Y 的子类，那么 x instanceof Y 就会返回 true；如果对象 x 的实际类型既不是 Y也不是 Y 的子类，那么就会返回 false。

作用和用法：
类型检查：
可以在运行时确定一个对象的实际类型，以便进行适当的处理。例如，在多态的情况下，父类的引用可以指向子类的对象，使用 instanceof 可以判断该引用实际指向的对象是否属于特定的子类类型。

Object obj = new Student();
if (obj instanceof Student) {
    Student student = (Student) obj;
    // 可以安全地调用 Student 类特有的方法
}

示例：

创建了Person、Student、Teacher、Application类。其中，Student、Teacher是Person的子类，在Application里面对Student实例化，引用类型为Object，引用变量为object，并通过instanceof判断object分别是否是属于Person、Student、Teacher、Object、String

package com.liu.oop.demo06;

public class Person {

}

package com.liu.oop.demo06;

public class Student extends Person{

}

package com.liu.oop.demo06;

public class Teacher extends Person {
}

package com.liu.oop;
import com.liu.oop.demo06.Student;
import com.liu.oop.demo06.Person;
import com.liu.oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {
        Object object = new Student();
        
        //Object > String
		//Object > Person > Teacher
		//Object > Person > Student
        
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);


    }
}

输出结果：

true
true
true
false
false

进一步练习：判断下面的输出结果

package com.liu.oop;
import com.liu.oop.demo06.Student;
import com.liu.oop.demo06.Person;
import com.liu.oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {
        Object object = new Student();
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);
        System.out.println("===========================");

        Person person = new Student();
        System.out.println(person instanceof Student);
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Teacher);
        //System.out.println(person instanceof String); //编译报错
        System.out.println("=================================");
        
        Student student = new Student();
        System.out.println(student instanceof Student);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Object);
		//System.out.println(student instanceof Teacher); //编译报错
		//System.out.println(student instanceof String); //编译报错

    }
}

结果：

true
true
true
false
false
===========================
true
true
true
false
=================================
true
true
true

另一个实例：在Person里面写下run方法，输出run；在Student里面写下go方法，输出go

package com.liu.oop.demo06;

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

package com.liu.oop.demo06;

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

这时，在Application里面创建Person引用类型、Student实际类型的引用变量student，并且想通过student来使用go方法是不行的。（因为变量的方法与变量的引用类型有关）

package com.liu.oop;
import com.liu.oop.demo06.Student;
import com.liu.oop.demo06.Person;
import com.liu.oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {
        //类型之间的转化

        //高-------->低
        Person student = new Student();
        student.go();//报错
    }
}

这时候就要想办法将student转换为 Student类型，也就是要将父类型转换为子类型，要强制转换

package com.liu.oop;
import com.liu.oop.demo06.Student;
import com.liu.oop.demo06.Person;
import com.liu.oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {
        //类型之间的转化

        //高-------->低
        Person student = new Student();
        Student s1 = (Student) student;
        s1.go();

    }
}

或者说，将```

Student s1 = (Student) student;
        s1.go();

简化为

((Student)student).go();

拓展：想把实际类型为Student的student转换为Person类型，该怎样转换？

 Student student=new Student();
        Person person=student;//自动转换

这时，person还能使用Student才有的go方法吗？

不能

 Student student=new Student();
        
        Person person=student;//自动转换
        
        person.go();//报错

这说明，在子类转换为父类的过程中，会丢失一些方法

总结：

1.父类引用指向子类的对象
2.把子类转换为父类，向上转型；
3.把父类转换为子类，向下转型；强制转换
4.方便方法的调用，减少重复的代码！