企业官网建设流程全解析

最近在整理学习笔记，翻到自己随手写下的“day3 对象与一些基本语法”，突然觉得这个题目值得拿出来展开聊一聊。原因很简单：不管你是从 Python、Java、C++ 还是 JavaScript 入门，前两天的变量和流程控制都只是热身，到第三天开始碰“对象”，才算真正进入编程的核心地带。你看那些高频搜索记录——python类对象、c++类和对象、js中函数是对象吗、对象数组去重、判断对象为空、对象深度拷贝……几乎覆盖了所有主流语言和框架。对象这个概念被反复追问了几十年，本质上是因为不同语言把它包装成了完全不同的样子。这篇笔记不会只讲某一种语言，而是把“对象是什么、怎么创建、怎么判断、怎么拷贝、怎么防坑”这条主线串起来，代码尽量给多语言对照。正在学对象语法的新手可以按顺序读，跨语言开发的老手可以直接跳到自己关心的章节。

1. 对象到底是什么：先把底层模型立住

很多教程一上来就背“对象是类的实例”，背完还是懵。我建议先放弃定义，从实际代码出发，把对象看成“一块打包好的内存”。这块内存里存了一组数据，还附带一组能操作这些数据的方法。你能通过某个变量名找到这块内存，能给它传参、取属性、调用方法，那它就是一个对象。

先把这个底层模型立住，后面所有的语法差异、踩坑场景，都能用这一句话解释清楚。

1.1 从“类”到“对象”：模板与实例的关系

类（class）是模板，对象是根据模板创建出来的实例。这个类比我讲过很多次：类就是饼干模具，对象是用模具压出来的饼干。模具定义了口味、大小、花纹，但每块饼干可以有自己不同的颜色或者装饰；同理，类里定义属性和方法，每个实例可以持有不同的属性值。

Python 的写法最直观：

class Dog: def __init__(self, name, age): self.name = name self.age = age def bark(self): return f"{self.name} is barking" d1 = Dog("旺财", 3) d2 = Dog("来福", 2) print(d1.bark()) # 旺财 is barking

这里Dog是类，d1、d2是对象。__init__负责在对象创建后立刻初始化属性，这是 Python 里最常见的对象创建入口。Java 和 C++ 里对应的叫构造器，写法略有不同，但核心心智模型完全一样：先声明类型，再实例化。

新手最容易绕晕的地方是“对象”和“变量”的关系。变量名不等于对象本身，它更像一张写着地址的便签。比如d1 = Dog("旺财", 3)，执行后变量d1保存的是对象的地址，不是把整个狗对象塞进变量里。这一点暂时记在心里，下一节详细展开。

实际操作中，我建议新手不要急着理解“万物皆对象”这种抽象说法，先用最笨的办法：看到对象.属性或对象.方法()的写法，就把它当对象处理。用一周时间，自然就顺了。

1.2 值类型与引用类型：解不开的一道坎

对象和普通变量最大的区别在于“值传递”和“引用传递”。像整数、布尔、字符串这种基础类型，变量里直接存值；而对象变量里存的是地址，也就是引用。这个区别是所有对象操作翻车的总根源。

看一段 JavaScript 代码：

let a = { count: 1 }; let b = a; b.count = 2; console.log(a.count); // 2

b = a并不是把{ count: 1 }复制了一份，而是让b和a指向同一个对象。所以修改b.count会直接影响到a.count。如果你真正想要一个独立副本，就得用拷贝，后面专门会讲。

Python 也有类似情况，只是表现方式隐蔽一点：

original = [1, 2, [3, 4]] shallow = original[:] shallow[2].append(5) print(original) # [1, 2, [3, 4, 5]]

切片original[:]只复制了外层列表，内部那个子列表仍是共享的。这种“只复制一层”的行为，就是浅拷贝（shallow copy）。Java 里==比较两个对象时，比较的是引用，而不是内容，也是同一个原因。

理解值类型和引用类型，对三件事特别重要：判断对象是否为空、做对象拷贝、做对象数组去重。它们底层都在处理同一个问题——我手里的这个变量，指的到底是哪块内存。

2. 不同语言里对象长什么样：语法对照大会

对象的核心概念跨语言通用，但每个语言都按自己的风格把它包装成了不同的样子。Python 搞“一切皆对象”，JavaScript 把函数也当成对象，C++ 则是从结构体一路发展出类和元对象系统。把这些差异对照着看，比死记某一种语言的语法高效得多。

2.1 Python 的类对象与“一切皆对象”的真相

Python 里定义类和创建对象的语法最简洁，适合用来建立完整认知。

class Student: school = "一中" # 类属性，所有实例共享 def __init__(self, name): self.name = name # 实例属性 s = Student("小明") print(s.school, s.name) # 一中 小明

这里要注意类属性和实例属性的区别。类属性挂在类上，所有实例共用；实例属性挂在self上，每个实例自己有一份。新手常见的坑是：如果类属性是可变对象，比如tags = []，那么所有实例会共享同一个列表，一个实例往里追加内容，其他实例也会看到。这种隐蔽问题，排查起来非常容易懵。

Python 的“一切皆对象”不是修辞。函数本身也是对象，类本身也是对象，int、str这些类型本质上是类对象。你可以给函数挂属性：

def greet(): print("hello") greet.author = "me" print(greet.author) # me

这也是为什么 Python 能轻松实现装饰器、类型注解、函数式编程——因为函数可以被传递、被赋值、被动态添加属性。理解这一点，再看 Django 模型对象、PyGObject 控件对象，就更容易接受：框架层大量使用元类和装饰器，本质上就是把“对象”玩到了极致。

2.2 JavaScript 的对象字面量、函数对象与原型链

JavaScript 的对象语法门槛最低，但也最容易产生误解。你可以不写类，直接用字面量创建对象：

const user = { name: "Alice", age: 20 };

这就是对象。没有类，也能有对象。ES6 之后虽然有了class关键字，但它本质上还是基于原型的语法糖，不是传统面向对象语言里的类。

关于“js中函数是对象吗”这个问题，答案是肯定的。看这段代码：

function foo() {} foo.customInfo = "hello"; console.log(foo.customInfo); // hello console.log(typeof foo); // "function"

typeof返回function，这只是语义上的特殊处理，函数本质上是可调用的对象。它有自己的属性、原型，可以赋值给变量，可以作为参数传递。你甚至可以对函数使用Object.keys()。

对象之间的继承关系靠原型链实现：

const parent = { greet: function() { return "hi"; } }; const child = Object.create(parent); child.name = "Tom"; console.log(child.greet()); // hi，来自 parent

child自己没有greet方法，但通过原型链向上找到了parent的方法。这也是 Vue 3、uni-app 里ref、reactive等响应式 API 的基础——框架会把普通对象转换成代理对象，拦截属性的读写操作，从而触发视图更新。所以你在 uni-app 或 Vue 里操作ref包裹的对象时，其实就是把一个普通对象包装成了一个带响应式能力的代理对象，底层仍然是对象和原型这套东西。

2.3 C++ 结构体链表、类对象与 Qt 元对象系统

C++ 的对象观和 Python、JavaScript 差别很大，因为 C++ 里你可以决定对象放在哪块内存。搜索里常出现“c++结构体链表基本语法”，这其实是入门对象时最好的切入点：

struct Node { int val; Node* next; }; Node a; a.val = 1; Node* b = new Node(); b->val = 2; a.next = b;

链表节点Node本身是一个对象，next指向下一个节点对象的地址。这里能直观看到引用（指针）在对象间是怎么串起来的。C++ 也没有强制要求对象必须用new创建，所以你既能在栈上定义自动对象（如Node a;），也能在堆上手动创建（如new Node()）。栈对象生命周期由作用域决定，堆对象需要你自己管理内存。这也是 C++ 最难的一部分，现代 C++ 通常用shared_ptr/unique_ptr管理对象生命周期，而不是裸指针。

再往上一层，Qt 的元对象系统值得专门提一下。C++ 本身没有反射能力，运行时拿不到类的完整结构信息，但 Qt 通过Q_OBJECT宏和元对象编译器（moc）给类注入了元信息，于是实现了信号槽、属性系统、动态调用这些能力。搜索词里的“qt 元对象系统”指的就是这套机制。理解它的好处是：当你在 GUI 框架里操作控件对象、设置对象位置时，底层其实是在读写一些带有特殊元信息的对象属性。

2.4 Django 模型对象、Cypher 节点与 GUI 控件对象：框架里的对象变体

框架世界里的“对象”往往不是单纯的语法实体，而是有特殊语义的包装对象。以 Django 为例，ORM 把数据库表的每一行映射成一个模型对象，删除对象也不是直接了事：

# 删除单个对象 book = Book.objects.get(id=1) book.delete() # 批量删除查询集 Book.objects.filter(published=False).delete()

book.delete()会返回删除数量，Django 还会处理级联删除，关联的外键对象会被自动清理。新手容易在这个环节漏掉一个关键点：QuerySet 是惰性的，get()拿不到数据时会抛异常，所以删除操作之前最好先做存在性判断。

图数据库 Cypher 语法里的“对象”又不一样。Cypher 用节点和关系描述数据，节点就像一个带标签和属性的对象：

CREATE (p:Person {name: "Alice", age: 30}) MATCH (p:Person) RETURN p

这里的p不是编程语言里的实例，而是图数据库的实体对象。它同样有自己的属性、类型标签、关系连接，概念上很像“对象图”。如果之前学过面向对象，再学图数据库会非常顺——每个节点就是对象，每条关系就是对象之间的引用。

GUI 框架里的控件对象更现实。PyGObject 里设置控件位置，通常就是给一个控件对象的属性赋值，比如button.set_position(...)，或者直接widget.props.halign = "center"。控件对象内部维护了大量状态，既有数据属性，也有行为方法，和普通类实例没有本质区别，只是它还要负责和底层 C 库交互。

3. 对象基本语法实战：创建、判空、取值、去重

理论部分讲完，现在进入真正能直接上手的部分。下面四组操作是日常开发里最高频的：怎么创建对象、怎么判断对象为空、怎么在框架里取对象、怎么做对象数组去重。每一组我都会给出多语言写法，并说明为什么这样写。

3.1 创建对象：构造器、字面量与工厂函数的取舍

很多学习平台把“对象的创建”放在第一关，这个设计很有道理。没有实例，所有关于类的讨论都是空的。创建对象的方式，不同语言有明显差异。

先看经典构造器方式，Java 和 C++ 用new：

Student s = new Student("张三");

Student* s = new Student("Li"); // 堆对象 Student t("Wang"); // 栈对象

JavaScript 里三种方式都很常见：

// 方式一：对象字面量，最简单 const obj1 = { name: "Alice" }; // 方式二：new Object() const obj2 = new Object(); obj2.name = "Bob"; // 方式三：工厂函数 function createUser(name) { return { name }; } const obj3 = createUser("Carol");

工厂函数的意思是：用一个普通函数返回新对象。它不依赖new，适合封装复杂的创建逻辑，比如设置默认值、做参数校验。Python 3.7+ 的dataclass则是创建数据对象的现代姿势：

from dataclasses import dataclass @dataclass class User: name: str age: int u = User("Alice", 20)

dataclass自动生成了init、repr、eq这些方法，代码量少很多。实际开发中，如果对象主要用于携带数据，我几乎都会优先考虑 dataclass；如果对象包含大量业务逻辑，再用普通 class。这个选择没有对错，核心是看对象是要“装数据”还是“做事情”。

3.2 判断对象为空：别再只会写 == null

“判断对象为空”是接口开发和日常编码里的高频操作。不同语言的判空姿势差别很大，用错一个判断条件，轻则空指针异常，重则数据静默错误。

这里最容易踩坑的是 JavaScript 的“空对象”判断。很多人直接写if (obj === {})，这永远为 false，因为{}是一个新对象，和obj引用不同。正确姿势：

const isEmpty = obj && obj.constructor === Object && Object.keys(obj).length === 0;

加上constructor === Object是为了避免把数组、日期等对象误判为空对象。数组用Object.keys([])得到 0，但它显然不是一个“空对象”。

Java 8 之后官方推荐用Optional处理可能为空的引用：

Optional<User> optional = Optional.ofNullable(user); String name = optional.map(User::getName).orElse("default");

Optional不是让你在所有地方都套一层，而是面向返回值，明确告诉调用方“这个值可能不存在”。在接口层做对象判空时，我习惯用Optional兜底，内部逻辑照常用if (obj != null)，两者并不冲突。

3.3 对象转 QueryWrapper、jQuery 取对象与 PreparedStatement：框架里的取值姿势

框架里的对象操作比语言层面要花哨一点，但也更贴近真实项目。

先看“对象转 QueryWrapper”。这是 MyBatis-Plus 里的常见需求：前端传了一个查询对象，你希望把非空字段自动拼成 SQL 条件。

UserQuery query = new UserQuery(); query.setName("张三"); query.setAge(20); QueryWrapper<User> wrapper = new QueryWrapper<>(query); List<User> users = userMapper.selectList(wrapper);

new QueryWrapper<>(query)的底层逻辑是：遍历查询对象里的字段，剔掉 null 值字段，把非空字段转成等值条件。这个特性的好处是省去一堆手写if判断，但要注意两点：第一，字段需要和实体映射对应，最好用@TableField显式指定列名；第二，它只能生成等值条件，范围查询、模糊查询还是得手动用.like()、.gt()这些方法拼。

“jquery根据name获取对象”也是典型场景：

// 根据 name 属性获取表单元素（返回 jQuery 对象） const $input = $('[name="username"]'); const value = $input.val();

注意$('[name="username"]')返回的是 jQuery 对象而不是原生 DOM。jQuery 对象是一个类数组对象，可以调用.val()、.on()等方法；取原生 DOM 需要$input[0]或$input.get(0)。

“preparedstatement对象”属于 JDBC 的预编译语句对象：

PreparedStatement ps = conn.prepareStatement("SELECT * FROM user WHERE id = ?"); ps.setLong(1, 1001); ResultSet rs = ps.executeQuery();

PreparedStatement 本质上是一个封装了 SQL 语句和参数的对象。它比直接拼接字符串安全，因为参数是分离的，数据库会把参数当数据而不是 SQL 代码处理，能有效防止注入攻击。这类对象在 ORM 框架里被继续封装，但底层仍然是这个思维。

3.4 对象数组去重：从原理到一行代码

对象数组去重为什么比基本类型数组去重麻烦？因为两个对象即使内容完全一样，内存地址也可能不同，直接用indexOf或includes都不好使。去重必须指定一个“键”——用哪个字段判断两个对象重复。

JavaScript 最常见的写法是用Set配合唯一键：

const arr = [ { id: 1, name: "a" }, { id: 2, name: "b" }, { id: 1, name: "a" } ]; const seen = new Set(); const unique = arr.filter(item => { if (seen.has(item.id)) return false; seen.add(item.id); return true; });

更简介的 Map 写法：

const unique = [...new Map(arr.map(item => [item.id, item])).values()];

原理是利用 Map 的键不可重复特性。arr.map把每一条对象转成[item.id, item]的小数组，Map 自动去重，最后.values()取回对象。如果多个字段组合判断唯一性，可以把键拼成一个字符串，比如${item.id}_${item.name}。

Python 里做字典对象列表去重，常见做法是用一个辅助集合：

seen = set() result = [] for d in dict_list: key = (d["id"], d["name"]) if key not in seen: result.append(d) seen.add(key)

Java 用 Stream：

List<User> unique = list.stream() .collect(Collectors.toMap( User::getId, Function.identity(), (a, b) -> a, LinkedHashMap::new )) .values() .stream() .toList();

这个写法里toMap的第三个参数(a, b) -> a表示遇到重复键保留第一个对象。如果不指定合并策略，重复键会直接抛异常。去重的本质就是“按某种规则计算唯一标识，然后让容器帮你过滤”，掌握这个原理，换任何语言都能很快写对。

4. 深拷贝与对象存储：把对象复制和落盘讲明白

对象拷贝和存储是“引用传递”模型的直接延伸。理解了浅拷贝和深拷贝的差异，你就理解了为什么很多线上 bug 是“对象被莫名其妙改掉了”。

4.1 浅拷贝与深拷贝的底层差异

浅拷贝只复制对象本身，对象内部的引用型字段仍然共享；深拷贝则是递归复制，连内部对象也一起复制，最终得到一份完全独立的对象树。

看 JavaScript 的例子：

const original = { name: "Alice", address: { city: "北京" } }; // 展开运算符是浅拷贝 const clone = { ...original }; clone.address.city = "上海"; console.log(original.address.city); // 上海，内部对象还是共享的

Python 的copy模块把这两个概念分离得很清楚：

import copy original = {"name": "Alice", "address": {"city": "北京"}} shallow = copy.copy(original) deep = copy.deepcopy(original) shallow["address"]["city"] = "上海" print(original["address"]["city"]) # 上海，浅拷贝共享内层 deep["address"]["city"] = "广州" print(original["address"]["city"]) # 上海，深拷贝完全独立

Java 里Object.clone()默认是浅拷贝，这也是很多人踩坑的地方。反序列化框架（Jackson、Gson）做出来的拷贝，默认行为也取决于配置，一般会创建一个新对象，但嵌套复杂的结构还是得小心循环引用。

选择浅拷贝还是深拷贝，要看清应用场景：只读取不修改内部对象，浅拷贝够用；拿到对象后要改内部字段且不能影响原对象，必须深拷贝。

4.2 Java 对象深度拷贝的三种可靠写法

Java 里做深度拷贝，网上的说法很多，但真正可靠的我常用的只有三种：序列化方式、JSON 序列化反序列化、手工复制。各有优劣，按场景选。

第一种：Java 原生序列化。

@SuppressWarnings("unchecked") public static <T> T deepCopyBySerializable(T obj) { try ( ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos) ) { oos.writeObject(obj); try ( ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bis) ) { return (T) ois.readObject(); } } catch (Exception e) { throw new RuntimeException(e); } }

要求对象及其内部所有对象实现Serializable接口。它能处理循环引用，因为序列化协议会记录对象之间的引用关系。性能一般，但胜在实现简单、逻辑统一。

第二种：JSON 序列化。

ObjectMapper mapper = new ObjectMapper(); User clone = mapper.readValue(mapper.writeValueAsString(original), User.class);

通过 JSON 文本中转一次，也能得到独立副本。注意两点：如果对象的 getter 里有循环引用逻辑，会出问题；多态类型或接口字段需要配置@JsonTypeInfo，否则反序列化会丢失子类信息。

第三种：手工复制，性能最优。

User clone = new User(); clone.setName(original.getName()); clone.setAge(original.getAge()); clone.setAddress(new Address(original.getAddress().getCity()));

缺点很明显：字段多的时候写起来痛苦，新增字段容易忘记复制。对于字段稳定、数量不多、性能敏感的核心对象，我才会用手工复制；其他场景优先序列化方式。

4.3 对象存储服务与 JSON 序列化：别把名字搞混

“对象存储服务”这个说法经常被拿来和编程里的对象混淆。OSS、S3、MinIO 这类的对象存储，存的“对象”其实是文件、图片、视频这类二进制数据，它有自己的唯一 key 和元数据，比如Content-Type、Last-Modified。它和语言层面的对象没有直接关系，只是同为“对象”，命名上容易让人误解。

用 S3 兼容接口上传文件的思路大致是这样：

import boto3 s3 = boto3.client('s3') s3.upload_file( Filename='local_pic.jpg', Bucket='my-bucket', Key='images/2025/01/local_pic.jpg' )

关键点是 Key 的设计，这决定了对象在存储桶里的“目录结构”。开发中很多人把整个 Java/Python 对象序列化成 JSON 再存到对象存储，也没问题，比如存操作日志、历史快照。此时真正要关心的是 JSON 序列化本身。

JSON 序列化对象时有三个高频坑：循环引用、时间格式、类型丢失。

• 循环引用：对象 A 持有对象 B，B 又持有 A，直接序列化会栈溢出。Jackson 要用@JsonManagedReference和@JsonBackReference处理，或者用JsonIgnoreProperties忽略反向字段。
• 时间格式：默认序列化出来的时间戳可读性差，接口对接时容易出错，建议统一配置日期格式。
• 类型丢失：接口类型是List<Animal>，实际放进去的是Dog，反序列化回来可能拿不到Dog的字段。这种场景需要显式传递类型信息。

对象落盘这件事，本质上就是把内存里的“对象图”转成可存储、可传输的字节或文本，再从字节或文本还原成对象图。

5. 那些年排查过的对象问题实录

最后这部分，我从高频搜索词里挑几个真实踩过的坑，当作排查记录分享出来。每个问题背后都对应着一个对象概念，理解了概念，排查思路自然就清晰了。

5.1 “无法枚举容器中的对象，访问被拒绝”到底怎么回事

这个报错常见于 Windows 环境下操作注册表、文件目录、IIS 站点容器等系统对象。比如一个 Windows 服务试图读取注册表HKEY_LOCAL_MACHINE下的受保护键时，如果服务账户没有对应权限，系统就会拒绝枚举容器中的子项。

排查思路按顺序来：

1. 确认当前进程跑在什么身份下，是管理员、普通用户还是特定服务账户。
2. 检查目标容器对象的访问控制列表，看是否给当前账户分配了“读取”或“列出目录”权限。
3. 检查继承设置，很多权限问题都出在“父容器有权限，但子容器禁用了继承”。
4. 在代码里捕获并打印具体异常堆栈，确认是权限失败还是句柄无效。

如果只是临时验证，用管理员身份运行程序通常能打通；但正式环境不能靠提权解决问题，正确做法是给对应的服务账户单独授权，最小权限原则。这个案例里的“容器对象”不是编程语言里的容器对象，而是系统命名空间里的实体，但它也有属性、有访问权限，和对象模型是相通的。

顺带说一个编码习惯：枚举对象容器之前，先做权限探测，能拿到权限再枚举。比直接GetChildren()然后被异常打断要自然得多，线上日志也会好看很多。

5.2 两万行 JSON 转换对象会扛不住吗：大对象数组的解析策略

有人问“阿里 JSON.parseArray 转换对象有两万行扛得住吗”，这个问题的标准答案是：两万行本身不算大，真正决定是否扛得住的是每一行对象的字段深度和数据量。

// fastjson 一次性解析整个 JSON 字符串 List<UserDTO> list = JSON.parseArray(jsonStr, UserDTO.class);

一次性解析会做两件事：先把整个字符串加载到内存，再递归构造完整的对象图。如果每个对象只有 5 个简单字段，两万行毫无压力；但如果对象里嵌套多层列表，或者每条记录都携带大字段，内存峰值会迅速膨胀。

实践中我更推荐流式处理思路：

// 先从字符串源头考虑：能否只解析部分？ // 使用 JSONReader 逐个读取对象，边读边处理 try (JSONReader reader = new JSONReader(new StringReader(jsonStr))) { reader.startArray(); while (reader.hasNext()) { UserDTO dto = reader.readObject(UserDTO.class); // 处理一条，然后丢弃引用 } reader.endArray(); }

流式解析的核心价值不是快，而是控制同时存活的对象数量。一次只保留一条正在处理的对象，处理完就释放引用，GC 压力小得多。如果是超大 JSON，还应避免一次性readAllBytes进内存，改用 InputStream 边读边解析。

这里要特别提醒 DTO 瘦身：两万行“扛不住”很少是因为行数多，更多是因为一行对象里塞进了几十个无用字段。接口对接时只保留需要的字段，比任何解析优化都有效。

5.3 Ansys Workbench 模态求解报错：去“求解信息对象”里找线索

搜索里出现的“ansys workbench 模态求解报错 求解过程中出现未知错误 检查 求解信息 对象”，虽然不是编程语言里的对象，但排查思维完全一致。Ansys Workbench 的树形结构里，模型、网格、求解设置、求解信息都是以对象形式组织的。

遇到“未知错误”时，最有效的操作是打开“求解信息”对象，展开里面的 Error 和 Warning 节点。大多数“未知错误”其实都有具体原因：

• 约束不足导致刚体位移，模态分析前几个频率接近 0，这是最常见的原因。
• 接触对设置错误，比如本该绑定接触的零件之间出现了间隙。
• 材料参数不完整，缺少弹性模量或密度，模态分析必须有密度参数。
• 网格质量差，个别单元畸变严重，导致求解器数值异常。

这个案例提醒我们：软件里的“对象”往往不是单纯的语法概念，而是一个可被状态管理、可被检查、可被操作的数据实体。排查问题的通用方法论是一样的——先定位到报错对象本身，再看它的属性、子对象、状态信息，最后根据线索缩小范围。

最后说点个人体会

学对象语法最忌讳背定义。我自己带新人的时候，一定会让他们做一件事：任何代码里出现对象赋值，都在纸上画一个箭头，从变量名指向对象内存。画着画着，引用、传参、拷贝这些问题全通了。

这一课学完之后，建议你沿着三条线继续深入：一是 ORM 里的实体对象，比如 Django 模型、MyBatis-Plus 实体，理解数据怎么变成对象；二是响应式编程里的代理对象，比如 Vue 3 的 ref 和 reactive，理解对象怎么被拦截和增强；三是反射、序列化、元对象系统这边的对象，理解对象怎么被检查、复制和传输。三条线都通了，对象这个东西你就彻底拿下了。