类与对象一文讲透：从饼干模具到代码实战，新手也能秒懂

我教编程这些年，遇到最多的一句话就是“类和对象我背了八百遍，一写代码就懵”。其实这事不怪你，因为很多教材把“类 Class”讲得像在背法律条文：“类是现实世界事物的抽象，是具有相同属性和行为的对象的集合……”你读完了，脑子里只剩下“抽象”两个字，更晕了。

我用大白话给你翻译一下：类就是一张图纸，对象是按图纸造出来的那个真东西。 就这么简单。这篇文章不跟你绕弯子，我会用模具、饼干、咖啡馆、学生档案这些生活里随处可见的例子，把类 Class 和对象彻底讲明白。不管你是刚翻开编程书的新手，还是学了一个学期还在跟 this、new、self 搏斗的同学，看完这篇，你应该能松一口气。

1. 先从生活里找“类”：你真的天天都在用

很多人觉得“类”是编程里才有的高深玩意儿，其实你生活里早就在用了。想想饼干模具：一套模具是星星形状的，你用面团一压，出来一块星星饼干；再压一次，又出来一块一模一样的星星饼干。那块模具既不是第一块饼干，也不是第二块饼干，但它规定了所有星星饼干的共同点——大小、形状、花边。饼干模具就是类，每一块被压出来的饼干就是对象。

再举个更贴近日常的例子。奶茶店的菜单上写着“珍珠奶茶，20元，可加冰、可选糖度”，这行字贴在墙上，你看半天也不会喝到嘴里。只有你点单之后，店员一通操作，端出那杯加了冰、三分糖的珍珠奶茶，这才是一杯能喝的“对象”。菜单是类，每一杯按菜单做出来的奶茶，就是对象。

1.1 模具与饼干：最容易被记住的一组比喻

为什么说模具和饼干的比喻最好用？因为它把“类”的两个关键特点都讲清楚了。

第一个特点：类规定了对象“长什么样”。如果模具是圆的，你不可能压出一块方形的饼干。放到代码里就是：类里定义了属性，那这个类创建出来的每个对象，都得有这些属性。你写了一个“学生”类，里面有学号、姓名、成绩，那么系统里就不可能出现一个没有学号的“学生”对象，至少形态上它必须为你留出这个位置。

第二个特点：类只负责规定，不负责具体的“内容”。模具本身不是饼干，菜单本身不能喝。类也一样，它只是模板，你往属性里填不同的值，就得到一个个不同的对象。张三是学生类的对象，李四也是学生类的对象，但张三的分数是95，李四的分数是72，数据完全不同，可他们拥有相同的结构。

1.2 为什么有“类”会让写代码更轻松

你可能会问：如果只是少写几行重复定义，好像也没那么神？那我把真实项目里的场景说得再直白一点。

假设你做一个学校管理系统，有三千个学生。没有类的做法是：每个学生的信息你都单独开几个变量，名字叫 student1_name、student1_score、student2_name、student2_score……三千个学生得写一万多个变量，代码乱成一锅粥，改个需求你能加班到天亮。而有了类之后，你只需要写一个“学生”类，然后在需要时通过它不断创建新对象，代码量成倍减少，结构还特别清爽。

更重要的是可维护性。后来学校说要增加一个“家长联系方式”字段，没有类的话，你得去所有学生变量的位置一处一处加；有类的话，80% 的改动都集中在类定义这一处，其他地方几乎不用碰。这就是“统一模板”带来的好处，也是工程上把代码组织成类的根本原因：把重复的东西收拢起来，把变化的东西留给对象。

2. 对象是“活”的那个：类负责规定，对象负责存在

类只是“规定”，真正在程序里干活的是对象。你可以把类想象成一张写满了设计和规范的文件，它静静地躺在代码里，不占运行内存的“现实空间”；而当你使用 new 或者创建对象的语法时，程序才真正在内存里给它划分一块区域，这块区域里有实实在在的数据。

我自己带学生时特别喜欢用“咖啡馆点单”来讲这一段。菜单放在收银台前，它描述了所有饮品，但客人面前那杯热气腾腾的拿铁，才是真正被“制作出来”的对象。程序运行时处理的是这一杯一杯的具体咖啡，而不是抽象意义上的那本菜单。

2.1 实例化：从模具到成品的那一刻发生了什么

从类到对象的过程，专业术语叫“实例化”。很多人被这个词吓到，其实它想表达的就是那句话：按图纸造东西。

在代码里，比如 Python 写 s = Student("张三", 95)，或 Java 写 Student s = new Student("张三", 95);，这行语句召回了这个过程：

第一步，在内存里给你这个对象分配一块空间，相当于准备好一个放着模具的工作台。第二步，执行类中的初始化方法（Python 里叫 __init__，Java/C++ 里叫构造方法），把传入的“张三”和“95”这两个值填进这块空间的对应位置。第三步，返回给你一个“地址”，你拿着这个地址，以后就能找到这个对象、操作它。

所以你看，实例化一点都不玄。本质上就是三个动作：分配内存、填数据、给地址。你把这个过程想成做饼干，就很自然：拿出模具、压面团、放在烤盘上，完事。

注意：有些语言里你创建对象时可能会漏写 new，比如 Java 新手容易写 Student s = Student("张三", 95); 然后编译报错。这是因为没有 new 的时候，你只是在“说”有一个学生，而并没有真的在内存里把学生做出来。记住一条死规则：要用对象，必须先实例化，实例化就要 new（或用对应语言的关键词）。

2.2 对象各自独立，互不串门

对象和对象之间是什么关系？我听到过不少新手把对象理解成“全局变量”的感觉，总觉得创建一个对象，所有代码里的同一个类对象都是同一个。这误会大了。

你做一个班级的学生档案。用“学生”类创建了对象 a 和对象 b，a 叫张三，b 叫李四。张三的分数改成 100，会影响李四吗？不会。因为这俩对象虽然在同一个类这个模具里刻出来的，但它们在内存里是两块完全独立的区域。改 a 的属性，改的是 a 自己的那块内存；b 的那块内存里还是 72 分，动都没动。

这一点非常关键。新手一旦理解了“每个对象有自己独立的数据副本”，很多错误就能迎刃而解。后面我会专门讲一个“对象之间互相影响”的坑，那段经历我至今印象深刻。

3. 类的两个核心部件：属性与行为（方法）

你解剖开任何一个类，里面主要就两样东西：属性和方法。说得生活一点，属性是“这个东西有什么”，方法是“这个东西能干什么”。

拿手机来举例。手机这个“类”长什么样？它应该有一个品牌属性、屏幕尺寸属性、颜色属性、当前电量属性，这些就是属性。它能干什么？打电话、发消息、拍照、待机，这些功能在代码里对应一个个函数，也就是方法。

3.1 属性写到哪、怎么写

属性就是定义在类里面的变量。在 Python 中你通常写在 __init__ 方法里用 self.xxx 来声明；在 Java、C++ 中则作为类的成员变量直接写在类体里。

我先给一段特别直观的 Python：

python复制class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

这段代码的意思就是：我规定学生这个类有两个属性，一个叫 name，一个叫 grade。以后你每创建一个学生对象，都必须给这两个属性准备值。

Java 里会略多一点，一般这样写：

java复制public class Student {
    String name;
    int grade;

    Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }
}

C++ 也有类似写法，主要差别是把初始化函数叫构造函数。这里我不让你记语法，就想让你知道一件事：任何语言里，属性的本质都一样，就是挂在这个对象上的变量，每个对象都有一份独立副本。

至于 private、public 那些访问修饰符，你现阶段可以理解成“这个东西能不能被外部碰到”。名字带 private 的，相当于放进抽屉里，只有类内部能拿；带 public 的，相当于摆在桌面上，谁都能看。这个细节后面再细说，不阻碍你理解主体概念。

3.2 方法是对象的“技能”

方法是定义在类里的函数。它跟普通函数的差别在于：它默认知道“自己是哪个对象身上的”，因此可以直接访问这个对象的属性。这个“知道自己是谁”很重要，因为它让方法天然地和对象绑定在一起。

还是那个学生类，我给它加两个方法：

python复制class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

    def introduce(self):
        print(f"我是{self.name}，成绩{self.grade}分")

    def is_pass(self):
        return self.grade >= 60

introduce 方法帮这个学生对象做自我介绍，is_pass 方法告诉你他这科过没过。这就是对象的能力：你要想知道某个学生过没过，不用自己拿着分数在代码里到处算，直接问这个对象一句“你过了没”，它就能给你一个回答。

这种把“数据和操作数据的函数”放在一起的做法，正是“类”最核心的设计思想，术语叫封装。意义在哪里？在于代码像搭积木一样，以后你只要拿到一个学生对象，不需要关心它数据内部怎么存，直接调它身上的方法就行。不用一个游离在外的函数，先去掏一个对象的内部状态，写完一种边界情况又漏掉另一种。

3.3 this、self 到底在指谁

几乎每个学类的人都会被 self、this 卡一下。其实它们翻译成中文就一个字：我。

Python 函数里写 def introduce(self):，意思是“这个方法是学生对象自己身上的技能”。方法被调用时，Python 会自动把这个对象本身传给第一个参数 self，所以你在方法里写 self.name，其实是说“我这个对象自己的名字”。这就像你自我介绍时说“我叫张三”，而不是说“某个叫张三的人”。

Java 里的 this 同理。在构造方法里写 this.name = name，意思就是“把我这个对象的 name 属性，设置成你传进来的那个 name 参数”。一个叫“我的”，一个叫“你的”，放一起很容易乱，所以必须用 this 来区分。

对于这个概念，我给新手一个死办法：每次看到 self 或 this，就在心里默念一遍“我自己”。 长期这样念，念着念着就理解了：它是对象的自我指代，让方法知道自己在服务哪个对象。

4. 用一个完整例子把概念真正跑通：学生档案小系统

前面说了很多理论，这一节我用一个非常小的例子，走一遍“分析需求 → 抽象类 → 创建对象 → 使用对象”的完整流程。我建议你打开编辑器跟着敲一遍，因为类这种东西，光看永远懂不了，敲一遍才会有“原来如此”的感觉。

4.1 分析需求，先列“名词和动词”

假设学校给你一个需求：要记录学生的信息和成绩，能显示每个学生的基本情况，能判断学生是否及格。这个需求很典型，因为下一秒你就要决定怎么写类了。

怎么从需求里抽出一个类？我总结经验就是找“名词”和“动词”。需求里出现的关键名词是“学生”，那“学生”就很可能是类。需求里的动词是“显示情况”“判断及格”，这些就是方法。名词的属性怎么来？学生身上有哪些描述信息？名字、学号、成绩。好，一个类的骨架就出来了。

这个过程听起来简单，但它是面向对象分析的核心能力。很多同学一上来就抄着别人代码写类，写是能写，但问一句“这个类为什么有三个属性而不是五个”，就答不上来。原因就是没有走这一步“从现实到代码”的抽象过程。

4.2 定义一个最基本的类

我先把刚才的分析落地成 Python 代码，加了学号字段：

python复制class Student:
    def __init__(self, student_id, name, grade):
        self.student_id = student_id
        self.name = name
        self.grade = grade

    def introduce(self):
        print(f"学号{self.student_id}，姓名{self.name}，成绩{self.grade}分")

    def is_pass(self):
        return self.grade >= 60

如果写成 Java，看这段：

java复制public class Student {
    String studentId;
    String name;
    int grade;

    public Student(String studentId, String name, int grade) {
        this.studentId = studentId;
        this.name = name;
        this.grade = grade;
    }

    public void introduce() {
        System.out.println("学号" + studentId + "，姓名" + name + "，成绩" + grade + "分");
    }

    public boolean isPass() {
        return grade >= 60;
    }
}

你看，不同语言长相不同，但骨架一模一样：属性、构造方法、普通方法。所以学类的时候，不必把每种语言的语法都当成新知识背，理解这一套思想，换个语言很快就能上手。

4.3 创建多个对象并用起来

类定义好之后，使用才是重点。我一次性创建三个学生对象，把它们放进一个列表，然后循环输出：

python复制students = [
    Student("001", "张三", 95),
    Student("002", "李四", 58),
    Student("003", "王五", 76)
]

for stu in students:
    stu.introduce()
    if stu.is_pass():
        print("   结论：及格")
    else:
        print("   结论：不及格")

这段代码的输出很直观：

• 学号001，姓名张三，成绩95分，结论：及格
• 学号002，姓名李四，成绩58分，结论：不及格
• 学号003，姓名王五，成绩76分，结论：及格

请注意，张三是 95 分，李四是 58 分，两个对象存的数据完全无关。循环调用 stu.introduce() 时，每个 stu 都分别代表自己，而不是笼统地代表“某个学生”。能理解这一行，说明你已经抓到类和对象的精髓了。

5. 新手最容易踩的坑，我逐个给你排一遍

我见过太多“看懂了但一写就炸”的情况。很多错误不是因为你不会语法，而是对类和对象的某些细节理解偏了。下面这四个坑，是我在教学中反复见到的，每一个我都尽量说出前因后果。

5.1 类名和变量名傻傻分不清

我经常看到新手的代码长这样：

java复制Student = new Student();

报错之后就懵了。其实问题出在 Student 是类名，你怎么能把类名当变量名用？正确做法是给对象起一个具体的变量名：student = new Student(); 或 s = new Student();。类相当于物种，变量名相当于这个具体个体的名字。你不会把“汪星人”这个名字直接拿来当一只狗狗的名字，逻辑上是一回事。

5.2 忘了 new，等来一个“空对象”

这是另一个高频错误。在 Java 或 C++ 里，有些同学这样写：

java复制Student s;
s.name = "张三";

编译器可能不报错，但程序一跑就给你来一个 NullPointerException（空指针异常）。为什么？因为光写了 Student s;，只是声明了一个可以装学生对象的“盒子”，盒子里还什么都没有。你直接往空盒子里塞“张三”，肯定出事。

正确写法是：

java复制Student s = new Student();
s.name = "张三";

一定要先 new，先把对象造出来。这就像你先把饼干做出来，才能往上面撒糖霜。对应 Python 里不常见这种问题，因为 Python 创建对象就是直接调类，不需要 new 关键词。但理解 this “先有对象再操作” 的逻辑，对后面学什么语言都有帮助。

5.3 把所有东西都塞进同一个类：上帝类警告

新手学会写类之后，容易走向另一个极端：什么功能都往一个类里塞。今天往“用户类”里加个打印方法，明天加个数据库连接，后天再加个界面刷新，最后这个类变得巨大无比，改一个地方就要重新测几十个功能。

这种类在行业里有个外号叫“上帝类”，听起来很厉害，实则是个定时炸弹。你把它想象成一个工具箱：螺丝刀、锤子、电钻、改锥全堆在一个抽屉里，找东西得翻半天，拿的时候还容易划伤手。

正确姿势是按职责拆类：一个类只管一件主要的事。比如把“学生”和“班级”分开，把“改分数”和“打印报表”分开，各管各的，互相通过方法协作。好的类设计，读起来像一张清晰的表格；糟糕的类设计，读起来像一篇没有分段的长作文。

5.4 把 static 当万能钥匙，破坏了对象独立的世界

不少同学学了 static 之后，特别喜欢给它加“static”，因为这样不用创建对象就能直接用，写起来省事。结果所有数据都变成了全局共享的，张三的消息打到李四的屏幕上，问题就出现了。

static 变量是这个类所有对象共享的，相当于一张贴在教室墙上的公用海报，谁都能改，改完所有人都看到；而普通属性是每个人自己抽屉里的笔记本，各记各的。新手阶段我建议你尽量少用 static，老老实实创建对象、操作对象属性。 当你能流畅地处理对象之间的关系后，再在确实需要的场景里使用 static，比如常量定义、工具方法，那时候你就会明白它真正的适用面。

6. 不同语言里的类长得不一样，道理却是同一个

学到这里，你可能已经感觉到，类与对象的语言长相千差万别。我常跟学生说，如果你理解了核心思想，换语言其实就是换一层“语法皮”。

以上表格里，核心概念完全一样：有类，有对象，有属性，有方法，有指向自己的引用。真正不同的，是语法细节和某些语言特有的特性，比如 C++ 有析构函数，JavaScript 在 ES6 后才开始普及 class 语法。可一旦你脑子里建立起“模具和饼干”这个画面，看任何语言的类代码，都不会觉得陌生。

顺便提一下“抽象类”，这个词也是新手搜索的高频词。它的本质可以理解为“这张图纸画了一半，还不能直接造东西”。它要为子类提供基础规范：比如定义好一个“动物”抽象类，规定了所有动物必须有“叫”这个方法，但具体怎么叫，由子类“狗”“猫”自己补充。子类的对象可以实例化，抽象类本身不能直接造对象。学完基础之后再回头看抽象类，你会发现它其实是类体系里的“半成品模板”，没有想象中那么难。

7. 把自己从“背概念”里捞出来的三个方法

最后，我不打算给你布置什么大作业，只分享三个我自己带学生时验证过非常有效的做法。这几年下来，凡是能快速掌握类与对象的人，用的基本就是这套打法。

7.1 先画一个方框，再写代码

别急着敲代码，拿张白纸，画一个大方框，上方写类名，中间写属性，下面写方法。比如画“学生”：

• 类名：Student
• 属性：学号、姓名、成绩
• 方法：自我介绍、判断是否及格

画好方框，再翻译成代码。这个过程强制你先把思路理清，而不是边写边乱加。你不需要特地去学复杂的 UML 类图，照样能提前解决 70% 的分析混乱。

7.2 把自己带入“对象”的视角

每当你不知道某个属性该不该放进类里，就问一句：如果我是这个对象，我有没有这个东西？比如你是“学生”，你有没有“考试成绩”？有，那这个属性应该放进来。你是“学生”，你有没有“食堂菜单”？这显然不是学生本身的属性，那就别放进来，应该是食堂类的属性。用“代入法”做分析，基本不会跑偏。

7.3 连续三天做一个小项目

找一个不超过两百行的小项目，比如学生成绩管理，或图书借阅登记。第一天定义类；第二天创建对象、放进列表；第三天加上查找或排序功能。三天时间足够你反复体会“类负责定义、对象负责实例化”这个过程。做完这个项目，你再回去看课本事例，会觉得那些定义都成了废话。

我个人的真实体会是，类与对象不是靠“懂”的，是靠“用过”才懂的。如果你现在还在背书，我的建议很简单：放下讲义，画方框，写类，造三个对象，把它们的属性改了再打印出来，玩个十分钟，你会回来感谢自己。