字节跳动面试题： java多态的实现
- 作者简介：一名后端开发人员，每天分享后端开发以及人工智能相关技术，行业前沿信息，面试宝典。
- 座右铭：未来是不可确定的，慢慢来是最快的。
- 个人主页：极客李华-CSDN博客
- 合作方式：私聊+
- 这个专栏内容：BAT等大厂常见后端java开发面试题详细讲解，更新数目100道常见大厂java后端开发面试题。
- 我的CSDN社区：https://bbs.csdn.net/forums/99eb3042821a4432868bb5bfc4d513a8
- 微信公众号，抖音，b站等平台统一叫做：极客李华，加入微信公众号领取各种编程资料，加入抖音，b站学习面试技巧，职业规划
Java中的多态性是面向对象编程的重要概念之一，它允许以统一的方式处理不同类型的对象，提高了代码的灵活性和可维护性。本文将深入探讨Java中多态的实现方式、原理以及应用场景。
2. 多态的概念
多态（Polymorphism）是指在面向对象程序设计中，同一个方法调用会根据对象的不同而表现出不同的行为。简而言之，多态性是指一个接口可以有多种不同的实现方式，同一个方法名可以具有不同的行为。
3. 多态的实现方式
在Java中，多态性通过方法的重写（Override）和方法的重载（Overload）实现。重写是指子类重新定义父类中已有的方法，而重载是指在一个类中可以定义多个同名但参数列表不同的方法。
3.1 方法的重写（Override）
方法的重写是实现多态的一种重要方式，它允许子类重新定义父类中已有的方法，以满足子类的特定需求。在方法的重写中，子类必须保持方法名、参数列表和返回类型与父类中的方法一致，但可以重新定义方法的实现。
示例代码如下：
// 父类 Animal
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
// 子类 Dog，重写了父类 Animal 的 sound 方法
class Dog extends Animal {
@Override
void sound() {
System.out.println("Dog barks");
}
}
// 主类 Main，演示多态
public class Main {
public static void main(String[] args) {
Animal animal = new Dog(); // 使用父类引用指向子类对象
animal.sound(); // 调用的是子类 Dog 中重写的 sound 方法
}
}
- 运行结果
在这个示例中，我们定义了一个父类 Animal 和一个子类 Dog，子类 Dog 重写了父类 Animal 中的 sound 方法。在主类 Main 中，我们使用父类的引用指向了子类的对象，通过调用 sound 方法实现了多态。
3.2 方法的重载（Overload）
方法的重载是指在同一个类中可以定义多个同名但参数列表不同的方法，以提供不同的行为。Java编译器会根据方法调用的参数类型和数量来决定调用哪个重载方法。
示例代码如下：
class Calculator {
int add(int a, int b) {
return a + b;
}
double add(double a, double b) {
return a + b;
}
}
在这个示例中，我们定义了一个 Calculator 类，其中有两个重载的 add 方法，一个用于整数相加，另一个用于浮点数相加。在调用 add 方法时，编译器会根据参数类型选择合适的重载方法。
4. 多态的优点
多态性使得程序更加灵活和可扩展，具有以下几个优点：
- 代码复用： 可以通过重写和重载实现方法的复用，减少代码的冗余和重复。
- 可扩展性： 新的子类可以轻松扩展和修改现有的行为，不需要修改父类的代码。
- 代码可读性： 使用多态性能够使代码更加简洁、清晰，易于理解和维护。
- 代码案例
// 定义动物类
class Animal {
// 动物发出声音
void makeSound() {
System.out.println("动物发出声音");
}
}
// 定义狗类继承自动物类
class Dog extends Animal {
// 狗发出声音
void makeSound() {
System.out.println("狗发出汪汪的声音");
}
}
// 定义猫类继承自动物类
class Cat extends Animal {
// 猫发出声音
void makeSound() {
System.out.println("猫发出喵喵的声音");
}
}
// 定义主类
public class PolymorphismExample {
public static void main(String[] args) {
// 创建动物数组
Animal[] animals = new Animal[2];
animals[0] = new Dog(); // 将狗对象放入数组中
animals[1] = new Cat(); // 将猫对象放入数组中
// 循环遍历动物数组并发出声音
for (Animal animal : animals) {
animal.makeSound(); // 多态调用
}
}
}
- 运行结果
在这个运行结果中，看到了狗对象和猫对象分别发出了它们特定的声音。这个结果体现了多态的优点：
-
代码复用： 在动物类中定义了一个通用的 makeSound 方法，而狗类和猫类分别重写了这个方法来实现它们特定的声音。这样的设计避免了重复编写相似的代码，提高了代码的复用性。
-
可扩展性： 如果想要添加新的动物类，比如鸟类，只需要创建一个新的鸟类并重写 makeSound 方法即可，不需要修改原有的代码。这种设计使得系统更加灵活和可扩展。
-
代码可读性： 通过使用多态性，可以将代码写得更加简洁、清晰。在主程序中，不需要关心具体的动物类型是狗还是猫，只需要调用它们的 makeSound 方法即可。这样的设计使得代码更易于理解和维护。
Java多态的应用场景
多态的应用场景
在接口中应用多态
接口是Java中实现多态的重要方式之一。通过定义接口并在不同的类中实现该接口，可以实现对同一接口的不同行为，从而提高代码的灵活性和可扩展性。
// 定义接口
interface Shape {
double calculateArea();
}
// 实现接口的不同形状类
class Circle implements Shape {
double radius;
// 构造方法
public Circle(double radius) {
this.radius = radius;
}
@Override
public double calculateArea() {
return Math.PI * radius * radius;
}
}
class Rectangle implements Shape {
double length;
double width;
// 构造方法
public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}
@Override
public double calculateArea() {
return length * width;
}
}
// 主类
public class PolymorphismInterfaceExample {
public static void main(String[] args) {
// 创建圆形对象
Circle circle = new Circle(5);
// 创建矩形对象
Rectangle rectangle = new Rectangle(4, 6);
// 计算并输出圆形的面积
System.out.println("Shape: Circle");
System.out.println("Area: " + circle.calculateArea());
// 计算并输出矩形的面积
System.out.println("\nShape: Rectangle");
System.out.println("Area: " + rectangle.calculateArea());
}
}
- 运行结果
在这个运行结果中，看到了两个不同形状的面积计算结果：
- 对于圆形（Shape: Circle），其面积为 78.53981633974483。
- 对于矩形（Shape: Rectangle），其面积为 24.0。
这个结果体现了多态的优点，即在相同的方法调用 calculateArea() 下，根据具体对象的类型，调用了不同类中的不同实现方法。在代码中，定义了一个 Shape 接口，其中包含了 calculateArea() 方法的声明。然后，分别创建了 Circle 和 Rectangle 两个类来实现 Shape 接口，并在这两个类中分别重写了 calculateArea() 方法。在主程序中，通过统一的方式调用了这两个类的 calculateArea() 方法，但由于多态的特性，实际调用的是各自类中的实现方法，从而得到了不同形状的面积计算结果。这样的设计使得代码更加灵活，便于维护和扩展。
在设计模式中应用多态
多态性在设计模式中也有广泛的应用。例如，工厂模式（Factory Pattern）和策略模式（Strategy Pattern）等设计模式都是基于多态性实现的。
// 定义形状接口
interface Shape {
void draw();
}
// 定义圆形类实现形状接口
class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Circle");
}
}
// 定义矩形类实现形状接口
class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Rectangle");
}
}
// 定义工厂接口
interface ShapeFactory {
Shape createShape();
}
// 圆形工厂类，实现工厂接口
class CircleFactory implements ShapeFactory {
@Override
public Shape createShape() {
return new Circle();
}
}
// 矩形工厂类，实现工厂接口
class RectangleFactory implements ShapeFactory {
@Override
public Shape createShape() {
return new Rectangle();
}
}
// 主类
public class PolymorphismDesignPatternExample {
public static void main(String[] args) {
// 创建圆形工厂
ShapeFactory circleFactory = new CircleFactory();
// 使用圆形工厂创建圆形对象
Shape circle = circleFactory.createShape();
// 绘制圆形
circle.draw();
// 创建矩形工厂
ShapeFactory rectangleFactory = new RectangleFactory();
// 使用矩形工厂创建矩形对象
Shape rectangle = rectangleFactory.createShape();
// 绘制矩形
rectangle.draw();
}
}
在这个运行结果中，看到了两个不同形状的绘制结果：
首先，调用了圆形工厂创建了一个圆形对象，然后调用其 draw() 方法，结果是 “Drawing a Circle”，表示成功绘制了一个圆形。
然后，调用了矩形工厂创建了一个矩形对象，同样调用其 draw() 方法，结果是 “Drawing a Rectangle”，表示成功绘制了一个矩形。
这个运行结果体现了多态的特性，即通过统一的方法调用，在运行时根据实际对象的类型执行相应的实现。在这个例子中，通过工厂模式创建了不同的形状对象，并通过形状接口的 draw() 方法进行绘制，由于多态的作用，程序根据对象的实际类型调用了不同类中的 draw() 方法，从而实现了不同形状的绘制功能。
在方法参数中应用多态
多态性还可以通过方法参数的多态来实现。即使用父类或接口作为方法的参数类型，然后传入不同的子类对象，实现对不同类型对象的统一操作。
// 方法参数中应用多态
class ShapeCalculator {
double calculateArea(Shape shape) {
return shape.calculateArea();
}
// 主方法
public static void main(String[] args) {
// 创建一个形状计算器实例
ShapeCalculator calculator = new ShapeCalculator();
// 创建圆形对象并计算面积
Circle circle = new Circle(5); // 半径为5的圆形
double circleArea = calculator.calculateArea(circle);
System.out.println("Circle Area: " + circleArea);
// 创建矩形对象并计算面积
Rectangle rectangle = new Rectangle(4, 6); // 长为4，宽为6的矩形
double rectangleArea = calculator.calculateArea(rectangle);
System.out.println("Rectangle Area: " + rectangleArea);
}
}
// 形状接口
interface Shape {
double calculateArea();
}
// 圆形类实现形状接口
class Circle implements Shape {
private double radius;
// 构造方法
public Circle(double radius) {
this.radius = radius;
}
// 实现计算圆形面积的方法
public double calculateArea() {
return Math.PI * radius * radius;
}
}
// 矩形类实现形状接口
class Rectangle implements Shape {
private double length;
private double width;
// 构造方法
public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}
// 实现计算矩形面积的方法
public double calculateArea() {
return length * width;
}
}
这个运行结果表示计算出了圆形和矩形的面积，分别是 78.53981633974483 和 24.0。
Circle Area: 78.53981633974483: 这说明计算得到的圆形的面积是约为 78.54。Rectangle Area: 24.0: 这说明计算得到的矩形的面积是 24.0。
这个结果表明，通过多态性，可以使用相同的方法 calculateArea() 来计算不同形状的面积，无论是圆形还是矩形，都可以通过调用 calculateArea() 方法来计算其面积，从而实现了统一的面积计算操作。
扫一扫
7117
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
