Java中的多态（静态和动态）

Java 中的多态是什么？

Java 中的多态发生在当一个或多个类或对象通过继承相互关联时。它是对象采取多种形式的能力。继承允许用户继承属性和方法，而多态则利用这些方法执行不同的任务。因此，目标是沟通，但方法不同。这称为多态。

例如，您有一部用于沟通的智能手机。您可以选择任何沟通方式。它可以是电话、短信、图片消息、邮件等。因此，目标是相同的，即沟通，但它们的方法不同。这就是所谓的多态。现在，我们将通过示例学习 Java 中的多态。

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

Java OOPs 中的多态及示例

我们有一个父类“Account”，具有存款和取款功能。Account 有 2 个子类。对于储蓄账户和支票账户，存款和取款的操作是相同的。因此，来自 Account 类的继承方法将起作用。

软件需求变更

软件行业中非常常见的需求规格发生变化。您需要为具有透支功能的特权银行账户添加功能。作为背景，透支是一种设施，您可以在其中提取比您账户中可用余额更多的金额。因此，特权账户的取款方法需要全新实现。但是，您不会更改储蓄账户和支票账户中经过测试的代码。这是 OOPS 的优势。

步骤 1) 这样，当调用储蓄账户的“withdraw”方法时，将执行父账户类的相应方法。

步骤 2) 但是，当调用特权账户（透支功能）的“withdraw”方法时，将执行特权类中定义的 withdraw 方法。这就是OOPs 中的多态。

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
 }
}

什么是动态多态？

OOPs 中的动态多态是这样一种机制：父类和子类中可以定义具有相同名称和签名的方法。对重写方法的调用是在运行时解析的。

动态多态示例

父类引用变量可以引用子类对象

 Doctor obj = new Surgeon();

考虑语句

obj.treatPatient();

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

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

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

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

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

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 中的 Super 关键字

如果 Surgeon 类中的 treatPatient 方法想要执行 Doctor 类中定义的功能，然后执行其自身特定的功能怎么办？在这种情况下，可以使用 super 关键字从子类访问父类的方法。Surgeon 类中的 treatPatient 方法可以这样写：

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

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

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

示例：学习继承、多态和 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 关键字可用于从子类访问父类的方法。