多态指的是同—个行为具有多个不同表现形式

。是指—个类实例(对象）的相同方法在不同情形下具有 不同表现形式。封装和继承是多态的基础，也就是说，多态只是—种表现形式而已。一个对象，同一个方法不同形态，方法必须重写
如何实现多态？多态的实现具有三种充要条件

继承 —— extends
重写父类方法——@override
父类引用指向子类对象 ——Father p1 = new Son( );

比如下面这段代码

1   public  class  Fruit  {
2
3           int  num;
4
5           public  void  eat(){
6           System .out .println("eat  Fruit");
7                }
8        }
9
10      public  class  Apple  extends  Fruit{
11
12                @Override
13                 public  void  eat()  {
14                       super .num  =  10;
15                         System .out .println("eat  "  +  num  +  "  Apple");
16                }
17
18                 public  static  void  main(String[]  args)  {
19                          Fruit  fruit  =  new  Apple();
20                          fruit .eat();
21                }
22        }

你可以发现 main 方法中有—个很神奇的地方， Fruit fruit = new Apple() ， Fruit 类型的对象
竟然指向了 Apple 对象的引用，这其实就是多态 -> 父类引用指向子类对象，因为 Apple 继承于 Fruit，并且重写了 eat 方法，所以能够表现出来多种状态的形式

图解

再举一个经典例子，关于员工类和经理类的案例（选自java核心技术卷I中第五章）

import java.util.Objects;

public class Main {
    public static void main(String[] args) {

          var boss =new Manager("刘备",10000);
          boss.setBonus(2000);//刘老板的红利

          var staff=new Employee[3];  //先定义一个Employee的数组 ，var是可变类型，staff全部指向了Employee类型对象
          staff[0]=boss; //把boss(经理类对象)赋值给第一个堆区员工数组第一个元素。
          staff[1]=new Employee("关羽",8000); //其他两个都是普通员工，并且进行初始化构造
          staff[2]=new Employee("张飞",6000);

          for (Employee e:staff)
          {
              System.out.println("姓名："+e.getName()+"  工资："+e.getSalary());
          }

        Employee e1=new Employee("aaa",122);
        Manager m1=new Manager("AAA",12312);

        Employee e2=new Manager("ddd",12);//向上转型
        //Manager m2 =new Employee("hhh",123);//不兼容类型，实际上为Employee，需要Manager,你实际开辟的空间为Employee,但是数据类型是Manager，
        // 因为继承树：Manager > Employee ,Manager 比 Employee功能更多，条件更苛刻 ,开辟出的空间Employee无法容纳下你实际声明的数据类型Manager，——向下转型是几乎失败的

        //右边是提供的类型，左边是需要的类型,左边不可以大于右边，需求不可以大于供给。强制转型和你是谁没有关系。
        Manager p=(Employee)m1;//error
        Manager p1= (Employee)e2;//error
        Manager p2= (Employee)e1;//error

        Employee p3 =(Employee)e2;//全部正确
        Employee p4 =(Manager)e1;
        Employee p5 =(Employee)e1;
        Employee p6 =(Employee)m1;
        Employee p7=(Manager)e2;
        Employee p8 =(Manager)m1;

    }
}
public class Employee
{
    private int salary;

    private String name;

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Employee(String name,int salary) {
        this.salary = salary;
        this.name = name;
    }
}

public class Manager extends Employee{
    private int bonus;
    public Manager(String name,int salary)
    {
        super(name,salary);
        bonus=0;
    }

    public int getSalary()
    {
        int baseSalary =super.getSalary();
    return (baseSalary + bonus);
    }

    public void setBonus(int b)
    {
        bonus =b;
    }
}

//右边是提供的类型，左边是需要的类型,左边不可以大于右边，需求不可以大于供给。强制转型和你是谁没有关系。

Manager p=(Employee)m1;//error
Manager p1= (Employee)e2;//error
Manager p2= (Employee)e1;//error

    Employee p3 =(Employee)e2;//全部正确
    Employee p4 =(Manager)e1;
    Employee p5 =(Employee)e1;
    Employee p6 =(Employee)m1;
    Employee p7=(Manager)e2;
    Employee p8 =(Manager)m1;

垃圾代码,阿猫阿狗的故事

class Animal {
    public void sound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        animal1.sound();  // 输出 "Dog barks"
        animal2.sound();  // 输出 "Cat meows"
    }
}

拓展：

在Java中，var 是一个关键字，它在Java 10及其之后的版本中引入。var 关键字用于声明局部变量，并且可以根据变量的初始化值自动推断出变量的数据类型。

使用 var 关键字可以简化代码，并且使代码更具可读性。通过自动推断数据类型，可以避免在声明变量时重复书写相同的类型，并且可以更加灵活地处理不同类型的变量。

示例代码：

var message = "Hello, World!"; // 推断 message 为 String 类型
var count = 10; // 推断 count 为 int 类型
var pi = 3.14; // 推断 pi 为 double 类型

需要注意的是，一旦使用 var 声明一个变量，该变量的类型就被确定下来，并且不能再改变。编译器会根据变量的初始化值推断出最合适的类型，并且编译后的代码中仍然会有明确的类型。

另外，尽管 var 关键字可以简化代码，但也要注意在可读性方面的平衡。在某些情况下，显式地声明变量的类型可能更有助于代码的可读性和维护性。因此，在使用 var 关键字时需要适度使用，权衡好代码简洁性与可读性之间的关系。