在学习 Java 之前，我们编写的代码大多是面向过程的，核心在于'步骤'，逻辑耦合度高。而今天开始，我们将进入 Java 的灵魂——面向对象（OOP） 编程。它是企业开发的主流思想，核心是'对象'，万物皆对象。
一、初识面向对象
1.1 什么是面向对象？
在生活中，我们永远是找'能干活的东西'来做对应的事情，而不是自己一步步去实现：
- 要洗衣服 → 找【洗衣机】来洗
- 要聊天沟通 → 找【手机】来聊
- 要敲代码学习 → 找【电脑】来用
核心总结：
面向 → 寻找、找 对象 → 能帮我们干活的、具备特定功能的「东西」 面向对象编程 (OOP) → 拿对象来做对应的事情，核心是「找对象、用对象」
1.2 我们要学的两大核心内容
面向对象的学习分为两个阶段：
- 学会获取并使用已经存在的对象（比如
Scanner、Random）； - 学会自己设计对象，并创建对象来使用（本节课重点）。
二、设计对象并使用：类与对象
2.1 类和对象的关系
这是最基础也是最核心的概念。
✨ 类（class）→ 事物的「设计图/图纸」
类是用来描述一类具有共同特征和行为的事物的抽象概念，是一个模板。
- 特征 → 事物的属性/成员变量（一般是名词，如：手机的品牌、价格）
- 行为 → 事物的方法/成员方法（一般是动词，如：打电话、玩游戏）
✨ 对象（object）→ 事物的「具体实例/成品」
对象是类的具体体现，是根据类这个设计图，创建出来的实实在在的、能干活的东西。
- 比如：
Phone类是手机的设计图，根据这个图纸创建出的「小米手机、荣耀手机」就是具体的对象 - 比如：
Student类是学生的设计图，根据这个图纸创建出的「张三、李四」就是具体的对象
⚠️ 核心原则：在 Java 中，必须先设计类，才能创建并使用对象。没有设计图（类），永远造不出成品（对象）。
2.2 类的定义 & 对象的创建与使用
✅ ① 定义类的标准语法
public class 类名 {
// 1. 成员变量（属性/特征）：类中、方法外，描述事物的属性，名词为主
数据类型 变量名;
// 2. 成员方法（行为/功能）：描述事物的行为，动词为主，无 static 修饰
public void 方法名 () {
// 方法体
// 该事物能做的事情
}
}
✍️ 命名规范
- 类名：大驼峰命名法，首字母大写，见名知意，比如
Phone、Student。 - 成员变量：小驼峰命名法，首字母小写，比如
brand、price。 - 成员方法：小驼峰命名法，动词开头，比如
call()、playGame()。
✅ ② 创建对象的标准语法
类名 对象名 = new 类名 ();
// 举例：Phone p = new Phone ();
// 左边：Phone p → 声明一个 Phone 类型的变量 p
// 右边：new Phone () → 真正创建 Phone 对象，在内存中开辟空间
// = → 把对象的内存地址赋值给变量 p，p 就指向了这个对象
✅ ③ 对象的使用
创建对象后，我们就可以通过对象操作它的「属性」和「行为」：
- 访问/赋值成员变量：
对象名。成员变量名- 赋值：
p.brand = "小米"; - 取值：
System.out.println(p.brand);
- 赋值：
- 调用成员方法：
对象名。成员方法名 (参数)- 调用：
p.call();
- 调用：
2.3 完整代码示例
开发规范：Java 中分为「JavaBean 类」和「测试类」，各司其职。
✔ 示例 1：JavaBean 类 - Phone.java
public class Phone {
// 成员变量：属性（特征）
String brand; // 手机品牌
double price; // 手机价格
// 成员方法：行为（功能）
public void call () {
System.out.println("手机在打电话");
}
public void playGame () {
System.out.println("手机在玩游戏");
}
}
✔ 示例 2：测试类 - PhoneTest.java
public class PhoneTest {
public static void main (String [] args) {
// 1. 创建手机对象
Phone p = new Phone ();
// 2. 给对象的成员变量赋值
p.brand = "小米";
p.price = 1999.98;
// 3. 获取对象的成员变量值并打印
System.out.println(p.brand); // 输出：小米
System.out.println(p.price); // 输出：1999.98
// 4. 调用对象的成员方法
p.call(); // 输出：手机在打电话
p.playGame(); // 输出：手机在玩游戏
// ========== 再创建一个对象，互不影响 ==========
Phone p2 = new Phone ();
p2.brand = "荣耀";
p2.price = 3700.0;
System.out.println(p2.brand); // 输出：荣耀
System.out.println(p2.price); // 输出：3700.0
p2.call(); // 输出：手机在打电话
}
}
✅ 运行结果：每个对象都是独立的，修改 p 的属性不会影响 p2，这是对象的核心特性！
2.4 关键概念：JavaBean 类 & 测试类
- JavaBean 类：专门用来描述一类事物的类，只写属性和行为，永远不写 main 方法。纯描述，无业务逻辑。
- 测试类：专门用来测试 JavaBean 类的类，里面只有
main方法。在测试类中，可以创建 JavaBean 类的对象、给对象赋值、调用对象的方法。
2.5 类的定义注意事项
- 一个
.java源文件中，可以定义多个 class 类，但只能有一个类被 public 修饰； - 被
public修饰的类，类名必须和文件名完全一致； - 实际开发中，强烈建议一个文件只定义一个 class 类，可读性更高；
- 成员变量的默认值：整数为 0，小数为 0.0，布尔为 false，引用类型为 null。
2.6 开发技巧：如何设计一个类？
拿到需求，不知道怎么设计类？记住这个万能公式：
属性 → 找名词：从需求中提取描述事物的名词，就是成员变量 行为 → 找动词：从需求中提取描述事物的动词，就是成员方法
比如：设计一个 GirlFriend 类 → 名词：姓名、年龄、性别 → 属性；动词：吃饭、睡觉 → 行为。
三、封装
3.1 封装的核心思想
封装是 Java 面向对象的三大核心特征之首（封装、继承、多态）。
✨ 对象代表什么，就要封装对应的数据，并提供该数据对应的行为 ✨
简单理解：谁的属性，就归谁管；谁的行为，就归谁做，职责分明。
- 人画圆 → 画圆是圆的行为，不是人的行为 → 人调用圆的画圆方法
- 人关门 → 关门是门的行为，不是人的行为 → 人调用门的关门方法
3.2 封装的好处
- 让程序员学会自己设计合理的对象，职责分明，代码逻辑更清晰；
- Java 官方按照封装思想设计了大量的对象（JDK API），我们可以直接拿来用，降低学习成本；
- 封装可以保护成员变量，避免外部随意修改，提高代码的安全性；
- 提高代码的复用性和可维护性，修改内部逻辑不会影响外部调用。
3.3 private 关键字：封装的核心实现手段
要实现封装，必须用到 private 关键字，这是 Java 中最常用的权限修饰符。
✔ private 关键字的核心特点
private可以修饰成员变量和成员方法；- 被
private修饰的成员，只能在当前类中访问和使用，在其他类中完全不可见； private的权限范围：本类可见，外部类不可见，是 Java 中权限最小的修饰符。
✔ 为什么要用 private？
在没有封装之前，我们直接通过 对象名。成员变量 给属性赋值，外部可以随意修改属性的值，会导致数据不安全。比如：给 GirlFriend 的 age 赋值为 -18，这是非法数据，但代码不会报错。
而用 private 修饰成员变量后，外部无法直接访问，必须通过我们提供的方法来赋值和取值，我们可以在方法中添加数据校验逻辑，保证数据的合法性。
3.4 封装的标准步骤
当我们用 private 修饰成员变量后，外部无法访问，此时必须提供对应的访问方法：
- 用
private关键字修饰所有的成员变量，私有化属性； - 为每一个私有化的成员变量，提供一对
public修饰的方法：- setXxx(参数) 方法：给成员变量赋值，方法名必须是
set+ 变量名首字母大写 - getXxx() 方法：获取成员变量的值，方法名必须是
get+ 变量名首字母大写
- setXxx(参数) 方法：给成员变量赋值，方法名必须是
- 在
setXxx方法中，可以添加数据校验逻辑，保证数据的合法性； - 在
getXxx方法中，直接返回成员变量的值即可。
3.5 封装的完整代码示例
这是企业开发的标准写法。
✔ 示例 1：JavaBean 类 - GirlFriend.java
public class GirlFriend {
// 1. 私有化所有成员变量，封装属性
private String name;
private int age;
private String gender;
// 2. 为每个私有化的成员变量，提供对应的 get/set 方法
// name 的 set/get 方法
public void setName (String name) {
this.name = name;
}
public String getName () {
return name;
}
// age 的 set/get 方法 + 数据校验逻辑（核心）
public void setAge (int age) {
// 校验年龄是否合法：只允许 18~25 岁
if (age >= 18 && age <= 25) {
this.age = age;
} else {
System.out.println("年龄非法！请输入 18~25 之间的数字");
}
}
public int getAge () {
return age;
}
// gender 的 set/get 方法
public void setGender (String gender) {
this.gender = gender;
}
public String getGender () {
return gender;
}
// 成员方法：行为
public void sleep () {
System.out.println("女朋友在睡觉");
}
public void eat () {
System.out.println("女朋友在吃饭");
}
}
✔ 示例 2：测试类 - GirlFriendTest.java
public class GirlFriendTest {
public static void main (String [] args) {
// 创建对象
GirlFriend gf = new GirlFriend ();
// 调用 set 方法给属性赋值
gf.setName("小浔浔");
gf.setAge(18);
gf.setGender("女");
// 调用 get 方法获取属性的值并打印
System.out.println(gf.getName()); // 输出：小浔浔
System.out.println(gf.getAge()); // 输出：18
System.out.println(gf.getGender()); // 输出：女
// 调用成员方法
gf.eat(); // 输出：女朋友在吃饭
gf.sleep(); // 输出：女朋友在睡觉
// 测试非法数据：赋值年龄为 30
gf.setAge(30); // 输出：年龄非法！请输入 18~25 之间的数字
System.out.println(gf.getAge()); // 输出：0（默认值，未赋值成功）
}
}
✅ 运行结果：非法数据被拦截，数据安全性得到保障，这就是封装的魅力！
3.6 封装核心总结
private是权限修饰符，可修饰成员变量和成员方法；- 被
private修饰的成员，仅本类可见，外部类无法直接访问； - 封装的标准实现：私有化成员变量 + 提供
public的setXxx/getXxx方法； setXxx方法：负责给成员变量赋值，可加数据校验，无返回值，有参数；getXxx方法：负责获取成员变量的值，有返回值，无参数；- 封装的核心价值：保护数据安全，提高代码可维护性。
核心知识点总结
✅ 面向对象核心
- 面向对象编程：拿对象做事情，核心是「找对象、用对象」；
- 学习阶段：先使用已有对象，再自定义类创建对象。
✅ 类与对象核心
- 类是设计图，对象是具体实例，先有类后有对象；
- 类的组成：成员变量（属性，名词）+ 成员方法（行为，动词）；
- 对象的创建：
类名 对象名 = new 类名 ();； - 对象的使用：
对象名。属性赋值/取值，对象名。方法 ()调用行为； - JavaBean 类：描述事物，无 main 方法；测试类：测试对象，有 main 方法。
✅ 封装核心
- 封装思想：对象代表什么，就封装对应的数据和行为；
- 封装实现：
private私有化成员变量 +public的get/set方法； - 封装好处：数据安全、逻辑清晰、提高复用性和可维护性；
setXxx赋值 + 校验，getXxx取值，是封装的标准写法。
面向对象不是一门语法，而是一种编程思想。从面向过程到面向对象，是程序员思维的一次质的飞跃。这些内容会贯穿你整个 Java 学习生涯，所有的框架、项目、高级特性，都是基于面向对象的思想设计的。
很多同学初学面向对象会觉得抽象、迷茫，这是正常的。面向对象的思想，不是靠记，而是靠练：多写几个类，多创建几个对象，多体会封装的思想，慢慢的你就会发现，面向对象的代码比面向过程的代码更简洁、更优雅、更符合现实世界的逻辑。
下一篇我们会继续讲解面向对象的核心知识点：this 关键字、构造方法、标准 JavaBean 类，这些内容是封装的进阶，也是笔试面试的高频考点。
