转型和instanceof关键字
- 向上转型
- 向下转型
- instanceof关键字
向上转型
向上转型和继承和覆写构成了多态，多态的出现使得父类成为一个接口，屏蔽了不同子类的差异性，为统一的变成成为了可能
多态:当同一个类的不同对象，进行同一种行为（调用相同的方法）将会有不同的表现形式（行为有差异）
- 没有用多态举例
class Person{
public String name;
public int age;
}
class Worker extends Person{
//工人说话
public void say(){
System.out.println("今天好好工作...");
}
}
class Student extends Person{
//学生说话
public void say(){
System.out.println("今天好好学习...");
}
}
public class MainTest{
public static void fun(Student st){
st.say();
}
public static void fun(Worker wo){
wo.say();
}
public static void main(String[]args){
MainTest ma=new MainTest();
fun(new Student());
fun(new Worker());
}
}
output:
今天好好学习...
今天好好工作...
这样并没有错，但试想一下当子类很多时，就需要写很多的不同的fun函数进行接收子类的对象，如此此时用多态的话，用父类来统一接收子类的对象，然后通过接收的子类的不同而调用不同子类的方法，这样就使得程序简化了很多
class Person{
public String name;
public int age;
public void say(){
System.out.println("人工作..");
}
}
class Worker extends Person{
//工人说话：覆写父类
public void say(){
System.out.println("今天好好工作...");
}
}
class Student extends Person{
//学生说话:覆写父类
public void say(){
System.out.println("今天好好学习...");
}
}
public class MainTest{
//此时只需要一个接收子类的函数
public static void fun(Person pr){
pr.say();
}
public static void main(String[]args){
MainTest ma=new MainTest();
fun(new Student());
fun(new Worker());
}
}
output:
今天好好学习..
今天好好工作...
多态的构成条件为 继承 方法覆写 和向上转型，用向上转型可以完成子类继承自父类的方法和子类覆写父类的方法，但当需要调用子类特有的方法就显得无能为力了，这时的向下转型就显得有用了
但是在进行向下转型前有一个条件一定要先发生向上转型，
在没有发生向上转型的情况下进行向下转型和发生类的转化异常
class Person{
}
class Student extends Person{
}
public class InstanceofTest{
public static void main(String[]args){
Student st=(Student)new Person();//直接进行向下转型
}
}
output:
Exception in thread "main" java.lang.ClassCastException: Person cannot be cast to Student
- 需要先进行向上转型的理解
Person pr=new Student //pr知道Student是自己的父类
Student st=(Student)pr
如果没有进行向上转型 pr根本就不知道谁是自己的子类，总言之他不知道st是不是自己的儿子，只有让其和子类建立关系才行
- instanceof关键字
刚刚看到如果没有进行向上转型而直接向下转型会发生异常，instanceof关键字可以进行判断有没有发生向上转型
instanceof判断一个对象是否属于该类 对象instanceof 类通过如果发生了向上转型 则pr这个对象也是属于 Student的
案例：向下转型和instanceof 假设同时需要调用子类覆写自父类的方法和子类特有的方法
class Person{
public String name;
public int age;
public void say(){
System.out.println("人工作..");
}
}
class Worker extends Person{
//工人说话：覆写父类
public void say(){
System.out.println("今天好好工作...");
}
//工人特有：工资
public void getSalary(){
System.out.println("今天赚了好多钱.....");
}
}
class Student extends Person{
//学生说话:覆写父类
public void say(){
System.out.println("今天好好学习...");
}
//学生特有：作业
public void doHouseWork(){
System.out.println("试卷做了一张又是一张....");
}
}
public class MainTest{
//此时只需要一个接收子类的函数
public static void fun(Person pr){//进行向上转型
pr.say();//调用子类覆写自父类的方法
if(pr instanceof Student){//pr也是学生的对象{
Student st=(Student)pr;//则发生向下转型
st.doHouseWork();
}
if(pr instanceof Worker){
Worker wo=(Worker)pr;
wo.getSalary();
}
}
public static void main(String[]args){
MainTest ma=new MainTest();
fun(new Student());
fun(new Worker());
}
}
output:
今天好好学习...
试卷做了一张又是一张....
今天好好工作...
今天赚了好多钱.....
此时的父类为不同子类调用自身的特有方法或者是覆写自父类的方法提供了统一的 接口，屏蔽了不同子类的差异性
- instanceof的其他作用
以前知道如果一个对象在没有进行实例化的时候直接使用会发生空指针异常
例如：
class Person{
public void show(){
System.out.println("hello");
}
}
public class InstanceofTest{
public static void main(String[]args){
Person pr=null;
pr.show();
}
}
output:
main" java.lang.NullPointerException
class Person{
public void show(){
System.out.println("hello");
}
}
public class InstanceofTest{
public static void main(String[]args){
Person pr=null;
if(pr instanceof Person)//验证pr是不是Person的对象
pr.show();
}
}
2023.5.4对于向上转型和任何类型都可以使用Object接收的问题
1.向上转型，直接上就是父类的引用和子类的引用同时指向子类对象的情景
2.任何对象都可以使用Object接收，实际上任何的类型都可以向上转型成Object类型。然后打印出该类型，是调用toString方法（复写了toString则调用的重写后的方法）
