多态指的是同—个行为具有多个不同表现形式
。是指—个类实例(对象）的相同方法在不同情形下具有 不同表现形式。封装和继承是多态的基础，也就是说，多态只是—种表现形式而已。一个对象，同一个方法不同形态，方法必须重写
如何实现多态？多态的实现具有三种充要条件
继承 —— 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;//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 {
@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 关键字时需要适度使用，权衡好代码简洁性与可读性之间的关系。
