多态的基本用途

在Java中，多态是一个强大的功能。多态，简单来说，就是“多种形态”的意思，它允许我们以统一的方式处理不同类型的对象，而这些对象在执行相同操作时，可以展现出不同的行为。

一、多态的定义

想象一下，你正在编写一个程序，这个程序需要处理多种类型的动物，比如猫、狗、鸟等。每种动物都有自己的吃和叫的方式。如果你不使用多态，你可能会为每种动物都编写一个专门的函数来处理它们的吃和叫的行为。但这样做不仅代码冗余，而且每当新增一种动物时，你都需要添加更多的函数。

多态的出现，就是为了解决这个问题。它允许我们定义一个统一的接口（在Java中是接口Interface，在C++中是纯虚函数或抽象类），让所有的动物类都实现这个接口。这样，无论你是处理猫、狗还是鸟，都可以通过这个统一的接口来调用它们的吃和叫的行为，而不需要关心它们具体的实现细节。

二、多态的实现方式

在Java等面向对象的语言中，多态主要有两种实现方式：接口实现和继承（包括子类重写父类方法）。

1. 接口实现

   接口是一组方法的声明，但它不包含方法的实现。任何实现了该接口的类都必须提供这些方法的具体实现。通过接口，我们可以定义一组规范，让不同的类去实现这些规范，从而实现多态。

   interface Animal {  
       void eat();  
       void makeSound();  
   }  
    
   class Dog implements Animal {  
       @Override  
       public void eat() {  
           System.out.println("Dog is eating meat.");  
       }  
    
       @Override  
       public void makeSound() {  
           System.out.println("Woof!");  
       }  
   }  
    
   class Cat implements Animal {  
       @Override  
       public void eat() {  
           System.out.println("Cat is eating fish.");  
       }  
    
       @Override  
       public void makeSound() {  
           System.out.println("Meow!");  
       }  
   }

   在上面的例子中，Dog和Cat类都实现了Animal接口，并提供了eat和makeSound方法的具体实现。这样，我们就可以通过Animal类型的引用来引用Dog或Cat的实例，并调用它们的方法，实现多态。

   1. 继承与方法重写

      除了接口实现，继承也是实现多态的一种方式。在继承关系中，子类可以重写父类的方法，从而改变方法的行为。这样，当我们通过父类类型的引用来引用子类对象时，调用的是子类重写后的方法，实现了多态。

      class Animal {  
          void eat() {  
              System.out.println("This animal eats something.");  
          }  
       
          void makeSound() {  
              System.out.println("Some sound.");  
          }  
      }  
       
      class Dog extends Animal {  
          @Override  
          public void eat() {  
              System.out.println("Dog is eating meat.");  
          }  
       
          @Override  
          public void makeSound() {  
              System.out.println("Woof!");  
          }  
      }  
       
      // 使用方式与接口实现类似

      举一个多态应用的实例：

      class A {
          public String show(D obj) {
              return ("A and D");
          }
          public String show(A obj) {
              return ("A and A");
          } 
      }
      class B extends A{
          public String show(B obj){
              return ("B and B");
          }
          
          public String show(A obj){
              return ("B and A");
          } 
      }
      class C extends B{
      }
      class D extends B{
      }
      public class Test {
          public static void main(String[] args) {
              A a1 = new A();
              A a2 = new B();
              B b = new B();
              C c = new C();
              D d = new D();
              
              System.out.println("1--" + a1.show(b));//A and A
              System.out.println("2--" + a1.show(c));//A and A
              System.out.println("3--" + a1.show(d));//A and D
              
              System.out.println("4--" + a2.show(b));//B and B
              System.out.println("5--" + a2.show(c));//B and B
              System.out.println("6--" + a2.show(d));//B and B
              
              System.out.println("7--" + b.show(b));//B and B
              System.out.println("8--" + b.show(c));//B and B
              System.out.println("9--" + b.show(d));//B and B      
          }
      }

      package Base;
      ​
      public class Base {
          public static void main(String[] args) {
              Base p1=new Son1();
              Base p2=new Son2();
              p1.func();//Son1 print 编译看左边，运行看右边
              System.out.println(p1.name);//Base 编译看左边，运行看左边
              p2.func();//Son2 print
              System.out.println(p2.name);//Base
          }
      }​
      

      package Base;
      ​
      public class Base {
         void func(){
             System.out.println("Base print");
         }
          String name="Base";
      ​
      }
      class Son1 extends Base{
         void func(){
             System.out.println("Son1 print");
         }
          String name="Son1";
      }
      class Son2 extends Base{
          void func(){
              System.out.println("Son2 print");
          }
          String name="Son2";
      }

      与方法重写不同，字段在子类中并没有真正的“重写”机制。相反，如果子类声明了一个与父类同名的字段，那么子类中的字段会隐藏（或遮蔽）父类中的字段。这种情况下，访问哪个字段取决于引用的类型（对于静态字段）或对象的实际类型（对于实例字段，但在这个例子中由于是通过父类引用访问的，所以实际上还是访问父类的字段）。然而，由于Java不支持通过父类引用来直接访问子类字段，所以这里的访问总是通过父类引用指向的对象的实际类型来决定的，但由于Java的编译时类型检查，这里实际上访问的是父类的字段。

   2. 注意，虽然继承可以实现多态，但过度使用继承会导致类之间的耦合度增加，不利于代码的维护和扩展。因此，在可能的情况下，推荐使用接口实现多态。

三、多态的优势

1. 代码复用：通过多态，我们可以编写更加通用的代码，减少代码冗余。比如，我们可以编写一个函数，它接受任何实现了特定接口的对象作为参数，并调用接口中的方法。这样，无论传入的是哪种类型的对象，函数都能正确执行。

2. 可扩展性：当需要添加新的功能或类型时，我们只需要定义一个新的类来实现相应的接口或继承相应的类，并提供必要的方法实现即可。这样，我们不需要修改现有的代码，就能实现新的功能。

3. 灵活性：多态使得我们可以在运行时动态地决定对象的类型和行为。这种灵活性在处理复杂系统时尤为重要，因为它允许我们根据实际情况来调整系统的行为。

四、多态的注意事项

虽然多态带来了很多好处，但在使用时也需要注意一些问题：

1. 接口或父类设计要合理：接口或父类中的方法应该是那些所有子类或实现类都共有的行为。如果某个方法只适用于部分子类或实现类，那么它就不应该放在接口或父类中。

2. 避免过度使用继承：如前所述，过度使用继承会导致类之间的耦合度增加，不利于代码的维护和扩展。因此，在可能的情况下，推荐使用接口实现多态。

3. 注意类型转换：在使用多态时，有时我们需要将父类类型的引用转换回子类类型。这时，我们需要使用类型转换（强制类型转换或instanceof操作符）。但是，如果转换失败（即父类引用实际上并不指向子类对象），那么程序将会抛出ClassCastException。

五、结语

多态是面向对象编程中的一个重要概念，它允许我们以统一的方式处理不同类型的对象，并让这些对象在执行相同操作时展现出不同的行为。通过多态，我们可以编写更加灵活、可扩展的代码，减少代码冗余，提高代码复用率。然而，在使用多态时，我们也需要注意接口或父类的设计、避免过度使用继承、谨慎处理类型转换等问题。