你想深入理解 Java 中的面向对象编程（OOP），这是 Java 编程的核心思想，我会从基础概念到核心特性，用通俗易懂的方式给你讲清楚。
一、面向对象的核心思想
首先，先理解「面向对象」到底是什么：
- 对比理解：传统的「面向过程」是按步骤写代码（比如 “先登录、再查数据、再展示”），关注 “怎么做”；
- 面向对象是把问题拆分成一个个「对象」（比如 “用户对象、订单对象、商品对象”），关注 “谁来做”，每个对象都有自己的属性和行为，通过对象之间的交互完成功能。
面向对象有 4 个核心特性：封装、继承、多态、抽象，这是理解的关键。
二、面向对象的基础概念
1. 类（Class）与对象（Object）
这是 OOP 的最基础概念，先搞懂这两个的关系：
- 类：是「模板 / 蓝图」，定义了一类事物的共同属性和行为。比如 “人类” 这个类，属性有姓名、年龄，行为有吃饭、走路。
- 对象：是类的「具体实例」。比如 “张三” 就是 “人类” 这个类的一个对象，有具体的姓名（张三）、年龄（20）。
代码示例（类和对象）：
// 定义一个「人类」类（模板）
public class Person {
// 1. 属性（成员变量）：描述对象的特征
String name; // 姓名
int age; // 年龄
// 2. 行为（方法）：描述对象能做的事
public void eat() {
System.out.println(name + "在吃饭");
}
public void run() {
System.out.println(name + "在跑步，年龄：" + age);
}
// 主方法：测试代码
public static void main(String[] args) {
// 创建「人类」的具体对象（实例化）
Person zhangsan = new Person();
// 给对象赋值属性
zhangsan.name = "张三";
zhangsan.age = 20;
// 调用对象的方法
zhangsan.eat(); // 输出：张三在吃饭
zhangsan.run(); // 输出：张三在跑步，年龄：20
// 再创建一个对象
Person lisi = new Person();
lisi.name = "李四";
lisi.age = 25;
lisi.eat(); // 输出：李四在吃饭
}
}
2. 封装（Encapsulation）
核心是「隐藏内部细节，只暴露必要的接口」，目的是保证数据安全。
- 做法：
- 将类的属性用
private修饰（私有），外部不能直接访问； - 提供
public的getter/setter方法，供外部访问 / 修改属性； - 可以在
setter中加逻辑校验，避免非法数据。
- 将类的属性用
代码示例（封装）：
public class Person {
// 1. 属性私有化
private String name;
private int age;
// 2. 提供getter（获取属性）和setter（修改属性）方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
// 在setter中加校验：年龄不能小于0
public void setAge(int age) {
if (age < 0) {
System.out.println("年龄不能为负数，默认设为0");
this.age = 0;
} else {
this.age = age;
}
}
// 普通方法
public void introduce() {
System.out.println("我叫" + name + "，今年" + age + "岁");
}
public static void main(String[] args) {
Person person = new Person();
person.setName("王五");
person.setAge(-5); // 触发校验，输出：年龄不能为负数，默认设为0
person.introduce(); // 输出：我叫王五，今年0岁
}
}
3. 继承（Inheritance）
核心是「代码复用」，让子类继承父类的属性和方法，子类还能扩展自己的功能。
- 关键字：
extends - 规则：
- Java 是单继承（一个子类只能继承一个父类），但可以多层继承；
- 子类不能继承父类的
private属性 / 方法，但可以通过父类的public方法间接访问； - 父类的构造方法不能继承，但子类构造方法会默认调用父类的无参构造。
代码示例（继承）：
// 父类：人类（基类/超类）
public class Person {
protected String name; // protected：子类可以直接访问
protected int age;
public void eat() {
System.out.println(name + "在吃饭");
}
}
// 子类：学生类（派生类），继承Person
public class Student extends Person {
// 子类扩展自己的属性
private String studentId; // 学号
// 子类扩展自己的方法
public void study() {
System.out.println(name + "（学号：" + studentId + "）在学习");
}
// 重写父类方法（方法重写是多态的基础）
@Override
public void eat() {
System.out.println(name + "在食堂吃饭");
}
public static void main(String[] args) {
Student student = new Student();
student.name = "赵六"; // 直接访问父类的protected属性
student.studentId = "2024001";
student.eat(); // 调用重写后的方法，输出：赵六在食堂吃饭
student.study(); // 输出：赵六（学号：2024001）在学习
}
}
4. 多态（Polymorphism）
核心是「一个事物多种形态」，允许父类引用指向子类对象，调用方法时自动执行子类的实现。
- 实现条件：
- 有继承关系；
- 子类重写父类方法；
- 父类引用指向子类对象。
- 好处：降低代码耦合，提高扩展性。
代码示例（多态）：
// 父类
public class Animal {
public void makeSound() {
System.out.println("动物发出声音");
}
}
// 子类1：狗
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("小狗汪汪叫");
}
}
// 子类2：猫
public class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("小猫喵喵叫");
}
}
// 测试多态
public class TestPolymorphism {
public static void main(String[] args) {
// 父类引用指向子类对象
Animal animal1 = new Dog();
Animal animal2 = new Cat();
// 调用方法时，自动执行子类的实现
animal1.makeSound(); // 输出：小狗汪汪叫
animal2.makeSound(); // 输出：小猫喵喵叫
// 多态的优势：新增子类（如Bird），无需修改下面的方法
makeAnimalSound(new Dog());
makeAnimalSound(new Cat());
}
// 统一的方法，接收所有Animal子类对象
public static void makeAnimalSound(Animal animal) {
animal.makeSound();
}
}
5. 抽象（Abstraction）
核心是「隐藏具体实现，只定义规范」，用抽象类或接口实现。
- 抽象类（
abstract class）：- 不能实例化（不能
new），只能被继承； - 可以包含抽象方法（只有方法签名，没有实现）和普通方法；
- 子类必须实现抽象类的所有抽象方法（除非子类也是抽象类）。
- 不能实例化（不能
- 接口（
interface）：- 比抽象类更 “抽象”，所有方法默认是
public abstract（JDK8+ 支持默认方法）； - 类可以实现多个接口（弥补 Java 单继承的不足）；
- 常用于定义 “行为规范”。
- 比抽象类更 “抽象”，所有方法默认是
代码示例（抽象类）：
// 抽象类：定义“交通工具”的规范
public abstract class Vehicle {
// 普通方法
public void fuel() {
System.out.println("需要加油/充电");
}
// 抽象方法：子类必须实现
public abstract void run();
}
// 子类1：汽车
public class Car extends Vehicle {
@Override
public void run() {
System.out.println("汽车在公路上跑");
}
}
// 子类2：自行车
public class Bicycle extends Vehicle {
@Override
public void run() {
System.out.println("自行车靠人力蹬着跑");
}
public static void main(String[] args) {
// Vehicle v = new Vehicle(); // 报错：抽象类不能实例化
Vehicle car = new Car();
car.run(); // 输出：汽车在公路上跑
car.fuel(); // 输出：需要加油/充电
}
}
代码示例（接口）：
// 接口：定义“会飞”的行为规范
public interface Flyable {
void fly(); // 抽象方法，默认public abstract
}
// 接口：定义“会游泳”的行为规范
public interface Swimmable {
void swim();
}
// 类实现多个接口
public class Duck implements Flyable, Swimmable {
@Override
public void fly() {
System.out.println("鸭子低空飞行");
}
@Override
public void swim() {
System.out.println("鸭子在水里游");
}
public static void main(String[] args) {
Duck duck = new Duck();
duck.fly();
duck.swim();
}
}
三、面向对象的其他重要补充
- 构造方法：创建对象时自动调用，用于初始化对象。
- 名称必须和类名相同，无返回值（连
void都没有）； - 如果不写构造方法，JVM 会默认提供无参构造；如果写了有参构造，默认无参构造会失效。
- 名称必须和类名相同，无返回值（连
- this 关键字：指代当前对象，用于区分成员变量和局部变量。
- super 关键字：指代父类对象，用于调用父类的属性、方法或构造方法。
总结
Java 面向对象的核心可以总结为 3 个关键点：
- 基础核心：类是模板，对象是实例，所有功能都围绕 “对象” 展开；
- 四大特性：封装（隐藏细节）、继承（复用代码）、多态（灵活扩展）、抽象（定义规范）；
- 核心价值：让代码更易维护、易扩展、易复用，符合大型项目的开发逻辑。
如果有具体的知识点（比如构造方法、接口和抽象类的区别）想深入了解，可以告诉我。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
