✅如何理解Java中的多态？
- ✅理解Java中的多态
- ✅ 扩展知识仓
- ✅方法的重载
- ✅方法的重写
- ✅重载和重写的区别区分
✅理解Java中的多态
多态的概念比较简单，就是同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
如果按照这个概念来定义的话，那么多态应该是一种运行期的状态。为了实现运行期多态，或者说是动态绑定，需要满足三个条件：
- 有类继承或者接口实现
- 子类要重写父类的方法
- 父类的引用指向子类的对象
简单用代码来解释一下：
public class Parent {
public void call() {
sout("im Parent") ;
}
}
// 1.有类继承或者接口实现
public class Son extends Parent {
// 2.子类要重写父类的方法
public void call() {
sout("im Son");
}
}
// 1.有类继承或者接口实现
public class Daughter extends Parent {
// 2.子类要重写父类的方法
public void call() {
sout("im Daughter");
}
}
public class Test {
public static void main(stringl] args) {
Parent p = new Son(); //3.父类的引用指向子类的对象
Parent p1 = new Daughter(); //3.父类的引用指向子类的对象
}
}
这样，就实现了多态，同样是Parent类的实例，p.call 调用的是Son类的实现、p1.call调用的是Daughter的实现。
有人说，你自己定义的时候不就已经知道p是son，p1是Daughter了么。但是，有些时候你用到的对象并不都是自己声明的。
比如Spring 中的IOC出来的对象，你在使用的时候就不知道他是谁，或者说你可以不用关心他是谁。根据具体情况而定。
前面说多态是一种运行期的概念。还有一种说法，包括维基百科也说明，认为多态还分为动态多态和静态多态。
一般认为Jva中的函数重载是一种静态多态，因为他需要在编译期决定具体调用哪个方法。关于这一点，不同的人有不同的见解，建议在面试中如果被问到，可以这样回答:
我认为，多态应该是一种运行期特性，Java中的重写是多态的体现。不过也有人提出重载是一种静态多态的想法，这个问题在StackOverflow等网站上有很多人讨论，但是并没有什么定论。我更加倾向于重载不是多态。
这样沟通，既能体现出你了解的多，又能表现出你有自己的思维，不是那种别人说什么就是什么的。
✅ 扩展知识仓
✅方法的重载
方法的重载就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者重载方法。
public class HollisExample {
// 方法重载 - 第一个方法
public void display(int a) {
System.out.println("Got Integer data.");
}
// 方法重载 - 第二个方法
public void display(String b) {
System.out.println("Got String data.");
}
}
总之，方法的重载（Overloading）是指在同一个类中，可以有多个同名方法，只要它们的参数列表不同即可。方法的重载可以是参数个数的不同，也可以是参数类型的不同。
方法的重载使得程序可以根据不同的参数列表调用同名方法，增加了程序的灵活性和可读性。
再看一段代码：
public class Calculator {
// 加法方法，接受两个整数参数
public int add(int a, int b) {
return a + b;
}
// 加法方法，接受三个整数参数
public int add(int a, int b, int c) {
return a + b + c;
}
// 加法方法，接受两个浮点数参数
public double add(double a, double b) {
return a + b;
}
// 加法方法，接受三个浮点数参数
public double add(double a, double b, double c) {
return a + b + c;
}
public static void main(String[] args) {
Calculator calculator = new Calculator();
int sum1 = calculator.add(2, 3); // 调用第一个add方法（两个整数）
int sum2 = calculator.add(4, 5, 6); // 调用第二个add方法（三个整数）
double sum3 = calculator.add(2.5, 3.5); // 调用第三个add方法（两个浮点数）
double sum4 = calculator.add(4.5, 5.5, 6.5); // 调用第四个add方法（三个浮点数）
System.out.println("Sum1: " + sum1);
System.out.println("Sum2: " + sum2);
System.out.println("Sum3: " + sum3);
System.out.println("Sum4: " + sum4);
}
}
在这个例子中，创建了一个名为 Calculator 的类，其中包含了四个名为 add 的方法。这四个方法分别接受不同类型和数量的参数，实现了方法的重载。在 main 方法中，我们根据传入的参数类型和数量调用相应的 add 方法，演示了方法的重载在实际编程中的应用。
✅方法的重写
重写指的是在Java的子类与父类中有两个名称、参数列表都相同方法的情况。由于他们具有相同的方法签名，所以子类中的新方法将覆盖父类的原有方法。
public class Parent {
// 父类的方法
public void display() {
System.out.println("Parent display()");
}
}
class Child extends Parent {
// 子类重写了父类的方法
@Override
public void display() {
System.out.println("Child display()");
}
}
public class Main {
public static void main(String[] args) {
Parent objl = new Parent();
obj1.display(); // 输出“Parent display()”
Parent obj2 = new Child();
obj2.display(); // 输出“Child display()”
}
}
总之，方法的重写（Overriding）是面向对象编程中的一个重要概念，指的是在子类中重新定义父类中的方法，以覆盖（override）父类中的原有方法。重写方法的目的是为了在子类中提供特定的行为，而不必修改父类的代码。
方法的重写需要满足以下规则：
1.方法名、参数列表必须与父类中的方法完全****相同。
2.返回类型可以是父类方法返回类型的子类型。
3.子类方法的访问级别不能低于父类方法的访问级别。
看一个代码实现方法的重写和多态的应用：
class Animal {
public void makeSound() {
System.out.println("The animal makes a sound");
}
}
class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("The dog barks");
}
public void bark() {
System.out.println("The dog barks");
}
}
class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("The cat meows");
}
public void meow() {
System.out.println("The cat meows");
}
}
class Zoo {
public void playWithAnimal(Animal animal) {
animal.makeSound(); // 调用 Animal 类的方法
animal.bark(); // 调用 Dog 类的方法，因为 animal 实际上是 Dog 对象
animal.meow(); // 调用 Cat 类的方法，因为 animal 实际上是 Cat 对象
}
}
public class Main {
public static void main(String[] args) {
Zoo zoo = new Zoo();
Animal animal1 = new Dog();
Animal animal2 = new Cat();
zoo.playWithAnimal(animal1); // 输出 "The dog barks" 和 "The dog barks" 和 "The dog barks"
zoo.playWithAnimal(animal2); // 输出 "The cat meows" 和 "The cat meows" 和 "The cat meows"
}
}
在这个例子中，定义了一个 Animal 类，两个子类 Dog 和 Cat，以及一个 Zoo 类。Dog 类和 Cat 类分别重写了 makeSound 方法，并且添加了各自特有的方法 bark 和 meow。在 Zoo 类的 playWithAnimal 方法中，我们传入了一个 Animal 类型的参数。由于多态的存在，这个参数实际上可以是一个 Dog 对象或一个 Cat 对象。在方法内部，我们调用了 animal 的 makeSound 方法（实际上是调用子类的方法），以及子类特有的方法 bark 和 meow。因此，根据传入的参数类型，我们可以得到不同的输出结果。这个例子展示了方法的重写和多态的应用，使得程序更加灵活和可扩展。
✅重载和重写的区别区分
1、重载是一个编译期概念、重写是一个运行期概念。
2、重载遵循所谓 “编译期绑定” ， 即在编译时根据参数变量的类型判定应该调用哪一个方法。
3、重写遵循所谓 “运行期绑定” ， 即在运行的时候，根据引用变量所指向的实际对象的类型来调用方法。
