Java 多态
- Java多态性的核心概念:Java中的多态性意味着一个实体(如方法或对象)在不同情况下可以表现出不同的行为。
- 实现多态的方式:Java中的多态可以通过方法重写、方法重载和操作符重载来实现。特别是在继承中,子类重写的方法可以根据对象类型表现不同的行为。
- 多态性的实际应用:多态允许创建更一致和灵活的代码。例如,使用同一个
render()
方法来渲染不同类型的图形,其行为会根据对象类型(如正方形或圆形)而改变。
以下图解展示了Java中多态性的一个实例:Polygon
类作为超类,具有 render()
方法,而 Square
和 Circle
作为子类,重写了 render()
方法以实现特定于正方形和圆形的渲染过程。
多态性是面向对象编程的一个重要概念。它简单地意味着一个实体(方法、操作符或对象)在不同场景下可以执行不同的操作。
示例:Java 多态性
class Polygon {
// 方法来渲染形状
public void render() {
System.out.println("渲染多边形...");
}
}
class Square extends Polygon {
// 渲染正方形
public void render() {
System.out.println("渲染正方形...");
}
}
class Circle extends Polygon {
// 渲染圆形
public void render() {
System.out.println("渲染圆形...");
}
}
class Main {
public static void main(String[] args) {
// 创建一个 Square 对象
Square s1 = new Square();
s1.render();
// 创建一个 Circle 对象
Circle c1 = new Circle();
c1.render();
}
}
输出
渲染正方形...
渲染圆形...
在上面的例子中,我们创建了一个超类:Polygon
和两个子类:Square
和 Circle
。注意 render()
方法的使用。
render()
方法的主要目的是渲染形状。然而,渲染正方形的过程与渲染圆形的过程不同。
因此,render()
方法在不同的类中表现不同。或者,我们可以说 render()
是多态的。
为什么要使用多态?
多态允许我们创建一致的代码。在前面的例子中,我们也可以创建不同的方法:renderSquare()
和 renderCircle()
分别用来渲染 Square
和 Circle
。
这将完美工作。然而,对于每个形状,我们需要创建不同的方法。这将使我们的代码不一致。
为了解决这个问题,Java 中的多态性允许我们创建一个单一的方法 render()
,它将对不同的形状有不同的行为。
注意:print()
方法也是多态性的一个例子。它用于打印不同类型的值,如 char
、int
、string
等。
我们可以通过以下方式实现 Java 中的多态性:
Java 方法重写
在 Java 继承 中,如果超类和子类中都存在相同的方法。那么,子类中的方法将覆盖超类中的同名方法。这被称为方法重写。
在这种情况下,同一个方法在超类中执行一种操作,在子类中执行另一种操作。例如,
示例 1:使用方法重写实现多态
class Language {
public void displayInfo() {
System.out.println("通用英 语语言");
}
}
class Java extends Language {
@Override
public void displayInfo() {
System.out.println("Java 编程语言");
}
}
class Main {
public static void main(String[] args) {
// 创建一个 Java 类的对象
Java j1 = new Java();
j1.displayInfo();
// 创建一个 Language 类的对象
Language l1 = new Language();
l1.displayInfo();
}
}
输出:
Java 编程语言
普通英语
在上面的例子中,我 们创建了一个名为 Language
的超类和一个名为 Java
的子类。这里,方法 displayInfo()
在 Language
和 Java
中都存在。
displayInfo()
的用途是打印信息。然而,它在 Language
和 Java
中打印的信息不同。
根据调用方法的对象,打印相应的信息。
注意:调用的方法是在程序执行过程中确定的。因此,方法重写是运行时多态。
2. Java 方法重载
在 Java 类中,我们可以创建具有相同名称但参数不同的方法。例如,
void func() { ... }
void func(int a) { ... }
float func(double a) { ... }
float func(int a, float b) { ... }
这被称为 Java 中的方法重载。这里,相同的方法会根据参数执行不同的操作。
示例 3:使用方法重载实现多态
class Pattern {
// 无参数的方法
public void display() {
for (int i = 0; i < 10; i++) {
System.out.print("*");
}
}
// 带单个参数的方法
public void display(char symbol) {
for (int i = 0; i < 10; i++) {
System.out.print(symbol);
}
}
}
class Main {
public static void main(String[] args) {
Pattern d1 = new Pattern();
// 调用无任何参数的方法
d1.display();
System.out.println("\n");
// 调用带单个参数的方法
d1.display('#');
}
}
输出:
**********
##########
在上面的例子中,我们创建了一个名为 Pattern
的类。该类包含一个名为 display()
的重载方法。
// 无参数的方法
display() {...}
// 带单个 char 类型参数的方法
display(char symbol) {...}
这里,display()
的主要功能是打印图案。然而,根据传递的参数,该方法执行不同的操作:
- 如果没有传递参数,就打印
*
的图案, - 如果传递了单个
char
类型参数,就打印该参数的图案。
注意:调用的方法是由编译器确定的。因此,它也被称为编译时多态。
3. Java 运算符重载
Java 中的一些运算符对不同的操作数表现出不同的行为。例如,
+
运算符被重载以执行数字加法以及字符串连接,- 运算符如
&
、|
和!
被重载用于逻辑和位操作。
让我们看看如何使用运算符重载实现多态。
+
运算符用于添加两个实体。然而,在 Java 中,+
运算符执行两个操作。
- 当
+
用于数字(整数和浮点数)时,它执行数学加法。例如,
int a = 5;
int b = 6;
// 数字相加
int sum = a + b; // 输出 = 11
- 当我们使用
+
运算符与字符串时,它将执行字符串连接(连接两个字符串)。例如,
String first = "Java ";
String second = "Programming";
// 字符串相加
name = first + second; // 输出 = Java Programming
这里,我们可以看到 +
运算符在 Java 中被重载以执行两个操作:加法和连接。
注意:在诸如 C++ 这样的语言中,我们可以定义运算符对不同
的操作数执行不同的操作。然而,Java 不支持用户定义的运算符重载。
多态变量
如果一个变量在不同条件下引用不同的值,就称为多态变量。
对象变量(实例变量)代表了 Java 中多态变量的行为。这是因为一个类的对象变量可以引用其类的对象以及其子类的对象。
示例:多态变量
class ProgrammingLanguage {
public void display() {
System.out.println("I am Programming Language.");
}
}
class Java extends ProgrammingLanguage {
@Override
public void display() {
System.out.println("I am Object-Oriented Programming Language.");
}
}
class Main {
public static void main(String[] args) {
// 声明一个对象变量
ProgrammingLanguage pl;
// 创建 ProgrammingLanguage 的对象
pl = new ProgrammingLanguage();
pl.display();
// 创建 Java 类的对象
pl = new Java();
pl.display();
}
}
输出:
I am Programming Language.
I am Object-Oriented Programming Language.
在上述示例中,我们创建了一个名为 ProgrammingLanguage
类的对象变量 pl
。这里,pl
是一个多态变量。这是因为,
- 在语句
pl = new ProgrammingLanguage()
中,pl
指向ProgrammingLanguage
类的对象。 - 而在语句
pl = new Java()
中,pl
指向Java
类的对象。