在本指南中，您将学习 Java 中的面向对象编程 (OOP) 概念。面向对象编程系统 (OOP) 是基于“对象”的编程概念。面向对象编程的主要目的是提高程序的可读性、灵活性和可维护性。

面向对象编程将数据及其行为结合在一起，形成一个称为对象的单一实体。这使得编程更易于理解。我们将详细介绍 OOP 的所有特性，如继承、多态、抽象、封装，以确保您在理解 Java 中的 OOP 时不会遇到困难。

支持面向对象编程的流行编程语言有：Java、C++、Python、C#、Perl、JavaScript、Ruby、Smalltalk 等。

什么是 Java 中的 OOP 概念

OOP 概念包括以下面向对象编程的概念：

• 对象
• 类
• 抽象
• 封装
• 继承
• 多态

1. 对象

对象可以表示具有状态和行为的实体。例如：一辆车是一个对象，它具有状态，如颜色、型号、价格，和行为，如速度、启动、换挡、停车等。

让我们来理解状态和行为之间的区别。对象的状态是一个数据项，可以用值来表示，例如车的价格、颜色，可以将它们视为编程中的变量。行为类似于类中的方法，它是一组可以共同执行任务的动作。例如，换挡是一个行为，因为它涉及多个子任务，如速度控制、离合器、换挡手柄的移动。

让我们再看几个对象的例子：

状态和行为的示例

示例 1： 
类：房屋 
状态：地址、颜色、面积 
行为：开门、关门

我们来看一下如何在 Java 程序中编写这些状态和行为。状态可以用实例变量表示，行为可以用类的方法表示。

class House {
    String address;
    String color;
    double area;
    void openDoor() {
        // 编写代码
    }
    void closeDoor() {
        // 编写代码
    }
}

示例 2： 
类：汽车 
状态：颜色、品牌、重量、型号 
行为：刹车、加速、减速、换挡。

注意：正如我们在上述示例中所见，对象的状态和行为可以通过类中的变量和方法来表示。

2. 类

类可以被看作是一个可以用来创建多个对象的蓝图。例如，我们有一个类 Website，它有两个数据成员。这只是一个蓝图，它不代表任何网站，但使用它我们可以创建代表网站的 Website 对象。在创建对象时，我们使用构造函数为对象提供了独立的属性。

public class Website {
    // 字段 (或实例变量)
    String webName;
    int webAge;
    // 构造函数
    Website(String name, int age) {
        this.webName = name;
        this.webAge = age;
    }
    public static void main(String args[]) {
        // 创建对象
        Website obj1 = new Website("beginnersbook", 11);
        Website obj2 = new Website("google", 28);
        // 通过引用访问对象数据
        System.out.println(obj1.webName + " " + obj1.webAge);
        System.out.println(obj2.webName + " " + obj2.webAge);
    }
}

输出：

beginnersbook 11
google 28

3. 抽象

抽象是一个过程，您只展示“相关”数据，并向用户“隐藏”不必要的对象细节。例如，当您登录到您的银行账户时，您输入您的用户 ID 和密码并点击登录按钮，点击登录后会发生什么，输入数据如何发送到服务器，如何验证，所有这些细节都被抽象化了。点击此处了解更多：Java 中的抽象。

抽象类示例：

// 抽象类
abstract class Animal {
    // 抽象方法
    public abstract void animalSound();
}
public class Dog extends Animal {
    public void animalSound() {
        System.out.println("Woof");
    }
    public static void main(String args[]) {
        Animal obj = new Dog();
        obj.animalSound();
    }
}

输出：

Woof

4. 封装

封装简单来说就是将对象的状态（字段）和行为（方法）绑定在一起。如果您正在创建类，那么您就在进行封装。

示例

1. 将实例变量设为私有，以防止外部直接访问这些变量。您只能通过类的方法设置和获取这些变量的值。
2. 在类中使用 getter 和 setter 方法来设置和获取字段的值。

class EmployeeCount {
    private int numOfEmployees = 0;
    public void setNoOfEmployees(int count) {
        numOfEmployees = count;
    }
    public double getNoOfEmployees() {
        return numOfEmployees;
    }
}
public class EncapsulationExample {
    public static void main(String args[]) {
        EmployeeCount obj = new EmployeeCount();
        obj.setNoOfEmployees(5613);
        System.out.println("No Of Employees: " + (int) obj.getNoOfEmployees());
    }
}

输出：

No Of Employees: 5613

类 EncapsulationExample 使用了 EmployeeCount 类的对象，不能直接获取员工数量。它必须通过同一个类的 setter 和 getter 方法来设置和获取值。

封装在 Java 编程中有什么好处？

如果您想在某个时刻更改 EmployeeCount 类的实现细节，您可以自由进行更改，而不影响使用它的类。

5. 继承

一个类通过继承获取另一个类的属性和功能。继承提供了代码重用的概念，每个子类只定义它独有的特性，其余特性可以从父类继承。

继承是基于现有类定义新类的过程，通过扩展其公共数据成员和方法，继承允许我们重用代码，提高 Java 应用程序的重用性。

父类称为基类或超类。扩展基类的子类称为派生类或子类。

注意：继承的最大优势是基类中的代码无需在子类中重写。基类的变量和方法也可以在子类中使用。

Java 中继承的语法

要继承一个类，我们使用 extends 关键字。这里类 A 是子类，类 B 是父类。

class A extends B {
}

一般化与专门化：为了在 OOP 中实现继承的概念，首先需要识别不同类之间的相似性，以提出基类。

识别不同类之间的相似性称为一般化。一般化是从两个或多个类中提取共享特性，并将其组合成一个通用的超类。共享特性可以是属性或方法。

与一般化相反，专门化指的是从现有类创建新子类。如果某些属性或方法只适用于类的某些对象，则可以创建一个子类。

继承示例

class Teacher {
    String designation = "Teacher";
    String college = "Beginnersbook";
    void does() {
        System.out.println("Teaching");
    }
}
public class MathTeacher extends Teacher {
    String mainSubject = "Maths";
    public static void main(String args[]) {
        MathTeacher obj = new MathTeacher();
        System.out.println(obj.college);
        System.out.println(obj.designation);
        System.out.println(obj.mainSubject);
        obj.does();
    }
}

输出：

Beginnersbook
Teacher
Maths
Teaching

6. 多态

多态的字面意思是多种形态。它是指一个对象具有多种形态。例如，当父类引用指向子类对象时，多态发生了。

我们来看一个多态的示例：

class Animal {
    public void animalSound() {
        System.out.println("Default Sound");
    }
}
public class Dog extends Animal {
    public void animalSound() {
        System.out.println("Woof");
    }
    public static void main(String args[]) {
        Animal obj = new Dog();
        obj.animalSound();
    }
}

输出：

Woof

上面的示例说明了多态。尽管 obj 是 Animal 类型，但由于它引用了 Dog 对象，所以会调用 Dog 类的 animalSound 方法。

小结

Java 中的 OOP 概念（继承、封装、多态、抽象、对象和类）通过分离对象和它们的行为使编程更加结构化和易于管理。通过本指南，您现在应该对 Java 中的 OOP 特性有了深刻的理解。

若你想提升Java技能，可关注我们的Java培训课程。