一、面向对象思想入门（视频核心导入）
1. 两种编程思想对比（视频重点强调）
Java是纯面向对象编程语言（OOP），核心是“找对象、用对象、造对象”，与面向过程思想对比清晰，视频中用“洗衣服”案例举例，便于理解：
- 面向过程（POP） ：关注“步骤和流程”，一步一步执行，亲力亲为。比如洗衣服：拿衣服→放水→放洗衣液→搓洗→漂洗→拧干→晾晒，每一步都要自己实现。
- 面向对象（OOP） ：关注“对象和交互”，找能完成对应功能的对象，让对象做事。比如洗衣服：找“洗衣机”（对象），把衣服交给洗衣机，洗衣机（对象）自己完成搓洗、漂洗等操作，无需关注内部细节。
核心区别：面向过程关注“怎么做”，面向对象关注“谁来做”；面向过程适合简单业务，面向对象适合复杂、可扩展的业务开发。
2. 面向对象核心概念
面向对象的核心是“类”和“对象”，两者是模板与实例的关系，类比“图纸和房子”：
- 对象：现实世界中具体的事物/实体，有自己的“属性”（特征）和“方法”（行为）。比如：具体的一个人、一辆车、一台洗衣机。
- 类：对一类具有相同属性和方法的对象的抽象描述，是创建对象的“模板”。比如：“人类”是所有具体的人的抽象，“洗衣机类”是所有具体洗衣机的抽象。
类与对象的关系：类是抽象的、没有实体的；对象是类的具体实例，一个类可以创建多个对象（比如一个“人类”可以创建“张三”“李四”两个具体对象）。
3. 面向对象三大特征
核心定义：
- 封装：把对象的属性和方法打包在一起，隐藏内部细节，只对外暴露访问接口（比如洗衣机，我们只需要按按钮，不需要知道内部怎么转动）。
- 继承：一个类（子类）可以继承另一个类（父类）的属性和方法，减少重复代码（比如“学生类”可以继承“人类”的姓名、年龄属性）。
- 多态：同一行为，在不同对象上有不同的表现（比如“吃饭”，人用筷子吃，动物用嘴巴吃）。
二、类与对象的核心语法（视频重点代码演示）
1. 类的定义
类是创建对象的模板，定义类时，必须明确类的“属性”（成员变量）和“方法”（成员方法），语法格式严格遵循视频要求：
// 修饰符：基础阶段只学public，代表公共访问
public class 类名 {
// 1. 成员变量（属性）：描述类的特征，直接定义在类中、方法外
数据类型 变量名; // 未初始化，JVM会赋默认值
数据类型 变量名 = 初始值; // 可直接初始化
// 2. 成员方法（行为）：描述类的功能，无static修饰（视频重点强调：区别于之前的静态方法）
方法返回值类型 方法名(参数列表) {
方法体; // 具体执行逻辑
return 返回值; // 有返回值必须写，无返回值写void且可省略return
}
}
命名规范（视频强调） ：类名必须遵循“大驼峰命名法”，首字母大写，后续每个单词首字母也大写，见名知意，比如Person、Student、WashingMachine，不能用拼音或关键字。
视频示例：Person类
// 人类：抽象描述人的属性和行为
public class Person {
// 成员变量（属性）：姓名、年龄、性别
String name; // 未初始化，默认值null
int age; // 默认值0
String gender; // 默认值null
// 成员方法（行为）：说话、吃饭
public void speak() {
// 直接使用成员变量
System.out.println(name + "在说话");
}
public void eat(String food) {
System.out.println(name + "在吃" + food);
}
}
2. 对象的创建与使用
类只是模板，必须通过“实例化”创建具体对象，才能使用类的属性和方法，视频中明确步骤：创建对象→操作属性→调用方法。
（1）创建对象语法（视频固定写法）
// 格式：类名 对象名 = new 类名();
Person p1 = new Person(); // 创建Person类的对象p1
视频讲解：new关键字的作用是“在堆内存中创建对象”，为成员变量分配默认值；对象名（p1）是栈内存中的引用，指向堆内存中的具体对象。
（2）操作对象的属性和方法
通过“对象名.属性名”访问/赋值成员变量，通过“对象名.方法名(参数)”调用成员方法，视频代码示例：
public class TestPerson {
public static void main(String[] args) {
// 1. 创建对象
Person p1 = new Person();
// 2. 为对象的属性赋值（修改默认值）
p1.name = "张三";
p1.age = 20;
p1.gender = "男";
// 3. 访问对象的属性
System.out.println("姓名：" + p1.name); // 输出：姓名：张三
System.out.println("年龄：" + p1.age); // 输出：年龄：20
// 4. 调用对象的方法
p1.speak(); // 输出：张三在说话
p1.eat("米饭"); // 输出：张三在吃米饭
// 5. 创建第二个对象（与p1相互独立）
Person p2 = new Person();
p2.name = "李四";
p2.eat("面条"); // 输出：李四在吃面条
}
}
（3）成员变量的默认值
创建对象时，若未给成员变量赋值，JVM会自动分配默认值，和数组元素默认值一致，视频中总结表格：
| 数据类型 | 默认值 |
|---|---|
| 整数型（int、long等） | 0 |
| 浮点型（float、double等） | 0.0 |
| 布尔型（boolean） | false |
| 字符型（char） | \u0000（空字符，控制台不显示） |
| 引用类型（String等） | null |
3. 局部变量与成员变量的区别
| 对比维度 | 成员变量（类中、方法外） | 局部变量（方法内、参数） |
|---|---|---|
| 定义位置 | 类的内部，所有成员方法外部 | 方法体内部、参数列表、代码块内 |
| 内存位置 | 堆内存（跟随对象） | 栈内存（跟随方法） |
| 默认值 | 有JVM分配的默认值 | 无默认值，必须显式赋值才能使用 |
| 作用域 | 整个类，所有成员方法都能访问 | 仅在定义的方法/代码块内有效 |
三、封装（视频核心重点，必掌握）
1. 封装的定义
封装就是“隐藏内部细节，对外暴露接口”，视频中用“手机”举例：我们使用手机时，只需要按屏幕（接口），不需要知道手机内部的芯片、线路怎么工作；对应到Java中，就是把对象的属性隐藏，不让外部直接访问，通过专门的方法访问/修改属性。
2. 封装的实现步骤
- 属性私有化：用private修饰成员变量，让成员变量只能在当前类内部访问，外部无法直接操作（视频强调：private是封装的核心关键字）。
- 提供getter方法：用于获取私有化的属性值，方法名固定格式：public 数据类型 get属性名()（布尔型特殊，用is开头）。
- 提供setter方法：用于修改私有化的属性值，方法名固定格式：public void set属性名(数据类型 参数)，可在方法中添加数据校验，保证数据安全。
视频示例：Person类封装
public class Person {
// 1. 属性私有化（private修饰）
private String name;
private int age;
private boolean isStudent; // 布尔型属性
// 2. getter方法：获取属性值
public String getName() {
return name;
}
public int getAge() {
return age;
}
// 布尔型属性的getter方法：用is开头（视频重点强调）
public boolean isStudent() {
return isStudent;
}
// 3. setter方法：修改属性值，添加数据校验
public void setName(String name) {
// this关键字：区分成员变量和局部变量（视频重点讲解）
this.name = name;
}
public void setAge(int age) {
// 数据校验：年龄不能小于0或大于150（视频演示的校验逻辑）
if (age >= 0 && age <= 150) {
this.age = age;
} else {
System.out.println("年龄输入无效，默认赋值18");
this.age = 18;
}
}
public void setStudent(boolean student) {
isStudent = student;
}
// 成员方法
public void speak() {
System.out.println(name + "今年" + age + "岁");
}
}
3. this关键字
视频中明确this的核心作用，只有1个：区分成员变量和局部变量（当方法的形参名和成员变量名相同时，必须用this.成员变量名表示当前对象的属性）。
补充：this代表“当前对象的引用”，只能在成员方法中使用，不能在静态方法中使用（视频强调：后续会详细讲解静态方法）。
4. 封装的使用
封装后，外部不能直接通过“对象名.属性名”访问属性，只能通过getter/setter方法，视频代码示例：
public class TestPerson {
public static void main(String[] args) {
Person p = new Person();
// 错误：不能直接访问private属性（编译报错）
// p.age = -20;
// 正确：通过setter方法修改属性，触发数据校验
p.setAge(-20); // 输出：年龄输入无效，默认赋值18
p.setName("张三");
p.setStudent(true);
// 正确：通过getter方法获取属性值
System.out.println(p.getName()); // 张三
System.out.println(p.getAge()); // 18
System.out.println(p.isStudent()); // true
p.speak(); // 张三今年18岁
}
}
四、构造方法
1. 构造方法的定义
构造方法是类的特殊方法，专门用于创建对象时初始化属性，视频中强调：只要用new关键字创建对象，就会自动调用构造方法，无需手动调用。
2. 构造方法的语法规则
- 方法名必须与类名完全一致（包括大小写），比如Person类的构造方法名只能是Person。
- 没有返回值类型，甚至连void都不能写（视频重点强调：区别于普通方法）。
- 修饰符：基础阶段只用public，和类的修饰符一致。
- 方法体中可以编写初始化逻辑，为成员变量赋值。
3. 构造方法的分类
（1）无参构造方法
没有参数的构造方法，视频中强调：若类中没有手动定义任何构造方法，JVM会自动生成一个默认的无参构造（空方法体）；若手动定义了构造方法，默认无参构造会被覆盖（易错点）。
// 无参构造方法（手动编写）
public Person() {
// 初始化属性，可省略（JVM会赋默认值）
this.name = "未知姓名";
this.age = 18;
}
（2）有参构造方法
带有参数的构造方法，用于创建对象时直接为属性赋值，无需再调用setter方法，视频示例：
// 有参构造：为姓名、年龄赋值
public Person(String name, int age) {
this.name = name;
this.age = age; // 可添加数据校验
}
// 有参构造：为所有属性赋值（构造方法重载）
public Person(String name, int age, boolean isStudent) {
this.name = name;
this.age = age;
this.isStudent = isStudent;
}
4. 构造方法的使用
创建对象时，根据传入的参数个数、类型，自动匹配对应的构造方法（构造方法重载），视频代码示例：
public class TestPerson {
public static void main(String[] args) {
// 调用无参构造
Person p1 = new Person();
p1.speak(); // 未知姓名今年18岁
// 调用带2个参数的有参构造
Person p2 = new Person("李四", 22);
p2.speak(); // 李四今年22岁
// 调用带3个参数的有参构造
Person p3 = new Person("王五", 25, true);
System.out.println(p3.getName() + "是否是学生：" + p3.isStudent());
}
}
5. 构造方法的注意事项
- 构造方法可以重载（和普通方法重载规则一致）：方法名相同，参数列表不同（个数、类型、顺序）。
- 手动定义构造方法后，默认无参构造会消失，若需要用无参创建对象，必须手动编写无参构造（视频重点强调，避免编译报错）。
- 构造方法不能手动调用，只能在new对象时由JVM自动调用（比如p1.Person(); 编译报错）。
- 可以用this(参数)在一个构造方法中调用本类的其他构造方法，必须写在构造方法的第一行（视频简要提及，后续详细讲解）。
五、视频总结与课后注意事项
- 面向对象基础核心是“类和对象”，类是模板，对象是实例，记住“new关键字创建对象”。
- 封装的核心是private修饰属性，提供getter/setter方法，this关键字区分成员变量和局部变量。
- 构造方法用于初始化对象，无参、有参均可，手动定义构造方法必须补全无参构造。
- 课后练习：编写Student类，实现封装，编写无参、有参构造，测试类中创建对象并使用（视频要求）。
