多态指的是同—个行为具有多个不同表现形式
。是指—个类实例(对象）的相同方法在不同情形下具有 不同表现形式。封装和继承是多态的基础，也就是说，多态只是—种表现形式而已。一个对象，同一个方法不同形态，方法必须重写
如何实现多态？多态的实现具有三种充要条件
继承 —— 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;//errorManager p1= (Employee)e2;//errorManager p2= (Employee)e1;//errorEmployee 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;//errorEmployee 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 {@Overridepublic void sound() {System.out.println("Dog barks");}
}class Cat extends Animal {@Overridepublic 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 关键字时需要适度使用，权衡好代码简洁性与可读性之间的关系。
