掌握 Java 中的面向对象编程：了解 OOP 的基础知识

2023-02-28

this 对象 oop

面向对象编程(OOP)是一种基于对象概念的编程范式。对象同时包含数据和行为，使开发人员可以轻松地以易于理解和维护的方式对现实世界的实体进行建模。在本文中，我们将深入探讨Java中的OOP，探索使其成为强大且广泛使用的编程语言的基本概念和原则。OOP中的第一个关键概念是封装，它指的是将数据和行为隐藏在

面向对象编程 (OOP) 是一种基于对象概念的编程范式。对象同时包含数据和行为，使开发人员可以轻松地以易于理解和维护的方式对现实世界的实体进行建模。在本文中，我们将深入探讨 Java 中的 OOP，探索使其成为强大且广泛使用的编程语言的基本概念和原则。

OOP 中的第一个关键概念是封装，它指的是将数据和行为隐藏在一个对象中的想法。封装允许对象控制其数据的访问和修改方式，这有助于确保数据保持一致和安全。为了说明这个概念，让我们考虑以下 Java 银行帐户示例：

public class BankAccount {
  private double balance;
  private String accountNumber;
  
  public BankAccount(double balance, String accountNumber) {
    this.balance = balance;
    this.accountNumber = accountNumber;
  }
  
  public double getBalance() {
    return balance;
  }
  
  public void setBalance(double balance) {
    this.balance = balance;
  }
  
  public String getAccountNumber() {
    return accountNumber;
  }
  
  public void setAccountNumber(String accountNumber) {
    this.accountNumber = accountNumber;
  }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.

在这个例子中，我们创建了一个名为 BankAccount 的类，它封装了与银行账户相关的数据和行为。数据（余额和帐号）存储在私有变量中，我们提供了访问和修改该数据的公共方法。这使我们能够确保数据保持一致和安全，因为外部对象无法直接访问或修改 BankAccount 对象内的数据。

OOP 中的第二个关键概念是继承，它允许我们创建继承现有类的属性和行为的新类。这使得重用代码和构建现有功能变得容易，同时还可以创建更专业的类来继承更通用类的行为。为了说明这个概念，让我们考虑以下 Java 支票帐户示例：

public class CheckingAccount extends BankAccount {
  private double overdraftLimit;
  
  public CheckingAccount(double balance, String accountNumber, double overdraftLimit) {
    super(balance, accountNumber);
    this.overdraftLimit = overdraftLimit;
  }
  
  public double getOverdraftLimit() {
    return overdraftLimit;
  }
  
  public void setOverdraftLimit(double overdraftLimit) {
    this.overdraftLimit = overdraftLimit;
  }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

在此示例中，我们创建了一个名为 CheckingAccount 的新类，它继承自 BankAccount 类。这意味着 CheckingAccount 类具有 BankAccount 类的所有属性和行为，以及我们定义的任何其他属性和行为。在本例中，我们向 CheckingAccount 类添加了一个透支限制属性，该属性特定于支票账户。

OOP 中的第三个关键概念是多态性，它允许将不同类的对象视为通用类型的对象。这使得编写能够处理不同类型对象的通用代码成为可能，并且使代码更易于管理和维护。为了说明这个概念，让我们考虑以下示例：

public interface Shape {
  double getArea();
}

public class Circle implements Shape {
  private double radius;
  
  public Circle(double radius) {
    this.radius = radius;
  }
  
  public double getRadius() {
    return radius;
  }
  
  public void setRadius(double radius) {
    this.radius = radius;
  }
  
  @Override
  public double getArea() {
    return Math.PI * radius * radius;
  }
}

public class Rectangle implements Shape {
  private double width;
  private double height;
  
  public Rectangle(double width, double height) {
    this.width = width;
    this.height = height;
  }
  
  public double getWidth() {
    return width;
  }
  
  public void setWidth(double width) {
    this.width = width;
  }
  
  public double getHeight() {
    return height;
  }
  
  public void setHeight(double height) {
    this.height = height;
  }
  
  @Override
  public double getArea() {
    return width * height;
  }
}

public class ShapeCalculator {
  public double calculateTotalArea(Shape[] shapes) {
    double totalArea = 0;
    for (Shape shape : shapes) {
      totalArea += shape.getArea();
    }
    return totalArea;
  }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.

在这个例子中，我们创建了一个名为 Shape 的接口，它定义了一个计算形状面积的方法。然后我们有两个类，Circle 和 Rectangle，它们实现了 Shape 接口。这意味着它们都被视为 Shape 类型的对象，即使它们是具有不同属性和行为的不同类。

最后，我们创建了一个名为 ShapeCalculator 的类，它可以计算 Shape 对象数组的总面积。因为所有 Shape 对象都有一个通用的 getArea() 方法，所以 ShapeCalculator 类可以使用这个方法来计算 Circle 和 Rectangle 对象的任意组合的总面积。

总之，OOP 是一种强大的编程范例，它允许开发人员以易于理解和维护的方式对现实世界的实体进行建模。通过掌握封装、继承和多态性的概念，Java 开发人员可以编写更健壮、可伸缩和可维护的代码。无论您是经验丰富的 Java 开发人员还是刚刚起步，了解 OOP 的基础知识都是成为成功程序员的重要一步。