Java中的多态和动态绑定

了解Java中的多态性和两种类型:编译时和运行时。另外，我们看看如何实现静态和动态绑定的演示。

多态是一个面向对象的编程概念。无论您是Java编程新手，还是使用Java多年的人，您都应该知道Java中的多态性是什么，以及它是如何工作的。大多数开发人员声称他们非常了解这个主题，但是当涉及到静态和动态绑定等其他复杂特性时，他们似乎不够自信。对多态性的良好理解允许我们构建高效的面向对象程序。

Java中的多态性是什么？

多态性由两个词组成:

Poly:意思是“很多”
态射:意为“形式”

因此，多态性意味着有许多形式。在编程世界里，它被定义为一个信号或信息以多种形式显示的能力.

现实生活中的例子

一个人可以同时表现出许多特征。例如，母亲同时可以是妻子、女儿、姐妹、公司员工等。因此，一个人在不同的条件下会表现出不同的特征。这就是所谓的多态性。

这里有更多的java课程学习路线,笔记,面试等架构资料

多态性的重要性

多态性是任何面向对象编程语言(例如Java)最重要的特征之一，在多态性的帮助下，一个单一的任务可以用不同的方式执行。

多态性的类型

在Java中，多态性大致分为两类:

编译时多态性(静态绑定)
运行时多态性(动态绑定)

编译时多态性

编译时多态性也称为静态绑定。这种类型的多态性可以通过函数重载或运算符重载来实现。但在Java中，它仅限于函数重载，因为Java不支持实现运算符重载。

函数重载

当至少有两个函数或方法具有相同的函数名，但它们包含的参数数量不同，或者至少有一个相应参数的数据类型不同(或者两者都不同)时，这就称为函数或方法重载，这些函数称为重载函数。

示例1

到目前为止，我们已经研究了什么是函数重载。现在让我们尝试以编程方式演示函数重载

class Main {
 
    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {
 
        // Returns sum of integer numbers
        return a + b;
    }
    // Method 2
    // having the same name but with 2 double parameters
    static double Addition(double a, double b)
    {
        // Returns sum of double numbers
        return a + b;
    }
    public static void main(String args[]) {
        
        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(12, 14));
        System.out.println(Addition(15.2, 16.1));
 
    }
}
复制代码

程序说明:

上面的程序由两个同名的静态函数组成:加法。
这里，两个函数包含相同数量的参数，但是它们对应的参数不同。
Method 1接受两个整数参数，而Method 2接受双数据类型的两个参数。
从主函数中，我们调用Addition(12, 14)功能第一。传递的参数是整数(12和14)，因此Method 1会被叫到这里。
然后我们调用了Addition(15.2, 16.1)功能。由于传递的参数是双数据类型(15.2和16.1)，Method 2这次会被称为。
这就是函数重载在Java中是如何根据参数的不同数据类型来实现的。

示例2

考虑下面给出的程序:

class Main {
 
    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {
 
        // Returns sum of integer numbers
        return a + b;
    }
 
    // Method 2
    // having the same name but with 3 integer parameters
    static double Addition(double a, double b)
    {
 
        // Returns sum of integer numbers
        return a + b;
    }
    public static void main(String args[]) {
        
        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(12, 14));
        System.out.println(Addition(15.2, 16.1));
 
    }
}
复制代码

程序说明:

上面的程序由两个同名的静态函数组成:加法。
这里，两个函数包含不同数量的参数，但是前两个对应参数的数据类型是相同的(整数)。
Method 1接受两个整数参数和Method 2接受三个整数数据类型的参数。
从主函数中，我们调用Addition(2, 3)功能第一。因为传递的参数是整数(2和3)，Method 1会被叫到这里。
然后我们调用了Addition(4, 5, 6)功能。传递的参数是双精度数据类型(4，5，6)，所以Method 2这次会被称为。
这就是函数重载在Java中是如何基于不同数量的参数实现的。

class Main {
 
    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {
        // Return the sum
        return a + b;
    }
    // Method 2
    // having the same name but with 3 parameters
    // 1st parameter is of type double and other parameters
    // are of type integer
    static double Addition(double a, int b,  int c)
    {
        // Return the sum
        return a + b + c;
    }
    public static void main(String args[]) {
        
        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(2, 4));
        System.out.println(Addition(4.2, 6, 10));
 
    }
}
复制代码

程序说明:

上面的程序由两个同名的静态函数组成:加法。
两个函数包含不同数量的参数，第一个对应元素的数据类型也不同。
Method 1接受两个整数参数，而Method 2接受三个参数—第一个是双精度类型，另外两个是整数数据类型。
从主函数中，我们调用Addition(2, 4)功能第一。因为传递的参数是整数(2和4)，Method 1会被叫到这里。
然后我们调用了Addition(4.2, 6, 10)功能。传递的第一个参数是整数类型，其他参数是双精度数据类型(4.2，6，10)，因此，Method 2这次会被称为。
这就是函数重载是如何在Java中基于不同数量的参数以及相应参数的不同数据类型来实现的。

注意: 不能仅基于函数的返回类型重载函数。

运行时多态性

这也称为动态绑定。在这个过程中，对函数的函数调用只在运行时被解析。我们可以通过方法覆盖在Java中实现动态绑定。

方法覆盖

当基类中的方法在派生类中有定义时，Java中的方法重写就会发生。基类中的方法或函数称为重写方法。

// Class 1
class Parent {
 
    // Print method
    void Print()
    {
 
        // Print statement
        System.out.println("Inside Parent Class");
    }
}
 
// Class 2
class Child1 extends Parent {
 
    // Print method
    void Print() { System.out.println("Inside Child1 Class"); }
}
 
// Class 3
class Child2 extends Parent {
 
    // Print method
    void Print()
    {
        // Print statement
        System.out.println("Inside Child2 Class");
    }
}
 
class Main {
 
    public static void main(String args[]) {
        
        // Creating an object of class Parent
        Parent parent = new Parent();
        parent.Print();
 
        // Calling print methods
        parent = new Child1();
        parent.Print();
 
        parent = new Child2();
        parent.Print();
    }
}
复制代码

程序说明:

上面的程序由三个类组成:Parent(类1)、Child1(类2)和Child2(类3)。class 2和class 3继承class 1.
这Parent有一个名为Print()。在这个函数中，我们正在打印"Inside Parent Class". Child1和Child2也有Print()基本上重写Print()的功能class Parent并且会打印"Inside Child1 Class"和"Inside Child2 Class"分别到控制台。
从main函数中，我们首先创建一个父类的对象，称为parent。然后，在这个对象的帮助下，我们调用父类的print方法。因此，"Inside Parent Class"会印在控制台上。
之后，我们调用了Child1类，我们调用Print()功能。注意，现在Print()方法下定义的Child1类将被调用，因为我们已经重写了Print()父类的方法。因此，"Inside Child1 Class"会印在控制台上。
最后，我们调用了Child2类，我们调用Print()功能。在这里Print()方法下定义的Child2类将被调用，因为我们已经重写了Print()父类的方法。因此，“Inside Child2 Class”会印在控制台上。
这就是在Java中实现方法覆盖的方式。