← 课程目录 🚀 从零到一
📐 学习维度 阶段1 · 第3章 面向对象 🚀 从零到一 📚 课程目录 🏠 首页 🛤️ 学习路径

3.1 类与对象:图纸和房子

审校 2026-09-26 · 素材来源:乐字节基础讲义(底稿改写)
📑 本篇章节导航 (共14节,点击直达)
类是图纸,对象是房子new 背后干了三件事一个类,多个互不干扰的对象引用:手里拿的是钥匙,不是房子构造方法:交房前的装修static:属于图纸,不属于某栋房成员变量和局部变量:一个在房子里,一个在口袋里对象数组:一排钥匙挂墙上内存图:栈、堆、方法区各管一摊拿一个练手项目串起来null 的防身术方法该放进哪个类:行为归谁管踩坑清单一句话总结

要记录一个学生,你写了两个变量:姓名、年龄。要记录三个学生呢?六个变量?三十个呢?变量散落一地,改一个学生的年龄都可能找错人。类就是为解决这个问题而生:把「一个学生」的数据和操作打包在一起。

类是图纸,对象是房子

类(class)是一张图纸,规定有什么、能干什么;对象(object)是按图纸盖出来的房子,真正住人。图纸只有一张,房子可以盖一栋小区。


// 图纸:学生有名字和年龄,会自我介绍
class Student {
    String name;   // 属性:房子里的房间
    int age;

    void introduce() {   // 方法:房子能提供的功能
        System.out.println("我是" + name + "," + age + "岁");
    }
}

Student s1 = new Student();   // 盖第一栋
s1.name = "张三";
s1.introduce();               // 我是张三,0岁

new 背后干了三件事

new Student() 这一行看似简单,JVM 实际做了三步:

1. 加载类:第一次用到 Student,把它的信息读进内存

2. 分配堆内存:在堆里划一块空间,属性给默认值(int 是 0,引用是 null)

3. 执行构造方法:有机会给属性赋初值

所以 s1.age 不赋值也能打印——默认值 0 已经就位。

一个类,多个互不干扰的对象


Student s1 = new Student();
Student s2 = new Student();
s1.name = "张三";
s2.name = "李四";
s1.introduce();   // 张三
s2.introduce();   // 李四,s1 的修改不影响 s2

每个对象在堆里有自己的地盘,各改各的属性,互不串门。这是面向对象最基本的安全感。

引用:手里拿的是钥匙,不是房子

Student s1 = new Student() 里,变量 s1 存的不是房子本身,而是钥匙(引用,指向堆里那块内存)。钥匙可以有不止一把:


Student s2 = s1;    // 复制了一把钥匙,不是盖了新房子
s2.name = "王五";
s1.introduce();     // 王五——两把钥匙开同一扇门

理解钥匙,三个常见现象就都通了:

构造方法:交房前的装修

构造方法名字和类名相同、没有返回值,new 的时候自动执行,专门用来初始化:


class Student {
    String name;
    int age;

    Student() {                  // 不写也有默认的,写了默认的就没了
        this("无名", 0);          // 借道另一个构造方法
    }

    Student(String name, int age) {   // 重载:多种装修方案
        this.name = name;        // this = 当前这栋房子
        this.age = age;
    }
}

Student s = new Student("张三", 18);   // 一步到位,不给默认值可乘之机

this 指当前对象自己。参数名和属性重名时,this.name 是属性、name 是参数,靠它区分。

static:属于图纸,不属于某栋房

用 static 修饰的成员属于类本身(图纸),所有对象共享一份:


class Student {
    static int count = 0;        // 全校学生数,大家共用这个数
    String name;

    Student(String name) {
        this.name = name;
        count++;                 // 每盖一栋,计数 +1
    }
}

new Student("张三");
new Student("李四");
System.out.println(Student.count);   // 2,用类名访问,不依赖任何对象

内存画面:普通属性每栋房一份,static 属性只有一份,挂在图纸旁边。

成员变量和局部变量:一个在房子里,一个在口袋里

属性(成员变量)写在类里、方法外,住在对象里,天生有默认值;局部变量写在方法里,住在栈上,不给初值就不让读。两者重名时按就近原则,局部变量把属性遮住,想摸到属性就得写 this.name。生命周期也不同:局部变量方法一结束就消失,成员变量跟着对象活,对象被 GC 收走才算完。

对象数组:一排钥匙挂墙上

存 30 个学生怎么办?数组的每个格子装一把引用:


Student[] all = new Student[30];   // 30 个空位,初始全是 null
all[0] = new Student("张三", 18);
all[1] = new Student("李四", 19);
for (Student s : all) {
    if (s != null) s.introduce();  // 判空再调,防空指针
}

注意 new Student[30] 只造了 30 个空位,没有造 30 个学生——元素默认是 null,要逐个 new 才有房子。这个组合以后天天用:列表页的 30 条商品、购物车里的 N 件货,底层都是对象数组。

内存图:栈、堆、方法区各管一摊

把这篇的知识点放上内存地图,三块各司其职:

拿 main 走一遍:main 进栈,声明 s1;new Student() 在堆里盖房,钥匙放进 s1;调 introduce(),方法进栈,拿 s1 的钥匙找到房子读 name;方法结束弹栈。最后 main 结束,房子没了引用,GC 收走。

所有关于「值传递」「引用拷贝」的疑惑,画一遍栈堆图就全通了。以后被问 String、集合底层,第一反应都应该是画图——图不会骗人,直觉会。

拿一个练手项目串起来

写个控制台版「学生管理」:Student 类放姓名、年龄、成绩,对象数组存全体,循环菜单做增删改查,每个功能拆成方法。这个小东西会用上本篇全部知识点:类、构造、对象数组、判空、遍历、方法拆分。别小看控制台程序,它的骨架就是「数据 + 菜单循环 + 功能方法」——以后换上接口和数据库,长成的就是真正的系统。

null 的防身术

null 表示「还没指向任何对象」。拿着 null 调方法就是空指针异常,Java 天字第一号报错。三个防身动作从现在养成:调用前判断 s != null;比较两个可能为 null 的对象用 Objects.equals(a, b),它内部替你兜底;方法要返回集合时,宁可返回空集合也不返回 null——空集合能遍历,null 一遍历就炸。

排查空指针反过来走三问:报错指向哪一行?那一行里哪个变量是 null?谁本来该给它赋值却没赋?顺着这条线找,八九不离十。

方法该放进哪个类:行为归谁管

新手常把所有方法塞进 main 所在的类。更自然的思考是「这事归谁管」:学生自己会介绍自己,introduce 放 Student;班级统计平均分,放 ClassRoom,因为它管着一排学生。行为挂在数据旁边,就是面向对象和面向过程最朴素的分界线。

写新功能前先问一句「这个操作的数据在谁手里」,方法就放那个类里。这个直觉以后会长成「领域模型」之类的大词,但根子就是现在这一问。

踩坑清单

一句话总结

类是图纸、对象是按图纸盖的房子,变量里拿的只是钥匙;构造方法负责交房前装修,static 挂在图纸上大家共用。