看到这句话的时候证明：此刻你我都在努力
加油陌生人
何为多态
在Java中，多态（Polymorphism）是一种允许不同类的对象对同一消息做出响应的能力，即同一个接口可以被不同的实例以不同的方式实现。多态性是面向对象编程的一个核心概念，它使得代码更加灵活和可扩展。
多态性主要通过以下几种方式实现：
- 方法重载（Overloading）：这是编译时多态的一个例子。方法重载允许同一个类中有多个同名方法，只要它们的参数列表不同（参数的类型、数量或顺序不同）。
- 方法重写（Overriding）：这是运行时多态的一个例子。当子类继承父类时，子类可以重写父类的方法。如果子类对象调用了一个被重写的方法，将执行子类中的方法实现，而不是父类中的实现。
- 接口实现：一个类可以实现一个或多个接口，接口定义了一组方法规范，具体的实现类必须提供这些方法的具体实现。不同的实现类可以以不同的方式实现同一个接口中定义的方法。
- 抽象类：抽象类可以包含抽象方法，这些方法没有具体的实现，必须由继承抽象类的子类来实现。这也是一种多态的体现，因为不同的子类可以提供不同的实现。
多态的使用可以带来以下好处：
- 代码复用：通过继承和接口实现，可以减少代码的重复编写。
- 扩展性：通过多态，可以在不修改现有代码的情况下，引入新的类和对象。
- 灵活性：多态允许程序在运行时动态地绑定方法调用，使得程序更加灵活。
多态是Java中实现开闭原则（对扩展开放，对修改封闭）的关键机制之一，它允许程序更容易适应变化，同时保持代码的稳定性和可维护性。
多态实现的条件：
- 必须在继承体系下
- 子类必须要对父类中方法进行重写
- 通过父类的引用调用重写的方法
总的来说：多态即是不同对象，不同的的态度。
方法重载的多态
方法重载在前面其实已经说过了，下面是一个方法重载多态的情况：
public class Cat {
String type="猫咪";
public void eat(){
System.out.println(type+"吃猫粮");
}
public void eat(int n){
System.out.println(type+"吃"+n+"两猫粮");
}
}
class Test{
public static void main(String[] args) {
Cat cat=new Cat();
cat.eat();
cat.eat(1);
}
}
上面我们对方法进行重载，然后传参不同时，同一个方法却呈现不同的打印方式即（不同的形态）。
方法重写的多态
我们先要认识，何为重写：
在Java中，重写（Overriding）是指子类提供一个特定的实现，覆盖从父类继承来的方法的实现。这是运行时多态的一个体现，意味着在程序运行时，会根据对象的实际类型来调用相应的方法。
要实现方法重写，需要满足以下条件：
- 方法名、参数列表和返回类型：子类重写的方法必须具有与父类被重写方法相同的方法名、参数列表和返回类型。如果返回类型不同，则不是重写，而是重载（Overloading）。
- 访问权限：子类重写的方法不能具有比父类更严格的访问权限。例如，如果父类中的方法是public的，子类重写的方法也必须是public或protected，但不能是private。
- 非静态方法：重写必须发生在非静态方法上。静态方法（Static methods）不能被重写。
- 非最终方法：如果父类中的方法是final的，则不能被重写。
下面是一个简单的示例，展示如何在Java中重写方法：
class Animal {
public void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
@Override // 这是一个注解，用于指示该方法重写了父类的方法
public void sound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Animal myAnimal = new Dog(); // 向上转型
myAnimal.sound(); // 输出 "Dog barks"，展示了运行时多态
}
}在这个例子中，Dog 类继承自 Animal 类，并重写了 sound() 方法。当我们创建 Dog 类的实例并将其向上转型为 Animal 类型时，调用 sound() 方法会执行 Dog 类中重写的方法，而不是 Animal 类中的原始方法。这就是多态性的一个典型应用，它允许程序在运行时根据对象的实际类型来确定调用哪个方法。
了解完重写我们在看看，下面的代码：
public class Animal {
String name="aaaa";
public void eat(){
System.out.println("吃东西。。。。。");
}
}
class Dog extends Animal{
String name;
public Dog(String name) {
this.name = name;
}
public void eat(){
System.out.println("吃狗粮。。。");
}
}
class Cat extends Animal{
String name;
public Cat(String name) {
this.name = name;
}
public void eat(){
System.out.println("吃猫粮。。。");
}
}
class Test{
public static void main(String[] args) {
Animal animal=new Dog("旺财");
animal.eat();
animal=new Cat("小黑");
animal.eat();
}
}
我们在调用eat（）方法时却呈现了不同的形态，即：一个吃猫粮，一个吃狗粮。
我们也可以用静态方法实现多态如下：
public class Animal {
String name="aaaa";
public void eat(){
System.out.println("吃东西。。。。。");
}
}
class Dog extends Animal{
String name;
public Dog(String name) {
this.name = name;
}
public void eat(){
System.out.println("吃狗粮。。。");
}
}
class Cat extends Animal{
String name;
public Cat(String name) {
this.name = name;
}
public void eat(){
System.out.println("吃猫粮。。。");
}
}
class Test{
public static void eat(Animal animal){
animal.eat();
}
public static void main(String[] args) {
Dog dog=new Dog("旺财");
eat(dog);
Cat cat=new Cat("小黑");
eat(cat);
}
}
这里我们在Test中实现了一个静态方法eat（Animal animal）然后传递一个对象进去即可完成多态。
其实上面的代码还涉及了，类的向上转型。我们接下来就讲讲向上转型和向下转型。
向上转型和向下转型
在Java中，向上转型（Upcasting）和向下转型（Downcasting）是面向对象编程中多态性的一部分，它们允许我们处理不同类型的对象，但以更通用的类型进行操作。
向上转型（Upcasting）
向上转型是指将子类对象赋值给父类引用的过程。向上转型是安全的，因为子类是父类的特化。这意味着子类继承了父类的所有属性和方法，所以子类对象可以被看作是父类对象。
示例代码：
class Animal {
void makeSound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
void makeSound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Animal myAnimal = new Dog(); // 向上转型
myAnimal.makeSound(); // 将调用Dog类的makeSound方法
}
}在这个例子中，Dog 类是 Animal 类的子类。我们创建了一个 Dog 类的实例，并将这个实例赋值给 Animal 类型的引用 myAnimal。由于向上转型是安全的，编译器允许这样做，并且当我们调用 makeSound() 方法时，将调用 Dog 类中重写的方法。
向下转型（Downcasting）
向下转型是指将父类对象赋值给子类引用的过程。向下转型是不安全的，因为父类引用可能没有指向实际的子类对象。如果向下转型不正确，将会导致 ClassCastException。
示例代码：
class Animal {
void makeSound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
void makeSound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Animal myAnimal = new Dog();
Dog myDog = (Dog) myAnimal; // 向下转型
if (myAnimal instanceof Dog) {
Dog myDogSafe = (Dog) myAnimal; // 安全的向下转型
myDogSafe.makeSound(); // 将调用Dog类的makeSound方法
} else {
System.out.println("myAnimal is not a Dog");
}
}
}在这个例子中，我们首先向上转型，将 Dog 对象赋值给 Animal 类型的引用 myAnimal。然后我们尝试向下转型，将 myAnimal 转换为 Dog 类型的引用 myDog。如果 myAnimal 实际上指向了一个 Dog 对象，那么向下转型将成功，否则将抛出 ClassCastException。
为了安全地进行向下转型，可以使用 instanceof 操作符来检查 myAnimal 是否确实指向了一个 Dog 对象。如果 instanceof 检查为 true，那么向下转型是安全的。
注意：
向上转型后只能调用父类的成员和方法，无法再调用子类特有的成员变量或方法。
一个小坑
避免在调用构造方法时调用已经重写过的方法，否则很容易出错。
如下代码：在实例化子类对象时，我们必须先调用完成父类的构造方法，然而Animal的构造方法又调用了子类的已经重写的方法func，这时发生动态绑定，方法执行重写的func，而此时num的值未完成初始化，就打印了0出来，所以打印结果就如下图：
public class Test {
public static void main(String[] args) {
Dog dog=new Dog();
}
}
class Animal{
public void func(){
System.out.println("动物");
}
public Animal(){
func();
}
}
class Dog extends Animal{
int num=999;
public void func(){
System.out.println("狗");
System.out.println(num);
}
}
浅谈final关键字
第一：final修饰类，则类不能被继承
第二：修饰类的方法则方法不能被重写
第三：修饰成员变量则变量相当于常量，无法在进行修改。
