看到这句话的时候证明：此刻你我都在努力
加油陌生人


个人主页：Gu Gu Study
专栏：一步一步了解Java

喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹

喜欢的话可以点个赞谢谢了。
作者：小闭

何为多态

在Java中，多态（Polymorphism）是一种允许不同类的对象对同一消息做出响应的能力，即同一个接口可以被不同的实例以不同的方式实现。多态性是面向对象编程的一个核心概念，它使得代码更加灵活和可扩展。
多态性主要通过以下几种方式实现：

1. 方法重载（Overloading）：这是编译时多态的一个例子。方法重载允许同一个类中有多个同名方法，只要它们的参数列表不同（参数的类型、数量或顺序不同）。
2. 方法重写（Overriding）：这是运行时多态的一个例子。当子类继承父类时，子类可以重写父类的方法。如果子类对象调用了一个被重写的方法，将执行子类中的方法实现，而不是父类中的实现。
3. 接口实现：一个类可以实现一个或多个接口，接口定义了一组方法规范，具体的实现类必须提供这些方法的具体实现。不同的实现类可以以不同的方式实现同一个接口中定义的方法。
4. 抽象类：抽象类可以包含抽象方法，这些方法没有具体的实现，必须由继承抽象类的子类来实现。这也是一种多态的体现，因为不同的子类可以提供不同的实现。

多态的使用可以带来以下好处：

• 代码复用：通过继承和接口实现，可以减少代码的重复编写。
• 扩展性：通过多态，可以在不修改现有代码的情况下，引入新的类和对象。
• 灵活性：多态允许程序在运行时动态地绑定方法调用，使得程序更加灵活。

多态是Java中实现开闭原则（对扩展开放，对修改封闭）的关键机制之一，它允许程序更容易适应变化，同时保持代码的稳定性和可维护性。
多态实现的条件：

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法

总的来说：多态即是不同对象，不同的的态度。

方法重载的多态

方法重载在前面其实已经说过了，下面是一个方法重载多态的情况：

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）是指子类提供一个特定的实现，覆盖从父类继承来的方法的实现。这是运行时多态的一个体现，意味着在程序运行时，会根据对象的实际类型来调用相应的方法。
要实现方法重写，需要满足以下条件：

1. 方法名、参数列表和返回类型：子类重写的方法必须具有与父类被重写方法相同的方法名、参数列表和返回类型。如果返回类型不同，则不是重写，而是重载（Overloading）。
2. 访问权限：子类重写的方法不能具有比父类更严格的访问权限。例如，如果父类中的方法是public的，子类重写的方法也必须是public或protected，但不能是private。
3. 非静态方法：重写必须发生在非静态方法上。静态方法（Static methods）不能被重写。
4. 非最终方法：如果父类中的方法是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修饰类，则类不能被继承

第二：修饰类的方法则方法不能被重写

第三：修饰成员变量则变量相当于常量，无法在进行修改。