Java OOP 中的多态性示例：什么是动态的

什么是 Java 中的多态性？

多态性 在 Java 中，当有一个或多个类或对象通过继承相互关联时，就会发生这种情况。它是物体采取多种形式的能力。继承让用户继承属性和方法，多态使用这些方法来执行不同的任务。所以，目标是沟通，但方法不同。

例如，您有一部用于通信的智能手机。您选择的通信模式可以是任何东西。可以是电话、短信、图片信息、邮件等。所以，共同的目标是沟通，但他们的方法不同。这称为多态性。 现在，我们将通过示例学习Java中的多态性。

在本 Java 教程中，您将学习-

• 什么是 Java 中的多态性？
• OOP 中的 Java 多态性示例
• Java 中的方法覆盖
• 重载和覆盖的区别
• 什么是动态多态性？
• 静态和动态多态的区别
• Java 中的超级关键字

如果视频无法访问，请单击此处

OOP 中的 Java 多态与示例

我们有一个父类，具有存款和取款功能的“账户”。帐号有 2 个子类

储蓄账户和支票账户的存款和取款操作相同。因此，从 Account 类继承的方法将起作用。

<中心>

Java 多态示例

软件需求变化

需求规范发生了变化，这在软件行业中很常见。您应该添加具有透支功能的特权银行帐户。

就背景而言，透支是一种工具，您可以在其中提取超过您帐户中可用余额的金额。

因此，需要重新实现特权的撤销方法。但是您不会更改 Savings and Checking 帐户中的测试代码。这是OOPS的优势

步骤 1) 这样当调用储蓄账户的“提现”方法时，就会执行父账户类的方法

步骤 2) 但是，当特权帐户（透支设施）的“提款”方法被调用时，特权类中定义的提款方法被执行。这就是 OOP 中的多态性。

Java 中的方法覆盖

方法覆盖就是在子类中重新定义超类方法。

方法覆盖的规则

• 方法签名，即方法名称、参数列表和返回类型必须完全匹配。
• 重写的方法可以扩大可访问性，但不能缩小范围，即如果它在基类中是私有的，则子类可以将其设为公共，但反之则不行。

示例

class Doctor{
  public void treatPatient(){
  // treatPatient method
  
}
class Surgeon extends Doctor{
  public void treatPatient(){
  // treatPatient method
  }
}
Class run{
  public static void main (String args[]){
    Doctor doctorObj = new Doctor()
	// treatPatient method in class Doctor will be executed
    doctorObj.treatPatient();
   
    Surgeon surgeonObj = new Surgeon();
    // treatPatient  method in class Surgeon  will be executed
    surgeonObj.treatPatient();
  }
}

重载和覆盖的区别

void sum (int a , int b);
void sum (int a , int b, int c);
void sum (float a, double b);

class X{
  public int sum(){
     // some code
  }
}

class Y extends X{
  public int sum(){
    //overridden method
   //signature is same
 }
}

什么是动态多态性？

OOP 中的动态多态性是一种机制，通过该机制可以在超类和子类中定义具有相同名称和签名的多个方法。对覆盖方法的调用在运行时解析。

动态多态示例：

超类的引用变量可以引用子类对象

 Doctor obj = new Surgeon();

考虑一下声明

obj.treatPatient();

这里引用变量“obj”是父类的，但它指向的对象是子类的（如下图多态示例）。

obj.treatPatient() 将执行子类-Surgeon 的treatPatient() 方法

如果使用基类引用来调用方法，则调用的方法由JVM决定，具体取决于引用所指向的对象

例如，即使 obj 是对 Doctor 的引用，它也会调用 Surgeon 的方法，因为它指向一个 Surgeon 对象

这是在运行时决定的，因此称为动态 或运行时多态

静态和动态多态的区别

Java中的静态多态是一种在编译时收集用于调用方法的信息的多态，而动态多态是一种在运行时收集用于调用方法的信息的多态。

void sum (int a , int b);
void sum (float a, double b);
int sum (int a, int b); //compiler gives error.

//reference of parent pointing to child object
 Doctor obj = new Surgeon();
// method of child called
obj.treatPatient();

Java 中的超级关键字

如果 Surgeon 类中的 TreatPatient 方法想要执行 Doctor 类中定义的功能，然后执行自己的特定功能怎么办？

在这种情况下，关键字 super 可用于从子类访问父类的方法。

Surgeon 类中的 TreatPatient 方法可以写成：

treatPatient(){
   super.treatPatient();
     //add code specific to Surgeon
}

关键字 super 可用于访问子类中任何超类的数据成员或方法。

接下来，我们将通过示例程序了解Java中的Super关键字、继承和多态。

示例：-学习继承、多态和超级关键字

步骤 1) 将以下代码复制到编辑器中

public class Test{
     public static void main(String args[]){
        X x= new X();
       Y y = new  Y();
       y.m2();
      //x.m1();
      //y.m1();
     //x = y;// parent pointing to object of child
     //x.m1() ;
     //y.a=10;
   }

}
class X{
   private int a;
   int b;
      public void m1(){
       System.out.println("This is method m1 of class X");
     }
}

class Y extends X{
      int c; // new instance variable of class Y
         public void m1(){
            // overriden method
            System.out.println("This is method m1 of class Y");
        }
       public void m2(){
           super.m1();
           System.out.println("This is method m2 of class Y");
      }
}

步骤 2) 保存、编译和运行代码。观察输出。

步骤 3) 取消注释 # 6-9 行。保存、编译和运行代码。观察输出。

第 4 步） 取消注释 # 10 行。保存并编译代码。

第 5 步） 错误 =?这是因为子类不能访问超类的私有成员。

总结

• 当有一个或多个类或对象通过继承相互关联时，就会出现面向对象编程中的多态性。它是物体具有多种形式的能力。
• 方法覆盖是在子类中重新定义超类方法。
• Java 中的动态多态性是一种机制，通过该机制可以在超类和子类中定义具有相同名称和签名的多个方法。
• Java 中的静态多态是一种在编译时收集用于调用方法的信息的多态，而动态多态是一种在运行时收集用于调用方法的信息的多态。
• super 关键字可用于从子类访问父类的方法。