“编程的本质，是用抽象的方式解决问题。”
Java 作为一门纯面向对象的编程语言，其核心思想就是：万物皆对象，一切皆可封装。
本文将带你深入理解 面向对象（OOP）的四大特性 和 方法（Method）的设计与使用，助你写出更优雅、更专业的 Java 代码。
📌 为什么学习面向对象？
在学习语法之后，你可能会问：
“我可以用 if、for、数组 写程序，为什么还要学面向对象？”
答案是：为了写出更清晰、更易维护、更可扩展的代码。
想象一下：
- 如果你要开发一个“学生管理系统”，你会用一堆变量（
name1,age1,score1...）来表示学生吗？ - 如果要添加“老师”、“课程”呢？代码会变得混乱不堪。
而面向对象，让你可以用 类（Class） 和 对象（Object） 来组织数据和行为，让程序结构更清晰。
一、面向对象编程（OOP）四大特性
Java 的面向对象编程基于四大核心特性：封装、继承、多态、抽象。我们逐个解析。
1. 封装（Encapsulation）：隐藏细节，暴露接口
“把不该别人看到的东西藏起来，只提供安全的访问方式。”
✅ 什么是封装？
- 将数据（属性）和操作数据的方法（行为）封装在一个类中
- 使用访问修饰符（
private,protected,public）控制访问权限
✅ 示例：学生类
public class Student { // 私有属性：外部无法直接访问 private String name; private int age; private double score; // 公共方法：提供访问和修改的“安全通道” public String getName() { return name; } public void setName(String name) { if (name != null && !name.trim().isEmpty()) { this.name = name; } else { System.out.println("姓名不能为空！"); } } public int getAge() { return age; } public void setAge(int age) { if (age >= 0 && age <= 150) { this.age = age; } else { System.out.println("年龄必须在 0-150 之间！"); } } // 行为方法 public void study() { System.out.println(name + " 正在努力学习，当前成绩：" + score); } }
✅ 封装的好处
- 安全性：防止非法数据（如年龄为 -5）
- 可维护性：修改内部逻辑不影响外部调用
- 复用性：一个类可以被多个地方使用
💡 原则：属性私有化，提供 getter/setter 方法
2. 继承（Inheritance）：代码复用的“家族传承”
“子承父业，站在巨人的肩膀上。”
✅ 什么是继承？
- 一个类（子类）可以继承另一个类（父类）的属性和方法
- 使用
extends关键字实现
✅ 示例：人 → 学生 / 老师
// 父类 public class Person { protected String name; protected int age; public void eat() { System.out.println(name + " 正在吃饭"); } public void sleep() { System.out.println(name + " 正在睡觉"); } } // 子类 public class Student extends Person { private double score; public void study() { System.out.println(name + " 正在学习，成绩：" + score); } } public class Teacher extends Person { private String subject; public void teach() { System.out.println(name + " 正在讲授 " + subject); } }
✅ 使用
Student s = new Student(); s.name = "张三"; // 可访问 protected 属性 s.eat(); // 继承自父类 s.study(); // 自身方法
✅ 继承的好处
- 代码复用：避免重复写
name、age、eat()等 - 扩展性：子类可以添加新功能
- 多态基础：为多态提供支持
⚠️ 注意：Java 只支持单继承（一个类只能继承一个父类），但可以通过接口实现多继承效果。
3. 多态（Polymorphism）：同一操作，不同行为
“同样的指令，不同的对象做出不同的反应。”
✅ 什么是多态？
- 同一个方法调用，由于对象不同而产生不同的行为
- 体现为：父类引用指向子类对象
✅ 示例：动物叫
// 父类 abstract class Animal { abstract void makeSound(); // 抽象方法，子类必须实现 } // 子类 class Dog extends Animal { void makeSound() { System.out.println("汪汪汪！"); } } class Cat extends Animal { void makeSound() { System.out.println("喵喵喵！"); } }
✅ 多态调用
Animal a1 = new Dog(); Animal a2 = new Cat(); a1.makeSound(); // 汪汪汪！ a2.makeSound(); // 喵喵喵！
✅ 多态的好处
- 灵活性：方法可以接受父类型，实际传入任意子类对象
- 可扩展性：新增动物类，无需修改调用代码
public void playWithAnimal(Animal animal) { animal.makeSound(); // 任何动物都能“玩” }
4. 抽象（Abstraction）：忽略细节，关注本质
“抓大放小，只关心‘做什么’，不关心‘怎么做’。”
- 抽象类（
abstract class）：不能被实例化，用于定义模板 - 抽象方法：只有声明，没有实现，由子类实现
✅ 上面的
Animal类就是一个典型的抽象类。
二、方法（Method）：行为的“执行单元”
方法是类中定义的功能模块，用于执行特定任务。
1. 方法的定义
[访问修饰符] [返回类型] 方法名([参数列表]) { // 方法体 [return 返回值;] }
✅ 示例：计算两数之和
public int add(int a, int b) { int sum = a + b; return sum; }
| 部分 | 说明 |
public |
访问修饰符 |
int |
返回类型（void 表示无返回值） |
add |
方法名（小驼峰命名法） |
(int a, int b) |
参数列表（可多个） |
{ ... } |
方法体 |
2. 方法的调用
Student s = new Student(); s.setName("李四"); // 调用 setter 方法 s.study(); // 调用行为方法 int result = add(3, 5); // 调用静态方法
3. 方法的重载（Overload）
同一个类中，方法名相同，但参数不同（类型、个数、顺序）
public class Calculator { public int add(int a, int b) { return a + b; } public double add(double a, double b) { return a + b; } public int add(int a, int b, int c) { return a + b + c; } }
✅ 编译器根据参数类型和个数决定调用哪个方法。
4. 构造方法（Constructor）
用于创建对象时初始化状态
public class Student { private String name; private int age; // 无参构造 public Student() { this.name = "未知"; this.age = 0; } // 有参构造 public Student(String name, int age) { this.name = name; this.age = age; } }
✅ 调用
Student s1 = new Student(); // 调用无参构造 Student s2 = new Student("王五", 21); // 调用有参构造
💡 注意：
- 构造方法名必须与类名相同
- 没有返回类型（连
void都没有）- 如果不写，Java 会提供一个默认无参构造
- 一旦写了有参构造，默认无参构造会消失，需手动添加
✅ 实战练习：设计一个“银行账户”类
public class BankAccount { private String accountNumber; private double balance; public BankAccount(String accountNumber) { this.accountNumber = accountNumber; this.balance = 0.0; } // 存款 public void deposit(double amount) { if (amount > 0) { balance += amount; System.out.println("存款成功，余额：" + balance); } else { System.out.println("存款金额必须大于0！"); } } // 取款 public void withdraw(double amount) { if (amount > 0 && amount <= balance) { balance -= amount; System.out.println("取款成功，余额：" + balance); } else { System.out.println("余额不足或金额非法！"); } } // 查询余额 public double getBalance() { return balance; } public String getAccountNumber() { return accountNumber; } }
✅ 测试
BankAccount acc = new BankAccount("123456"); acc.deposit(1000); acc.withdraw(300); System.out.println("当前余额：" + acc.getBalance());
🎯 总结：OOP 与方法核心要点
| 概念 | 核心思想 | 关键字/语法 |
| 封装 | 隐藏内部细节 | private + getter/setter |
| 继承 | 代码复用 | extends |
| 多态 | 同一接口，不同实现 | 父类引用指向子类对象 |
| 抽象 | 定义模板 | abstract class / abstract method |
| 方法 | 执行特定任务 | 访问修饰符 + 返回类型 + 参数 |
| 方法重载 | 同名不同参 | 参数类型/个数不同 |
| 构造方法 | 初始化对象 | 与类同名，无返回类型 |
