Java面向对象

Java面向对象编程详解

原创于 2025-08-07 16:12:51 发布 · 657 阅读

22 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

JavaSE 专栏收录该内容

13 篇文章

订阅专栏

Java面向对象编程详解

Java面向对象编程（OOP）是一种以“对象”为核心的编程范式，它将数据和操作数据的方法封装在对象中，强调代码的可重用性、可维护性和灵活性。与面向过程编程（如C语言）相比，OOP更注重对象之间的交互和抽象。以下我将逐步解释核心概念，确保内容基于Java语言特性，并参考站内引用进行说明。

1. 面向对象思想

面向对象思想的核心是将现实世界的事物抽象为“对象”，每个对象包含属性（数据）和行为（方法）。例如，“汽车”对象可能有属性（如颜色、速度）和行为（如启动、刹车）。这与面向过程编程（如按步骤编写函数）不同，OOP通过对象封装状态和行为，提高模块化程度。

面向过程 vs 面向对象：
面向过程关注“怎么做”（如函数序列），而面向对象关注“谁来做”（如对象协作）。例如，计算圆面积：
- 面向过程：定义函数 calculateArea(radius)，直接操作数据。
- 面向对象：创建 Circle 类，封装 radius 属性和 calculateArea() 方法，对象调用方法完成计算。
  优点：OOP更易扩展（如添加新对象类型），但初始设计更复杂；面向过程更直接，但维护性差。

2. 三大特性：封装、继承、多态

这三大特性是OOP的基石，确保代码的抽象性和灵活性。

封装（Encapsulation）：
将数据（属性）和操作数据的方法绑定在类中，并隐藏内部细节。通过访问权限修饰符控制外部访问：
- private：仅类内访问（完全隐藏）。
- protected：类内和子类访问。
- public：任意访问。
- 默认（不写）：同包内访问。
  示例：
```
public class Person {
    private String name; // 封装属性，外部不可直接访问
    public void setName(String name) { // 提供公共方法修改
        this.name = name;
    }
}
```
封装增强安全性和可维护性，防止外部误操作。

继承（Inheritance）：
子类（派生类）继承父类（基类）的属性和方法，实现代码复用。Java使用 extends 关键字。
示例：

public class Animal {
    protected String name; // protected，子类可见
    public void eat(String food) {
        System.out.println(name + "正在吃" + food);
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        this.name = name; // 继承父类属性
    }
    @Override
    public void eat(String food) { // 重写方法
        System.out.println("狗狗" + name + "正在吃" + food);
    }
}

继承支持“is-a”关系（如狗是动物），但需注意：父类私有成员不可继承，构造方法需通过 super() 显式调用。

多态（Polymorphism）：
同一方法在不同对象中有不同实现。Java通过方法重写（Override）和接口实现多态。
示例：

public abstract class Shape {
    public abstract void draw(); // 抽象方法
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

public class Test {
    public static void main(String[] args) {
        Shape shape = new Circle(); // 父类引用指向子类对象
        shape.draw(); // 输出: Drawing a circle.（动态绑定）
    }
}

多态提高代码灵活性，支持运行时动态绑定（JVM根据对象类型决定调用哪个方法）。

3. 修饰符作用域

Java修饰符控制类、方法、变量的访问范围和特性：

访问权限修饰符：
- public：全局可见（任何类）。
- protected：同包或子类可见。
- 默认（无修饰符）：仅同包可见。
- private：仅类内可见。
  作用：确保封装性，避免非法访问。
其他修饰符：
- static：修饰类成员（变量或方法），使其属于类而非对象。静态变量共享内存，静态方法可直接通过类名调用（无需实例化）。
  示例：
```
public class Counter {
    public static int count = 0; // 静态变量，所有对象共享
    public static void increment() { // 静态方法
        count++;
    }
}
```
- final：修饰变量（常量，不可修改）、方法（不可重写）、类（不可继承）。
- abstract：修饰类或方法，表示抽象（需子类实现）。

4. 接口定义与使用

接口（Interface）定义一组抽象方法（无实现），用于实现多继承和规范行为。Java使用 interface 关键字，类通过 implements 实现接口。

定义与实现：
接口可包含抽象方法、默认方法（Java 8+）和静态方法。
示例：

public interface Drawable {
    void draw(); // 抽象方法
    default void resize() { // 默认方法（可选实现）
        System.out.println("Resizing...");
    }
}

public class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

接口 vs 抽象类：
- 接口：纯抽象（Java 8前），支持多实现（一个类可实现多个接口）。
- 抽象类：可包含实现方法，但只支持单继承。
  接口更适用于定义行为契约（如 Drawable），抽象类用于部分共享实现（如 Animal 类）。

5. 内部类原理

内部类（Inner Class）是定义在另一个类内部的类，用于逻辑分组或访问外部类私有成员。Java支持四种类型：

成员内部类：普通内部类，持有外部类引用，可直接访问其私有成员。
示例：

public class Outer {
    private int outerVar = 10;
    public class Inner {
        public void display() {
            System.out.println("Access outerVar: " + outerVar); // 直接访问外部类私有变量
        }
    }
}

原理：编译时生成 Outer$Inner.class，内部类隐式持有 Outer.this 引用。

静态内部类：用 static 修饰，不依赖外部类实例，无法访问非静态成员。
示例：

public class Outer {
    static class StaticInner {
        // 可独立实例化
    }
}

局部内部类：定义在方法内，作用域限于该方法。

匿名内部类：无类名，用于一次性实现接口或抽象类。
示例：

public interface Greeting {
    void greet();
}
public class Test {
    public static void main(String[] args) {
        Greeting greeting = new Greeting() { // 匿名内部类
            @Override
            public void greet() {
                System.out.println("Hello!");
            }
        };
    }
}