认识多态，使用多态的好处，多态下的类型转换问题

1.什么是多态？

   Java中的多态是指通过继承和重写实现的一种特性，允许一个父类型的引用变量指向其子类型的对象，并在运行时根据实际类型调用适当的方法。它有助于实现代码的灵活性、可扩展性和可维护性。

2.多态的前提

在Java中，多态的实现主要依靠两个关键概念：继承和重写。

1. 继承：子类可以继承父类的属性和方法。通过继承，子类可以拥有父类的特性，并可以通过添加新的属性和方法进行扩展。

2. 重写：子类可以重写继承自父类的方法，以实现自己的逻辑。重写方法具有相同的方法名、返回类型和参数列表，但可以修改方法体来覆盖父类的实现。

3.多态的具体代码

public class Test {
    public static void main(String[] args) {
        //目标：认识多态：对象多态，行为多态
        //1.对象多态
        People p1 = new Teacher();
        p1.Run();//行为多态，编译看左边，运行看右边

        People p2 = new Student();
        p2.Run();//行为多态，编译看左边，运行看右边
        
        System.out.println(p1.name);//对于变量，编译看左边，运行看左边
        System.out.println(p2.name);//对于变量，编译看左边，运行看左边        
    }
}
public class People {
    public String name = "父类People的名称";
    public void Run(){
        System.out.println("人跑得快！");
    }

}
public class Student extends People{
    public String name = "子类Student的名称";
    @Override
    public void Run() {
        System.out.println("人跑得贼快！");
    }
}
public class Teacher extends People{
    public String name = "子类Teacher的名称";
    @Override
    public void Run() {
        System.out.println("老师跑得贼快！");
    }
}

​

以上代码输出为：

老师跑得贼快！
人跑得贼快！

父类People的名称
父类People的名称

注意：变量不讲多态性，编译阶段访问的变量是谁，运行的时候就是谁

4.使用多态的好处

public class Test {
    public static void main(String[] args) {
        //目标：理解多态的好处
        //好处1：可以实现解耦合，右边对象可以随时切换
        People p1 = new Teacher();
        p1.Run();
        People p2 = new Student();
        p2.Run();
        //好处2：可以使用父类类型的变量作为形参，可以接收一切子类对象
        Student s = new Student();
        Teacher t = new Teacher();
        g(s);
        g(t);
    }

    public static void g(People p){

    }
}

//其他类还在，这里为了简便，省略不写

1.可以实现解耦合，右边对象可以随时切换

2.可以使用父类类型的变量作为形参，可以接收一切子类对象

多态下会产生一个问题：多态下不能使用子类的独有功能。

比如：在Student和Teacher类下各自写一个test()、teach()方法，通过p2.test()或p1.teach()是无法运行的。

5.多态下的类型转换问题

类型转换
1.自动类型转换:父类变量名= new 子类();     例如: People p = new Teacher();
2.强制类型转换:子类 变量名 =(子类)父类变量    例如 Teacher t = (Teacher)p;
 

强制类型转换的一个注意事项
存在继承/实现关系就可以在编译阶段进行强制类型转换，编译阶段不会报错。
运行时，如果发现对象的真实类型与强转后的类型不同，就会报类型转换异常 (ClassCastException) 的错误出来。

通过instanceof判断真实类型，进行强制转换，以调用子类的独有功能

​
public class Test {
    public static void main(String[] args) {
        
        People p1 = new Student();
        People p2 = new Teacher();
        g(p1);
        g(p2);

    }

    public static void g(People p){
        if(p instanceof Student){
            Student s = (Student) p;
            s.Test();
        }else if(p instanceof Teacher){
            Teacher t = (Teacher) p;
            t.Teach();
        }
    }
}
​

类型转换总结

1、类型转换有几种形式?能解决什么问题?
自动类型转换、强制类型转换。
可以把对象转换成其真正的类型，从而解决了多态下不能调用子类独有方法的问题。
2、强制类型转换需要注意什么?
存在继承/实现时，就可以进行强制类型转换，编译阶段不会报错
但是，运行时，如果发现对象的真实类型与强转后的类型不同会报错 (ClassCastException)
3、强制类型转前?Java建议我们做什么事情?
使用instanceof判断当前对象的真实类型:对象 instanceof 类型