Java基础——类和对象

学习目标

1. 学会定义符合规范的 Java 类
2. 掌握类的实例化（创建对象）方法
3. 掌握通过对象引用访问对象属性 / 方法的规则
4. 理解 this 引用的含义和使用场景
5. 理解构造方法的作用、特性及重载
6. 掌握静态 / 非静态成员（方法 / 变量）的调用规则
7. 理解代码块的分类、作用及执行顺序

一、先搞懂：面向过程 vs 面向对象

1. 核心区别

1. 面向过程：关注 “做事的步骤”，一步一步按流程来。
2. 面向对象：关注 “参与的角色（对象）”，让对象之间协作完成事情。

2. 举个栗子：洗衣服

1. 面向过程：
   1. 接水 → 2. 放洗衣粉 → 3. 放衣服 → 4. 搓洗 → 5. 漂洗 → 6. 拧干 → 7. 晾晒（全程盯着 “步骤”，少一步都不行）
2. 面向对象：角色（对象）：人、衣服、洗衣粉、洗衣机。分工：人把衣服和洗衣粉放进洗衣机 → 洗衣机完成清洗 → 人把衣服拿出来晾晒。（全程盯着 “谁来做”，不用关心洗衣机内部怎么转）

3. 面向对象核心三步

找对象（确定参与的角色）→ 创建对象（给角色赋予属性）→ 使用对象（让角色做事）

二、类：对象的 “说明书”

1. 认识类

类是描述对象 “长什么样、能做什么” 的模板，比如：

• “学生类”：描述学生有姓名、年龄（属性），能学习、考试（行为）；
• “洗衣机类”：描述洗衣机有容量、品牌（属性），能洗衣服、脱水（行为）。
• 类比：类 = 月饼模子，对象 = 用模子压出来的月饼（同一个模子能做多个月饼）。

2. 定义类（新手必看规则）

核心规则

1. 类名用大驼峰：每个单词首字母大写（如Student、WashingMachine）；
2. 成员（属性 / 方法）前统一写public（暂时记：表示 “公开可访问”）；
3. 方法不加static（暂时记：加了就是 “类专属”，没加是 “对象专属”）。

实战：定义学生类

// 学生类（模板） public class Student { // 成员变量（属性：描述对象的特征） public String name; // 姓名 public int age; // 年龄 public double score;// 成绩 // 成员方法（行为：描述对象能做的事） public void study() { System.out.println(name + "正在学习"); } public void exam() { System.out.println(name + "参加考试，成绩：" + score); } }

3. 类的实例化（用模板造对象）

“实例化” 就是用类创建具体对象，好比用月饼模子做出月饼。

语法 & 示例

public class Test { public static void main(String[] args) { // 1. new关键字：创建对象（实例化） Student stu1 = new Student(); // 2. . 符号：访问对象的属性/方法 stu1.name = "张三"; stu1.age = 18; stu1.score = 90.5; stu1.study(); // 输出：张三正在学习 stu1.exam(); // 输出：张三参加考试，成绩：90.5 // 3. 同一个类可以创建多个对象 Student stu2 = new Student(); stu2.name = "李四"; stu2.age = 19; stu2.study(); // 输出：李四正在学习 } }

三、前置知识：三种变量

完整代码示例

// 演示三种变量的区别 public class VariableDemo { // 1. 静态变量（类变量）：类中、方法外，加static // 特点：属于类，所有对象共享，生命周期随类 public static String school = "北京大学"; // 2. 成员变量（实例变量）：类中、方法外，无static // 特点：属于对象，每个对象独有，创建对象时初始化 public String name; // 成员方法：演示三种变量的访问方式 public void showInfo(int age) { // 3. 局部变量：方法内部（包括方法参数） // 特点：仅方法内可用，必须手动初始化 int score = 95; // ========== 访问变量 ========== // ① 访问局部变量：直接用变量名 System.out.println("局部变量 age = " + age); System.out.println("局部变量 score = " + score); // ② 访问成员变量：this.变量名（或 对象.变量名） // this代表当前对象，这里就是调用showInfo的对象 System.out.println("成员变量 name = " + this.name); // ③ 访问静态变量：类名.变量名（推荐） 或 this.变量名（不推荐） System.out.println("静态变量 school = " + VariableDemo.school); } // 主方法：测试入口 public static void main(String[] args) { // ========== 测试成员变量 ========== // 创建第一个对象 VariableDemo stu1 = new VariableDemo(); stu1.name = "张三"; // 成员变量：每个对象单独赋值 stu1.showInfo(18); // 传入局部变量age=18 // 创建第二个对象 VariableDemo stu2 = new VariableDemo(); stu2.name = "李四"; // 成员变量：和stu1的name互不影响 stu2.showInfo(19); // 传入局部变量age=19 // ========== 测试静态变量 ========== // 静态变量：通过类名修改，所有对象都会受影响 VariableDemo.school = "清华大学"; System.out.println("\n修改静态变量后："); stu1.showInfo(18); // 此时stu1的school也变成了清华大学 stu2.showInfo(19); // ========== 局部变量注意事项 ========== // 错误示例：局部变量未初始化不能用（注释掉才能运行） // int num; // System.out.println(num); // 编译报错：变量num可能尚未初始化 } }

运行结果

局部变量 age = 18 局部变量 score = 95 成员变量 name = 张三 静态变量 school = 北京大学 局部变量 age = 19 局部变量 score = 95 成员变量 name = 李四 静态变量 school = 北京大学 修改静态变量后： 局部变量 age = 18 局部变量 score = 95 成员变量 name = 张三 静态变量 school = 清华大学 局部变量 age = 19 局部变量 score = 95 成员变量 name = 李四 静态变量 school = 清华大学

核心区别解读

关键易错点总结

1. 局部变量：方法里的临时变量，用完就丢，必须手动赋值（比如age是方法参数，调用时传值才初始化）；
2. 成员变量：每个对象的“专属属性”，比如张三和李四的name互不影响；
3. 静态变量：类的 “共享属性”，修改一次所有对象都变（比如school从北大改成清华后，所有学生的学校都变了）；
4. 静态方法（如main）中不能直接访问成员变量（因为成员变量属于对象，静态方法不依赖对象），但可以直接访问静态变量。

四、this 引用：对象的 “身份证”

1. 为什么需要 this？

场景 1：形参名和成员变量名重名，分不清谁是谁

// 不好的写法：name到底是形参还是成员变量？ public void setName(String name) { name = name; // 错误：把形参赋值给形参，成员变量没变化 } // 正确写法：this.name = 成员变量，name = 形参 public void setName(String name) { this.name = name; }

场景 2：多个对象调用同一个方法，方法要知道 “服务谁”

1. 比如 stu1 和 stu2 都调用study()，this 会自动指向调用方法的对象（stu1 调用时 this=stu1，stu2 调用时 this=stu2）。

2.this 的核心特性

1. this 指向调用当前方法的对象；
2. 只能在 “成员方法” 中用；
3. 是成员方法的 “隐藏参数”，编译器自动传递，不用手动写。

五、对象的构造与初始化

1. 重载：方法的 “同名不同参”

好比去餐厅点餐：“来份炒饭”（无参）、“来份加蛋的炒饭”（一个参数）、“来份加蛋加肠的炒饭”（两个参数）—— 都是 “炒饭”，只是参数不同。

// 重载示例：方法名相同，参数个数/类型不同 public class Student { public void eat() { System.out.println("吃饭"); } public void eat(String food) { System.out.println("吃" + food); } }

2. 构造方法：对象的 “出生证明”

创建对象时自动调用，给对象初始化属性，一生只调用一次（好比人只能出生一次）。

构造方法规则

1. 名字必须和类名完全一样；
2. 没有返回值（连 void 都不能写）；
3. 创建对象时编译器自动调用，对象生命周期内只调一次；
4. 可以重载（多个构造方法，参数不同）；
5. 不手动定义的话，编译器自动生成无参构造方法；
6. 构造方法中可通过this(...)调用其他构造方法（必须是第一条语句）；
7. 绝大多数用 public 修饰，特殊场景（单例模式）用 private。

示例：构造方法的使用

public class Student { public String name; public int age; // 无参构造（编译器自动生成，写了就用自己的） public Student() { System.out.println("无参构造被调用"); } // 有参构造（重载） public Student(String name, int age) { this.name = name; // 用this区分变量 this.age = age; System.out.println("有参构造被调用"); } } // 测试 public class Test { public static void main(String[] args) { Student stu1 = new Student(); // 调用无参构造 Student stu2 = new Student("张三", 18); // 调用有参构造 System.out.println(stu2.name); // 输出：张三 } }

3. 默认初始化：为什么成员变量不用手动赋值？

局部变量是 “临时草稿纸”，不用就丢，所以必须手动赋值；而成员变量是对象的 “专属特征”，JVM 创建对象时会自动给成员变量赋默认值：int=0、String=null、boolean=false（好比买新手机，出厂就自带默认设置）。

4. 就地初始化：定义时直接赋值

public class Student { public String name = "未知姓名"; // 就地初始化 public int age = 18; // 就地初始化 }

六、封装：给对象 “套壳子”

1. 封装的概念

把对象的属性和方法 “打包”，隐藏内部细节，只对外暴露有限接口（好比手机：我们只用屏幕和按键，不用关心内部电路板怎么工作）。

2. 访问限定符：控制 “可见性”

Java 用 4 种限定符控制谁能访问类 / 属性 / 方法：

3. 包：类的 “文件夹”

1. 包的作用

1. 管理类：把相关的类放在同一个包（好比把 “厨具” 放厨房、“衣服” 放衣柜）；
2. 避免重名：不同包可以有同名类（好比 “张三（一班）” 和 “张三（二班）” 不冲突）。

2. 常用操作

1. 导入包：import java.util.Scanner;（用别人写好的类）；
2. 自定义包：
   1. IDEA 中右键 src → 新建 → 包 → 输入包名（如com.example.student）；
   2. 类文件最上方会自动生成package com.example.student;；
   3. 包名规则：公司域名颠倒（如百度域名www.baidu.com→ 包名com.baidu.xxx）。

七、static 成员：类的 “共享资源”

1. static 修饰成员变量（静态变量）

属于类，不是某个对象，所有对象共享（好比班级的 “班名”：所有学生的班名都一样，不用每个学生单独存）。

示例

public class Student { public String name; // 成员变量：每个学生都不一样 public static String school = "北京大学"; // 静态变量：所有学生共享 public void show() { System.out.println(name + "，学校：" + school); } } // 测试 public class Test { public static void main(String[] args) { Student stu1 = new Student(); stu1.name = "张三"; stu1.show(); // 输出：张三，学校：北京大学 Student stu2 = new Student(); stu2.name = "李四"; // 静态变量推荐用“类名.变量名”访问 Student.school = "清华大学"; stu2.show(); // 输出：李四，学校：清华大学 stu1.show(); // 输出：张三，学校：清华大学（所有对象共享，一个改全改） } }

2. static 修饰成员方法（静态方法）

属于类，不用创建对象就能调用（好比计算器的 “加法功能”：不用先造一个计算器对象，直接用）。

核心规则

1. 静态方法中不能直接用非静态成员（变量 / 方法），要用必须先 new 对象；
2. 非静态方法中可以直接用静态成员；
3. 推荐用 “类名。方法名” 调用（如Math.random()）。

核心调用规则（重点）

1. 通过对象引用调用：用于非静态成员（变量 / 方法）；
2. 通过类名调用：用于静态成员（变量 / 方法）（推荐）。
3. 静态方法中不能用任何非静态成员（变量 / 方法）：要用必须 new 对象，再通过对象访问；
4. 非静态方法中可直接用静态成员（变量 / 方法）；
5. 核心本质：静态的不依赖于对象，属于类，不属于对象！！！

3. static 成员的初始化

1. 就地初始化：public static int count = 0;；
2. 静态代码块：专门初始化静态变量，只执行一次（类加载时执行）。

八、代码块：初始化的 “补充手段”

用{}包裹的代码，按位置 / 修饰符分 3 类：

执行顺序：静态代码块 → 构造代码块 → 构造方法

public class Student { // 静态代码块 static { System.out.println("静态代码块执行"); } // 构造代码块 { System.out.println("构造代码块执行"); } // 构造方法 public Student() { System.out.println("构造方法执行"); } } // 测试：创建两个对象 public class Test { public static void main(String[] args) { Student stu1 = new Student(); Student stu2 = new Student(); } } // 输出： // 静态代码块执行（只执行一次） // 构造代码块执行 // 构造方法执行 // 构造代码块执行 // 构造方法执行

总结

1. 面向对象核心：找对象→创对象→用对象，类是模板，对象是具体实例；
2. this 是对象的 “身份证”，指向调用当前方法的对象，解决变量重名和对象识别；
3. 构造方法是对象 “出生凭证”，一生只调一次，可重载，支持 this 调用其他构造；
4. 封装是 “藏细节、露接口”，靠访问限定符控制可见性，包是类的 “文件夹”；
5. 静态成员属于类、所有对象共享，静态方法不能直接用非静态成员；
6. 代码块执行顺序：静态（类加载）→ 构造（创对象）→ 构造方法。