💨更多相关知识👇

💖基于Spring+SpringMVC+Mybatis在线weiit-saas微信小程序电商系统

💖Spring中的bean的配置、作用范围、生命周期详细描述及使用（XML版上篇）

💖异常处理与解决方案详解上篇

💖异常处理与解决方案详解下篇

💖Math类与System类的常用方法使用

💖JavaEE中的静态方法定义、方法重载要求、return作用详解

💖List接口的常用方法，精华总结

💖JavaEE中的Stream流的常用方法

💖JavaEE中的Stream流知识点使用，精华总结，一文直接上手

🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈
 
🍂个人博客首页： KJ.JK
 
欢迎大家点赞👍收藏💖评论💬关注🔒
 
💖源码获取 | 💻学习交流 | 🤝商务合作 | 💨私信作者
 
💨推荐一款实用的模拟面试、刷题练习算法的神器、适用于所有的程序猿👉点击开始免费刷题，跟着博主走上巅峰💪

一、多态的概述

         多态是"同一个行为"具有"多种不同表现形式"   (同一个对象，在不同时刻表现出来的不同形态)

             
在Java中的体现形式是:

               * 父类的引用指向子类的对象

               * 接口的引用指向实现类的对象

二、多态的前提

 多态的前提:
             1.有继承关系/接口的实现
                 
             2.方法重写
                 
             3.父类引用指向子类对象               (还可以接口指向实现类)
                //Animal  d=new Dog();      //Usb u=new Mouse();

🌟代码演示

//父类动物
public class Animal {

public  void eat(){
    
    System.out.println("吃饭");
}

    public void run() {
    }
}

//子类猫
public class cat extends Animal{
    @Override
    public void eat() {
        
        System.out.println("猫吃鱼");
    }
}

//子类狗
public class Dog extends  Animal{
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

//测试类
public class Test {

    public static void main(String[] args) {


        //父类引用指向子类对象
        Animal  d=new Dog();
        d.eat();

        Animal  c=new cat();
        c.eat();

    }
}

三、多态中成员访问特点

🍂成员方法的访问特点

               编译看左边（父类）， 执行看右边（子类）

🌟代码演示

//父类人
public class Person {

    public void eat(){
        
        System.out.println("人吃饭");
    }
}

//子类狗
public class Dog extends  Person{
    @Override
    public void eat() {

        System.out.println("狗吃饭");
    }

    public  void run(){

        System.out.println("狗跑");
    }
}

//测试类
public class Test {


    /*
    多态的成员特点：

        对象 d 能调用什么方法，由对象 d左边 的父类 Person决定
        方法运行起来的效果，由对象 d 右边 new出来的子类 Dog决定

     */
    public static void main(String[] args) {


        Person  d=new Dog();
        d.eat();



//        d.run();    //报错,父类Person里面没有这个方法
                     //这个是多态的缺点,  多态下不能使用子类的特有功能
    }
}

🍂成员变量的访问特点

          编译看左边(父类)，执行看左边 (父类)    (变量没有多态性)

🌟代码演示

//父类人
public class Person {
    String name="人类";

}

//子类狗
public class Dog extends  Person{
    String name="萨摩耶";
}

//测试类
public class Test {


    /*

     变量的访问特点:
     
             编译看左边（父类），运行也看左边（父类）

            对象 d能够访问哪些成员变量，以及变量的结果是多少，全部
            取决于 d 左边的父类Person（即变量没有多态性）


     */
    public static void main(String[] args) {


        Person d=new Dog();
        System.out.println(d.name);
    }
}

🔥系列热门专栏🔥：
 
⚡《JavaEE进阶序列 | 从小白到工程师》系列文章⚡
 
⚡《JavaEE项目实战》系列文章⚡
 
⚡《JavaSwing项目合集》系列文章⚡
 
⚡《数据分析中的pandas》系列文章⚡

四、多态的优缺点

🍍多态的优点

                 * 提高代码的扩展性
                  
                 * 定义方法时，如果将 "父类" 或 "接口" 作为参数，在调用方法时，可以传递任意子类对象极大提高方法的通用性

🍍多态的缺点

             多态下不能使用子类的特有功能    (可以通过强转解决)

五、多态的类型转换

🍖向上转型：子类到父类（自动类型转换）（小变大）

        例子:
                Dog dog = new Dog();
                
                Animal a = dog;  //向上转型

🍖向下转型：父类到子类（强制类型转换） （大变小）

        例子:
               Animal a=new cat();
               
               cat c= (cat) a;
               
               c.catchMouse();

/*
向下转型好处:

         由于多态下不能使用子类的特有功能
         所以向下转型后，就"可以调用子类的特有功能"
*/

🍖向下转型的风险

      如果父类引用的 "实际类型" 与要转换的 "目标类型" 不同，就会出现类型转换异常：ClassCastException

💯 解决方法

使用 "instanceof" 关键字进行类型判断
              
          格式: 对象名 instanceof 类名             
              
          范例: a instanceof  cat
              
          作用: 判断左边的对象是否属于右边的类型,是返回true，否返回false  

🌟代码演示

//父类动物
public class Animal {

    public void eat(){

        System.out.println("动物吃饭");
    }
}

//子类猫
public class cat extends  Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

//子类狗
public class Dog extends  Animal {

    @Override
    public void eat() {
        System.out.println("狗吃饭");
    }


    public void run() {
        System.out.println("狗跑");
    }
}

//测试类
public class Test {
    public static void main(String[] args) {

        cat c=new cat();
        showskill(c);

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

        Dog dog=new Dog();
        showskill(dog);

    }

    public  static  void showskill(Animal a){
        a.eat();

        if(a instanceof  cat){

           cat  c2 =(cat) a;
           c2.catchMouse();

        }

        if(a instanceof  Dog){
            Dog dog=(Dog) a;
            dog.run();
        }
    }
}

六、多态的应用

         将 "方法的参数" 设计为 "父类" 或 "接口" ,调用方法时可以传入 "任意的子类"
             
         好处: "提高方法的适用性"    

🌟代码演示

//父类动物
public class Animal {
    String name="动物";
    public  void eat(){
        System.out.println("吃饭");
    }
}

//子类猫
public class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//子类狗
public class Dog extends Animal {

    String name="狗子";

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

//测试类
public class Person {

    public static void main(String[] args) {

        Dog d=new Dog();
        feed(d);

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

        Cat c=new Cat();
        feed(c);


    }



    //改进后
    //多态的应用:将方法的参数设计为父类或接口,调用方法时可以传入任意的子类
    //好处:提高方法的适用性
    public  static  void feed(Animal d){
        System.out.println("开始");
        d.eat();
        System.out.println("结束");

    }


    /*
        原来太过繁琐这样子
     */

//    public  static  void feed(Dog d){
//        System.out.println("开始");
//
//        d.eat();
//
//        System.out.println("结束");
//    }
//
//    public  static  void feed(Cat c){
//        System.out.println("开始");
//
//        c.eat();
//
//        System.out.println("结束");
//    }


}

七、多态的综合案例

🌟代码演示

//接口类
public interface USb {

    public  abstract  void connect();

    public  abstract  void exit();
}

//子类键盘
public class KeyBoard implements USb{

    @Override
    public void connect() {
        System.out.println("键盘连接");
    }

    @Override
    public void exit() {

        System.out.println("键盘退出");

    }


    public  void input(){
        System.out.println("键盘输入");
    }
}

//子类鼠标
public class Mouse implements   USb{
    @Override
    public void connect() {
        System.out.println("鼠标连接");
    }

    @Override
    public void exit() {

        System.out.println("鼠标退出");
    }



    public void click(){
        System.out.println("鼠标单击");
    }
}

//测试类
public class Computer {
    public static void main(String[] args) {

        Computer c=new Computer();


        Mouse mouse=new Mouse();
        c.useDevice(mouse);


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

        KeyBoard keyBoard=new KeyBoard();
        c.useDevice(keyBoard);


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

    }

    public  void useDevice(USb u){

        u.connect();

        if(u instanceof  Mouse){

            Mouse m=(Mouse) u;
            m.click();

        }

        if( u instanceof  KeyBoard){

            KeyBoard k=(KeyBoard) u;
            k.input();
        }

        u.exit();

    }
}

作者：KJ.JK

文章对你有所帮助的话，欢迎给个赞或者 star，你的支持是对作者最大的鼓励，不足之处可以在评论区多多指正，交流学习