了解Java中的多态性和两种类型:编译时和运行时。另外,我们看看如何实现静态和动态绑定的演示。
多态是一个面向对象的编程概念。无论您是Java编程新手,还是使用Java多年的人,您都应该知道Java中的多态性是什么,以及它是如何工作的。大多数开发人员声称他们非常了解这个主题,但是当涉及到静态和动态绑定等其他复杂特性时,他们似乎不够自信。对多态性的良好理解允许我们构建高效的面向对象程序。
Java中的多态性是什么?
多态性由两个词组成:
- Poly:意思是“很多”
- 态射:意为“形式”
因此,多态性意味着有许多形式。在编程世界里,它被定义为一个信号或信息以多种形式显示的能力.
现实生活中的例子
一个人可以同时表现出许多特征。例如,母亲同时可以是妻子、女儿、姐妹、公司员工等。因此,一个人在不同的条件下会表现出不同的特征。这就是所谓的多态性。
多态性的重要性
多态性是任何面向对象编程语言(例如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中实现方法覆盖的方式。
摘要
在本文中,我们学习了Java中的多态性。然后我们深入主题,讨论了Java中两种类型的多态性:编译时多态性和运行时多态性。我们通过程序演示了如何用Java实现静态和动态绑定。
最后
感谢阅读,这里有更多的java课程学习路线,笔记,面试等架构资料