【从零开始java学习|第十篇】面向对象
目录
一、面向对象介绍
二、类和对象
1. 类（Class）：对象的模板
2. 对象（Object）：类的实例
三、封装
1. 封装的概念
2. 封装的优势
四、就近原则和 this 关键字
1. 就近原则
2. this 关键字
五、构造方法
1. 构造方法的作用
2. 构造方法的特点
3. 默认构造方法
六、标准的 JavaBean 类
七、对象内存图（三种情况）
1. 单个对象的内存图
2. 两个对象的内存图
3. 两个引用指向同一对象
八、基本数据类型和引用数据类型（面向对象视角）
九、this 的内存原理
十、成员变量和局部变量
总结
一、面向对象介绍
面向对象编程（OOP）是一种以 "对象" 为核心的编程思想，它将现实世界中的事物抽象为程序中的 "对象"，通过对象之间的交互完成功能。
与面向过程的区别：
- 面向过程：关注 "步骤"，如 "先做什么，再做什么"（例：按步骤实现登录功能）
- 面向对象：关注 "对象"，如 "用户对象"" 登录界面对象 "，通过对象协作完成功能
面向对象三大特征：
- 封装：隐藏对象内部细节，只暴露必要接口
- 继承：实现类之间的代码复用
- 多态：同一行为的不同表现形式
优势：代码更易维护、扩展，更符合人类对现实世界的认知。
二、类和对象
1. 类（Class）：对象的模板
类是对同一类事物的抽象描述，包含这类事物的属性（数据）和方法（行为）。
// 类的定义：描述"学生"这类事物
public class Student {// 属性（成员变量）：学生的特征String name;int age;// 方法：学生的行为public void study() {System.out.println(name + "正在学习");}
}
2. 对象（Object）：类的实例
对象是类的具体 "实例"，是真实存在的个体。通过new关键字创建对象。
public class Test {public static void main(String[] args) {// 创建对象：类名 对象名 = new 类名();Student stu1 = new Student();// 给对象的属性赋值stu1.name = "张三";stu1.age = 18;// 调用对象的方法stu1.study(); // 输出：张三正在学习// 再创建一个对象（另一个实例）Student stu2 = new Student();stu2.name = "李四";stu2.study(); // 输出：李四正在学习}
}
类与对象的关系：类是模板，对象是根据模板创建的具体实例（如 "汽车图纸" 与 "具体的汽车"）。
三、封装
封装是面向对象的三大特征之一，此外还有继承和多态。封装的作用是在拿到一个需求之后，告诉我们如何正确的设计对象的属性和方法。
1. 封装的概念
封装是指隐藏对象的内部细节（如属性值），只通过公共方法对外提供访问和修改的接口。
实现方式：
- 用
private修饰属性（私有属性，仅本类可见） - 提供
public的getter（获取属性值）和setter（修改属性值）方法
public class Person {// 私有属性：外部不能直接访问private String name;private int age;// getter：获取namepublic String getName() {return name;}// setter：修改namepublic void setName(String n) {name = n; // 可在此处添加验证逻辑}// getter：获取agepublic int getAge() {return age;}// setter：修改age，添加合法性验证public void setAge(int a) {if (a > 0 && a < 150) { // 年龄必须在合理范围age = a;} else {System.out.println("年龄不合法");}}
}
2. 封装的优势
- 保护数据安全（如限制年龄范围）
- 隐藏实现细节（外部无需知道属性如何存储）
- 便于修改内部实现（不影响外部调用）
3. private关键字
- 是一个权限修饰符
- 可以修饰成员(成员变量和成员方法
- 被private修饰的成员只能在本类中才能访问
示例：
四、就近原则和 this 关键字
1. 就近原则
当方法中出现局部变量与成员变量同名时，优先使用局部变量（离引用位置更近）。
public class Dog {String name = "旺财"; // 成员变量public void bark() {String name = "小白"; // 局部变量System.out.println(name + "在叫"); // 输出：小白在叫（就近使用局部变量）}
}
2. this 关键字
this代表当前对象的引用，用于：
- 区分同名的局部变量和成员变量
- 调用本类的其他方法或构造方法
public class Cat {String name; // 成员变量// 用this区分局部变量和成员变量public void setName(String name) {this.name = name; // this.name指成员变量，name指局部变量}public void eat() {System.out.println(this.name + "在吃"); // this可省略（无同名局部变量时）}
}
五、构造方法
1. 构造方法的作用
初始化对象（给对象的属性赋初始值），在创建对象时自动调用。
2. 构造方法的特点
- 方法名与类名完全相同
- 没有返回值类型（连
void都不能写） - 不能被
static、final等修饰
public class Book {String title;double price;// 无参构造方法public Book() {System.out.println("创建了一本书");}// 带参构造方法：初始化时直接赋值public Book(String t, double p) {title = t;price = p;}
}// 调用构造方法
public class Test {public static void main(String[] args) {Book b1 = new Book(); // 调用无参构造Book b2 = new Book("Java编程", 59.9); // 调用带参构造}
}
3. 默认构造方法
- 如果类中没有定义任何构造方法，编译器会自动生成一个无参构造方法
- 如果手动定义了构造方法，默认无参构造会失效（如需使用需手动添加）
六、标准的 JavaBean 类
JavaBean 是一种规范的类，用于封装数据，遵循以下规则：
- 成员变量私有（
private） - 提供无参构造方法
- 提供
getter和setter方法 - 可根据需要重写
toString()（方便打印对象信息）
public class User {// 1. 私有成员变量private String username;private String password;private int age;// 2. 无参构造public User() {}// 3. 带参构造（可选）public User(String username, String password, int age) {this.username = username;this.password = password;this.age = age;}// 4. getter和setterpublic String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}// 5. 重写toString()（可选）@Overridepublic String toString() {return "User{username='" + username + "', age=" + age + "}";}
}
七、对象内存图（三种情况）
1. 单个对象的内存图
栈内存 堆内存
+----------+ +----------------+
| 引用变量 | | 对象（User） |
| u ------+----------> username: null |
+----------+ | password: null|| age: 0 |+----------------+
- 引用变量（
u）存于栈中，指向堆中的对象 - 对象的属性在堆中，有默认值（引用类型为
null，基本类型为对应默认值）
2. 两个对象的内存图
栈内存 堆内存
+----------+ +----------------+
| u1 ------+----------> username: "张三"|
+----------+ | age: 18 |
| u2 ------+----------+----------------+
+----------+ | username: "李四"|| age: 20 |+----------------+
- 两个引用变量指向堆中不同对象，属性各自独立
3. 两个引用指向同一对象
栈内存 堆内存
+----------+ +----------------+
| u1 ------+----------> username: "张三"|
+----------+ | age: 18 |
| u2 ------+----------+----------------+
+----------+
u1和u2指向同一对象，修改u1的属性会影响u2
八、基本数据类型和引用数据类型（面向对象视角）
| 类型 | 存储方式 | 在对象中的表现 |
|---|---|---|
| 基本数据类型 | 栈中直接存值 | 对象的属性值直接存在堆中 |
| 引用数据类型 | 栈中存地址，堆中存值 | 对象的属性存地址，指向另一对象 |
public class Person {int age; // 基本类型：值直接存在Person对象中String name; // 引用类型：存地址，指向堆中的字符串对象
}
九、this 的内存原理
this是当前对象的引用，本质上是方法的一个隐藏参数，在创建对象时自动绑定到该对象。
public class Car {String color;public void setColor(String color) {this.color = color; // this指向调用该方法的对象}
}// 调用时
Car c = new Car();
c.setColor("红色"); // 实际执行：setColor(c, "红色")，this就是c
内存中：this与对象的引用变量（如c）存储相同的地址，指向堆中的同一个对象。
十、成员变量和局部变量
| 区别 | 成员变量 | 局部变量 |
|---|---|---|
| 定义位置 | 类中，方法外 | 方法内、方法参数、代码块中 |
| 作用域 | 整个类 | 仅在定义的方法 / 代码块中 |
| 默认值 | 有默认值（如 int 为 0，对象为 null） | 无默认值，必须初始化后使用 |
| 内存位置 | 堆内存（对象中） | 栈内存（方法栈帧中） |
| 生命周期 | 随对象创建而存在，随对象销毁而消失 | 随方法调用而存在，随方法结束而消失 |
public class VariableDemo {int memberVar = 10; // 成员变量public void method() {int localVar = 20; // 局部变量System.out.println(memberVar + localVar);}
}
总结
面向对象编程是 Java 的核心思想，其核心是类和对象：类是模板，对象是实例。通过封装保护数据，利用构造方法初始化对象，遵循JavaBean 规范实现标准化封装。
理解this关键字、成员与局部变量的区别、数据类型的存储差异，以及对象在内存中的表现，是掌握面向对象编程的基础。这些概念为后续学习继承和多态奠定了重要基础。
如果我的内容对你有帮助，请点赞，评论，收藏。接下来我将继续更新相关内容！