面向对象编程教程

1740字约6分钟

Java基础语法面向对象OOP

2025-08-17

概述

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将现实世界中的事物抽象为对象，通过对象之间的交互来解决问题。Java是一门完全面向对象的语言，理解面向对象的概念对Java开发至关重要。

面向对象编程有四大核心特性：

类和对象 - 程序的基本单元
封装 - 隐藏实现细节，提供公共接口
继承 - 子类可以继承父类的属性和方法
多态 - 同一个接口可以有不同的实现

类和对象

类（Class）

类是对象的模板或蓝图，它定义了对象的属性和行为。类是一种抽象的概念，描述了一类事物的共同特征。

在我们的示例代码中，我们定义了一个Person 类：

class Person {
    // 实例变量（属性）
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 实例方法
    public void introduce() {
        System.out.println("大家好，我是" + name + "，今年" + age + "岁。");
    }
    
    // ... getter和setter方法
}

对象（Object）

对象是类的实例，是具体存在的实体。通过new关键字可以创建类的对象。

在示例代码中，我们创建了两个Person 对象：

Person person1 = new Person("张三", 25);
Person person2 = new Person("李四", 30);

每个对象都有自己的属性值，但共享类的方法定义。

封装

封装是面向对象编程的核心概念之一，它将数据（属性）和操作数据的方法组合在一起，同时隐藏对象的内部实现细节，只通过公共接口与外界交互。

封装的优点

信息隐藏 - 隐藏对象的内部实现细节
提高安全性 - 通过访问控制防止非法访问
提高可维护性 - 内部实现改变不影响外部代码

实现封装的关键要素

访问修饰符

Java提供了四种访问修饰符来控制访问级别：

private - 私有的，只能在本类中访问
default - 默认的，可以在同一包内访问
protected - 受保护的，可以在同一包内和子类中访问
public - 公共的，可以在任何地方访问

在BankAccount 类中，我们使用private修饰属性：

class BankAccount {
    private String accountNumber;  // 账户号
    private String ownerName;      // 户主姓名
    private double balance;        // 余额
    // ...
}

这样外部代码就不能直接访问这些属性，必须通过公共方法来操作。

Getter和Setter方法

提供公共的getter和setter方法来安全地访问和修改私有属性：

// Getter方法
public String getAccountInfo() {
    return "账户号: " + accountNumber + ", 户主: " + ownerName;
}

public double getBalance() {
    return balance;
}

// Setter方法（示例中省略了setter，因为账户号和户主一般不允许修改）

构造方法

通过构造方法在创建对象时初始化属性：

public BankAccount(String accountNumber, String ownerName, double initialBalance) {
    this.accountNumber = accountNumber;
    this.ownerName = ownerName;
    this.balance = initialBalance > 0 ? initialBalance : 0;
}

业务方法

提供具有业务逻辑的公共方法：

public boolean deposit(double amount) {
    if (amount > 0) {
        balance += amount;
        System.out.println("存款成功: " + amount);
        return true;
    } else {
        System.out.println("存款金额必须大于0");
        return false;
    }
}

通过封装，我们确保了数据的安全性和一致性，防止了非法操作。

继承

继承是面向对象编程的重要特性，它允许一个类（子类）获取另一个类（父类）的属性和方法，实现代码重用。

继承的优点

代码重用 - 子类可以重用父类的代码
扩展性 - 子类可以在继承的基础上增加新的功能
多态的基础 - 继承是实现多态的前提

继承的实现

在Java中，使用extends关键字实现继承：

class Animal {  // 父类
    protected String name;
    // ...
}

class Dog extends Animal {  // Dog类继承Animal类
    private String breed;
    // ...
}

在示例代码中，Dog 和Cat 类都继承了Animal类：

class Dog extends Animal {
    // ...
}

class Cat extends Animal {
    // ...
}

继承中的关键概念

super关键字

子类可以通过super关键字调用父类的构造方法或方法：

public Dog(String name, String breed) {
    super(name); // 调用父类的构造方法
    this.breed = breed;
}

方法重写（Override）

子类可以重写父类的方法，提供自己的实现：

@Override
public void eat() {
    System.out.println(name + "正在吃狗粮...");
}

使用@Override注解可以确保方法确实被重写，避免拼写错误。

多态

多态是指同一个方法调用可以根据对象的不同而表现出不同的行为。它是面向对象编程的核心特性之一。

多态的实现条件

要有继承关系
要有方法重写
要有父类引用指向子类对象

多态的体现

在示例代码中，我们演示了多态的使用：

Animal animal1 = new Dog("小白", "哈士奇");  // 父类引用指向子类对象
Animal animal2 = new Cat("小花", 2);        // 父类引用指向子类对象

animal1.makeSound();  // 调用Dog类重写的makeSound方法
animal2.makeSound();  // 调用Cat类重写的makeSound方法

虽然都是调makeSound() 方法，但由于实际对象不同，表现出不同的行为。

向下转型和instanceof

为了使用子类特有的方法，我们需要进行向下转型（将父类引用转换为子类引用）：

if (animal1 instanceof Dog) {           // 检查对象类型
    Dog dog = (Dog) animal1;            // 向下转型
    dog.bark();                         // 调用子类特有方法
}

instanceof操作符用于检查对象是否是某个类的实例，防止类型转换异常。

包结构说明

为了更好地组织代码，我们将每个类分别放在独立的Java文件中，并统一放在com.ibz.oop包中：

src/main/java/com/ibz/oop/
├── OOPDemo.java     // 主类，包含演示方法
├── Animal.java      // 动物基类
├── Dog.java         // 狗类，继承Animal
├── Cat.java         // 猫类，继承Animal
├── Person.java      // 人类
├── BankAccount.java // 银行账户类

这种组织方式符合Java最佳实践：

每个.java文件只包含一个公共类
文件名与公共类名完全一致
相关类放在同一个包中便于管理
主类（包含main方法）独立存在

要运行该程序，可以使用以下命令：

javac src/main/java/com/ibz/oop/*.java
java -cp src/main/java com.ibz.基础.oop.OOPDemo

或者使用Maven：

mvn compile
mvn exec:java -Dexec.mainClass="com.ibz.基础.oop.OOPDemo"

总结

面向对象编程是Java的核心编程思想，掌握这四大特性对Java开发至关重要：

类和对象 - 是面向对象编程的基础，类是模板，对象是实例
封装 - 通过访问控制和方法提供安全的数据访问方式
继承 - 实现代码重用，建立类之间的层次关系
多态 - 提供统一接口的不同实现，增强程序的灵活性