Java 中的 OOPs 概念

2025年7月7日 | 阅读10分钟

面向对象编程（Object-oriented programming）是一种提供诸如继承、数据绑定、多态等概念的范式。

Simula 被认为是第一个面向对象的编程语言。万物皆对象（everything is represented as an object）的编程范式被称为纯面向对象编程语言。

Smalltalk 被认为是第一个真正意义上的面向对象编程语言。

流行的面向对象语言有 Java、 C#、 PHP、 Python、 C++ 等。

OOPs（面向对象编程）

面向对象编程旨在实现现实世界的实体，例如对象、类、抽象、继承、多态等。

对象意味着一个现实世界的实体，例如笔、椅子、桌子、电脑、手表等。面向对象编程 是一种使用类和对象来设计程序的思想或范式。它通过提供一些概念来简化软件开发和维护。

除了这些概念之外，在面向对象设计中还有一些其他术语被使用。

耦合
内聚
关联 (Association)
聚合 (Aggregation)
组合 (Composition)

Object

任何具有状态和行为的实体都称为对象。例如，椅子、笔、桌子、键盘、自行车等。它可以是物理的或逻辑的。

对象可以被定义为一个类的实例。它包含一个地址，并在内存中占用一定的空间。对象可以在不了解彼此数据或代码细节的情况下进行通信。唯一必要的是对象接受的消息类型和对象返回的响应类型。

阅读更多请访问 Java中的对象

示例：一只狗是一个对象，因为它有颜色、名字、品种等状态，以及摇尾巴、吠叫、吃饭等行为。

对象的主要元素是

状态（State）：它体现于对象的属性。此外，它反映了对象的属性。
行为（Behavior）：对象的行为是它的方法。此外，它表示对象如何响应其他对象。
标识（Identity）：标识是一个特殊的名称，它赋予一个事物与其他对象通信的能力。
方法（Method）：方法是一组执行特定操作并给出结果的语句。方法可以在不返回任何结果的情况下完成特定任务。方法被认为是节省时间的，因为它们使我们能够在不重新输入代码的情况下重用代码。Java与C、C++和Python等语言不同，因为每个方法都必须是类的一部分。

对象示例

示例

class Dog {
    String name;
    void bark() {
        System.out.println(name + " says Woof!");
    }
}
public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();     // Creating an object
        myDog.name = "Rocky";      // Assigning value to the object's field
        myDog.bark();              // Calling method on the object
    }
}

编译并运行

输出

Rocky says Woof!

类是逻辑实体。类也可以被定义为我们从中创建单个对象的蓝图。类不占用任何空间。

通常，类声明按出现顺序包含以下内容：

修饰符（Modifiers）： 类可以是公共的，也可以是默认访问权限。
class 关键字： 使用 class 关键字创建类。
类名（Class name）： 名称必须以首字母开头（约定俗成大写）。
超类（Superclass）（如果存在）： 如果类有父类（超类），则为父类的名称，前面加上 extends 关键字。一个类只能扩展（子类化）一个父类。
接口（Interfaces）（如果存在）： 如果类实现了接口，则为实现的接口的逗号分隔列表，前面加上 implements 关键字。一个类可以实现多个接口。
体（Body）： 由花括号 {} 包围的类体。

阅读更多请访问 Java中的类定义

继承

当一个对象获取了父对象的所有属性和行为时，称为继承。它提供了代码重用性。它用于实现运行时多态。

要阅读更多内容，请访问 Java 继承

继承示例

示例

// Superclass (Parent)
class Vehicle {
    void start() {
        System.out.println("Vehicle is starting...");
    }
    void stop() {
        System.out.println("Vehicle is stopping...");
    }
}
// Subclass (Child) - Inherits from Vehicle
class Car extends Vehicle {
    void honk() {
        System.out.println("Car is honking!");
    }
}
public class MainExample {
    public static void main(String[] args) {
        Car myCar = new Car();
        // Calling inherited methods (from Vehicle)
        myCar.start();
        myCar.stop();
        // Calling child class method
        myCar.honk();
    }
}

编译并运行

输出

Vehicle is starting...
Vehicle is stopping...
Car is honking!

多态

如果一项任务以不同的方式执行，则称为多态。例如，为了以不同的方式说服客户，绘制某些东西，例如形状、三角形、矩形等。

阅读更多请访问 Java中的多态

在Java中，我们使用方法重载和方法重写来实现多态。

另一个例子是说话；例如，猫发出“喵”声，狗发出“汪汪”声等。

多态示例

示例

class Animal {
    // Method Overloading (compile-time polymorphism)
    void sound() {
        System.out.println("An animal makes a sound");
    }
    void sound(String type) {
        System.out.println("Animal sound: " + type);
    }
}
class Dog extends Animal {
    // Method Overriding (runtime polymorphism)
    @Override
    void sound(String type) {
        System.out.println("Dog barking is: " + type);
    }
}
public class Main {
    public static void main(String[] args) {
        Animal a = new Animal();
        Dog d = new Dog();
        Animal poly = new Dog(); 
        // Method Overloading
        a.sound();
        a.sound("Generic");
        // Method Overriding
        d.sound("Loud");
        // Performing the Polymorphism 
        poly.sound("Soft");
    }
}

编译并运行

输出

An animal makes a sound
Animal sound: Generic
Dog barking is: Loud
Dog barking is: Soft

抽象

隐藏内部实现并仅向用户显示功能称为抽象。例如，在电话通话中，我们不知道内部处理。在Java中，我们使用抽象类和接口来实现抽象。

阅读更多请访问 Java中的抽象

抽象示例

示例

abstract class Animal {
    abstract void makeSound();
    // Creating a Concrete method 
    void breathe() {
        System.out.println("Animal is breathing...");
    }
}
// Concrete subclass
class Dog extends Animal {
    // implementation for an abstract method
    @Override
    void makeSound() {
        System.out.println("Dog barking");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.breathe();
        myDog.makeSound();
    }
}

编译并运行

输出

Animal is breathing...
Dog barking

封装

将代码和数据绑定（或包装）到单个单元中称为封装。例如，胶囊用不同的药物包装。

Java类是封装的一个例子。Java Bean是一个完全封装的类，因为所有数据成员都是私有的。

阅读更多请访问 Java中的封装

抽象示例

示例

class Student {
    // Private data members
    private String name;
    // Setter method
    public void setName(String name) {
        this.name = name;
    }
    // Getter method
    public String getName() {
        return name;
    }
}
public class Main {
    public static void main(String[] args) {
        Student s = new Student();
        // Setting value using setter
        s.setName("John");
        // Getting value using getter
        System.out.println("Student Name: " + s.getName());
    }
}

编译并运行

输出

Student Name: John

耦合

耦合（Coupling）是指一个类对另一个类的了解、信息或依赖。当类相互感知时，就会发生耦合。如果一个类对另一个类有信息，则存在强耦合。在Java中，我们使用 private、protected 和 public 修饰符来显示类、方法和字段的可见性级别。我们可以使用接口来实现弱耦合，因为没有具体的实现。

阅读更多请访问 Java中的松耦合

内聚

内聚（Cohesion）是指执行单一明确任务的组件的级别。单一明确的任务由高度内聚的方法完成。弱内聚的方法会将任务分成几个部分。java.io 包具有高度内聚性，因为它包含与 I/O 相关的类和接口。然而，java.util 包是一个内聚性较弱的包，因为它包含不相关的类和接口。

阅读更多请访问 Java中的内聚

关联 (Association)

关联（Association）表示对象之间的关系。在这里，一个对象可以与一个对象或多个对象相关联。对象之间可以有四种类型的关联：

一对一
一对多
多对一
多对多

例如，一个国家可以有一位总理（一对一），一位总理可以有多位部长（一对多）。同样，许多议员可以有一位总理（多对一），许多部长可以有许多部门（多对多）。

注意：关联可以是单向的或双向的。

阅读更多请访问 Java中的关联

聚合 (Aggregation)

聚合（Aggregation）是一种实现关联的方式。它表示一种关系，其中一个对象包含其他对象作为其状态的一部分。它表示对象之间弱关系。在Java中，它也被称为 HAS-A 关系。就像继承表示 IS-A 关系一样。它是重用对象的另一种方式。

阅读更多请访问 Java中的聚合

组合 (Composition)

组合（Composition）也是一种实现关联的方式。组合表示一种关系，其中一个对象包含其他对象作为其状态的一部分。包含对象和依赖对象之间存在强关系。这是对象没有独立存在的状态。如果我们删除父对象，所有子对象将自动被删除。

阅读更多请访问 Java中的组合

OOP 相对于过程式编程语言的优点

OOP 使开发和维护更容易，而在过程式编程语言中，如果代码随着项目规模的增加而增长，则难以管理。
OOP 提供数据隐藏，而在过程式编程语言中，全局数据可以从任何地方访问。
OOP 能够更有效地模拟现实世界事件。如果我们使用面向对象编程语言，我们可以为现实世界的问题提供解决方案。

面向对象编程语言和面向对象编程语言有什么区别？

面向对象编程语言遵循 OOP 的所有特性，但继承除外。JavaScript 和 VBScript 是面向对象编程语言的最佳示例。

示例

// Java program for demonstrating the features and functionalities of OOP concepts in Java.  
class Animal {  
    private String name;  
    // Constructor  
    public Animal(String name) {  
        this.name = name;  
    }  
    // Encapsulation: Getter method  
    public String getName() {  
        return name;  
    }  
    // Polymorphism: Overridden method  
    public void makeSound() {  
        System.out.println("Some sound");  
    }  
}  
// Derived class (Inheritance)  
class Dog extends Animal {  
    // Constructor  
    public Dog(String name) {  
        super(name);  
    }  
    // Polymorphism: Overriding method  
    @Override  
    public void makeSound() {  
        System.out.println("Woof");  
    }  
}  
// Derived class (Inheritance)  
class Cat extends Animal {  
    // Constructor  
    public Cat(String name) {  
        super(name);  
    }  
    // Polymorphism: Overriding method  
    @Override  
    public void makeSound() {  
        System.out.println("Meow");  
    }  
}  
public class Main{  
    public static void main(String[] args) {  
        // Creating objects of the Dog and Cat classes  
        Dog dog = new Dog("Buddy");  
        Cat cat = new Cat("Whiskers");  
        // Accessing methods of the base class through objects of derived classes  
        System.out.println("Dog name: " + dog.getName());  
        dog.makeSound();  
        System.out.println("Cat name: " + cat.getName());  
        cat.makeSound();  
    }  
}  

编译并运行

输出

Dog name: Buddy
Woof
Cat name: Whiskers
Meow

Java OOPs概念选择题

1. 以下哪项最好地描述了 Java 中的封装？

隐藏类的实现细节
定义多个同名方法
从现有类创建新类
允许将对象视为其父类的实例

答案：a)

解释：封装涉及隐藏类的实现细节并提供公共接口。

2. Java 中的方法重载是什么？

使用具有不同参数的相同方法名
使用具有相同参数的多个方法
在子类中扩展方法
在子类中重写方法

答案：a)

解释：方法重载允许具有相同名称但参数不同的多个方法。

3. 哪个概念允许子类提供对其超类中已定义方法的特定实现？

方法重载
方法覆盖
抽象
封装

答案：b)

解释：方法重写允许子类提供对其超类中定义的方法的特定实现。

4. 哪个访问修饰符用于限制同一包和子类中类成员的访问？

private
protected
default
public

答案：b)

解释：protected 访问修饰符限制对同一包及其子类中类成员的访问。

5. abstract 关键字在 Java 中的用途是什么？

声明一个不能实例化的类
定义一个必须由子类实现的类
a 和 b 都是
定义一个常量

答案：c)

解释：abstract 关键字用于声明一个不能实例化的类，并定义必须由子类实现的类。

你知道吗？

我们可以重载 main 方法吗？
Java 构造函数返回一个值，但返回什么？
没有 main 方法可以创建程序吗？
this 关键字有哪六种用法？
为什么 Java 不支持多重继承？
为什么要使用聚合？
可以重写静态方法吗？
什么是协变返回类型？
Java super 关键字有哪三种用法？
为什么要使用实例初始化块？
空白 final 变量的用途是什么？
什么是标记接口或标记接口？
什么是运行时多态或动态方法分派？
静态绑定和动态绑定有什么区别？
Java 中如何实现向下转型？
私有构造函数的用途是什么？
什么是对象克隆？

我们将在 OOPs 概念中学习什么？

OOPs 的优点
命名约定
对象和类
方法重载
构造函数
static 关键字
this 关键字的六种用法
继承
聚合 (Aggregation)
方法重写
协变返回类型
super 关键字
实例初始化块
final 关键字
抽象类
Interface
运行时多态
静态绑定和动态绑定
使用 instanceof 运算符进行向下转型
包
访问修饰符
封装
对象克隆

下一主题Java中的命名约定

我们提供所有技术（如 Java 教程、Android、Java 框架）的教程和面试问题

联系信息

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

+91-9599086977

关注我们

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java 教程

控制语句

Java Object 类

Java 继承

Java 多态

Java 抽象

Java 封装

Java 数组

Java OOPs 杂项

Java 字符串

Java 正则表达式

异常处理

Java 内部类

Java 多线程

Java 同步

Java I/O

Java 文件处理

Java 序列化

Java 网络

Java 反射

Java 集合

Java 5 特性

Java 8 特性

Java JDBC

RMI

国际化

Java 项目

Java 中的 OOPs 概念

OOPs（面向对象编程）

Object

对象示例

示例

继承

继承示例

示例

多态

多态示例

示例

抽象

抽象示例

示例

封装

抽象示例

示例

耦合

内聚

关联 (Association)

注意：关联可以是单向的或双向的。

聚合 (Aggregation)

组合 (Composition)

OOP 相对于过程式编程语言的优点

面向对象编程语言和面向对象编程语言有什么区别？

示例

Java OOPs概念选择题

相关帖子

Java 类和对象

Java 中的 static 关键字

Java 命名约定

Java 中的构造函数

Java 方法