Java 面向对象编程完全入门：对象、类、继承、接口、包 五大核心概念一文通透

你是否刚接触 Java，看到 class、extends、implements 这些关键字就一头雾水？或者你已经能写简单程序，但总觉得对面向对象"似懂非懂"？

这篇文章会从零基础出发，用大量生活化比喻和完整可运行的代码，帮你一次性吃透 Java 面向对象编程的五大核心概念。每个概念都配有代码实战，读完即可动手。

一、面向对象编程到底是什么

在写代码之前，你需要先理解一种思维方式——面向对象编程（Object-Oriented Programming，简称 OOP）。

传统的编程方式（面向过程）像是在写一份菜谱：先做第一步，再做第二步，一步接一步。而面向对象的思维方式不同，它把现实世界抽象成一个个对象，每个对象有自己的数据和能力，对象之间通过互相发消息来协作完成任务。

Java 从设计之初就是一门面向对象的语言，它的五大核心概念是：

下面逐一展开。

二、对象（Object）——万物皆对象

2.1 从现实世界理解对象

环顾你的四周，到处都是对象：你的手机、你的水杯、你面前的电脑。

每个现实对象都有两个特征：

• 状态（State）：描述对象"是什么样"——手机的品牌、电量、是否静音
• 行为（Behavior）：描述对象"能做什么"——手机能打电话、发短信、拍照

这个思路直接搬到编程里：

• 状态 → 字段（Field），也叫成员变量
• 行为 → 方法（Method），也叫成员函数

2.2 数据封装——对象最重要的原则

软件对象有一个关键设计原则：数据封装（Data Encapsulation）。

什么意思？就是对象的内部数据不能被外界直接访问，必须通过方法来操作。

想象一台 ATM 机：你不能直接打开机器拿钱，你必须通过"插卡→输密码→选金额→取款"这一套流程（方法）来操作。ATM 内部有多少钱、钞票怎么存放，你完全不知道，也不需要知道。

这样做的好处是：

2.3 代码实战：用 Java 表示一个对象

class Dog {
// 状态（字段）
String name;
String color;
boolean hungry;

// 行为（方法）
void bark() {
System.out.println(name + " 汪汪叫！");
}

void eat() {
hungry = false;
System.out.println(name + " 吃饱了。");
}

void printState() {
System.out.println("名字: " + name +
", 颜色: " + color +
", 饿了吗: " + hungry);
}
}

class DogDemo {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.name = "旺财";
myDog.color = "棕色";
myDog.hungry = true;

myDog.printState();
myDog.bark();
myDog.eat();
myDog.printState();
}
}

运行结果：

名字: 旺财, 颜色: 棕色, 饿了吗: true
旺财 汪汪叫！
旺财 吃饱了。
名字: 旺财, 颜色: 棕色, 饿了吗: false

关键观察：myDog 就是一个对象，它有自己的状态（name、color、hungry），也有自己的行为（bark()、eat()）。调用 eat() 方法后，对象内部的 hungry 状态从 true 变成了 false——外界通过方法改变了对象的状态。

三、类（Class）——对象的蓝图

3.1 类和对象的关系

类是蓝图，对象是根据蓝图造出来的实物。

一份蓝图可以造出无数栋楼——每栋楼就是一个对象（实例）。楼与楼之间结构相同，但住的人不同，装修也不同——每个对象有自己独立的状态。

Java 中用 class 关键字定义类，用 new 关键字创建对象：

class Bicycle {
// 状态
int cadence = 0; // 踏频
int speed = 0; // 速度
int gear = 1; // 档位

// 行为
void changeCadence(int newValue) {
cadence = newValue;
}

void changeGear(int newValue) {
gear = newValue;
}

void speedUp(int increment) {
speed = speed + increment;
}

void applyBrakes(int decrement) {
speed = speed – decrement;
}

void printStates() {
System.out.println("踏频:" + cadence +
" 速度:" + speed + " 档位:" + gear);
}
}

3.2 类 vs 对象：一个关键区分

很多初学者混淆类和对象。记住这个对比：

3.3 创建多个对象

class BicycleDemo {
public static void main(String[] args) {
// 用同一个类创建两个不同的对象
Bicycle bike1 = new Bicycle();
Bicycle bike2 = new Bicycle();

// 分别操作
bike1.changeCadence(50);
bike1.speedUp(10);
bike1.changeGear(2);
bike1.printStates();

bike2.changeCadence(50);
bike2.speedUp(10);
bike2.changeGear(2);
bike2.changeCadence(40);
bike2.speedUp(10);
bike2.changeGear(3);
bike2.printStates();
}
}

运行结果：

踏频:50 速度:10 档位:2
踏频:40 速度:20 档位:3

虽然 bike1 和 bike2 都是从 Bicycle 类创建的，但它们各自拥有独立的状态——调用不同的方法后，两辆车的踏频、速度、档位完全不同。

⚠️ 初学者常见误区：Bicycle 类本身没有 main 方法，它不是一个可以直接运行的程序。它只是蓝图，需要另一个类（如 BicycleDemo）来创建对象并使用。

四、继承（Inheritance）——代码复用的利器

4.1 为什么需要继承

山地车、公路车、双人车都是自行车。它们共享自行车的基本特征（速度、踏频、档位），但又各有独特之处：

• 山地车：有避震、可越野
• 公路车：轻量、弯把
• 双人车：双座、双车把

如果每种车都从头写代码，会有大量重复。继承让你把共有的部分放在父类中，子类只需要写自己独有的部分。

4.2 Java 继承语法

// 父类（超类）
class Bicycle {
int cadence = 0;
int speed = 0;
int gear = 1;

void changeCadence(int newValue) { cadence = newValue; }
void changeGear(int newValue) { gear = newValue; }
void speedUp(int increment) { speed += increment; }
void applyBrakes(int decrement) { speed -= decrement; }

void printStates() {
System.out.println("踏频:" + cadence +
" 速度:" + speed + " 档位:" + gear);
}
}

// 子类——山地车
class MountainBike extends Bicycle {
String terrain; // 山地车独有：地形类型

void setTerrain(String newTerrain) {
terrain = newTerrain;
}

// 重写父类方法，增加地形信息
void printStates() {
System.out.println("踏频:" + cadence +
" 速度:" + speed + " 档位:" + gear +
" 地形:" + terrain);
}
}

// 子类——公路车
class RoadBike extends Bicycle {
int tireWidth; // 公路车独有：轮胎宽度（毫米）

void setTireWidth(int width) {
tireWidth = width;
}

void printStates() {
System.out.println("踏频:" + cadence +
" 速度:" + speed + " 档位:" + gear +
" 轮胎宽度:" + tireWidth + "mm");
}
}

class InheritanceDemo {
public static void main(String[] args) {
MountainBike mtb = new MountainBike();
mtb.changeCadence(60); // 继承自 Bicycle
mtb.speedUp(15); // 继承自 Bicycle
mtb.changeGear(3); // 继承自 Bicycle
mtb.setTerrain("碎石路"); // MountainBike 独有
mtb.printStates();

RoadBike road = new RoadBike();
road.changeCadence(80);
road.speedUp(25);
road.changeGear(5);
road.setTireWidth(23); // RoadBike 独有
road.printStates();
}
}

运行结果：

踏频:60 速度:15 档位:3 地形:碎石路
踏频:80 速度:25 档位:5 轮胎宽度:23mm

4.3 继承的核心规则

4.4 继承的本质是"是一种（is-a）"关系

判断该不该用继承，问自己一个问题：“子类是一种父类吗？”

• 山地车是一种自行车 ✅ → 可以继承
• 引擎不是一种汽车 ❌ → 不该继承，应该用"包含（has-a）"关系

这个判断标准在面试中经常考到。

五、接口（Interface）——行为的契约

5.1 接口是什么

接口定义了一组方法签名，但不提供实现。它相当于一份合同：“你要用我，就必须实现这些方法。”

interface Bicycle {
void changeCadence(int newValue);
void changeGear(int newValue);
void speedUp(int increment);
void applyBrakes(int decrement);
}

5.2 实现接口

用 implements 关键字实现接口，类必须提供接口中所有方法的具体实现：

class ACMEBicycle implements Bicycle {
int cadence = 0;
int speed = 0;
int gear = 1;

public void changeCadence(int newValue) {
cadence = newValue;
}

public void changeGear(int newValue) {
gear = newValue;
}

public void speedUp(int increment) {
speed = speed + increment;
}

public void applyBrakes(int decrement) {
speed = speed – decrement;
}

public void printStates() {
System.out.println("踏频:" + cadence +
" 速度:" + speed + " 档位:" + gear);
}
}

注意：实现接口方法时必须加 public 关键字（这是 Java 的规定，接口方法默认是 public 的）。

5.3 接口 vs 抽象类——面试必考

这是后续章节会深入讲的内容，这里先给个简要对比：

面试时常被问到"什么时候用接口，什么时候用抽象类"，答题思路：需要多重继承能力或者定义跨类族的通用行为时用接口；需要共享代码和状态时用抽象类。

六、包（Package）——代码的组织结构

6.1 为什么需要包

一个大型 Java 项目可能有成百上千个类。如果所有类都堆在一起，就像把一万本书都扔在地上——根本找不到你要的。

包就是文件夹，用来分门别类地组织你的代码。Java 平台自身就用包来组织 API：

6.2 包的两大作用

6.3 Java API 文档——程序员的字典

Java 平台提供了海量的现成类库，被称为 API（Application Programming Interface，应用编程接口）。学会查阅 Java API 文档是每个 Java 开发者的必备技能。

JDK 8 API 文档地址：https://docs.oracle.com/javase/8/docs/api/

建议收藏这个地址——它将成为你编程生涯中用得最多的参考文档。

七、五大概念总结速查

🔥 获取完整源码 + 更多独家内容

关注公众号「IT探险家」，回复「OOP」获取本文完整代码 + Java 面向对象速查手册

💎 加入知识星球「IT探险家·进阶圈」，获取：系统学习路线 + 完整项目源码 + 专属答疑