Learning Processing 第 8 章:Processing/Java 面向对象编程(OOP)实战指南
Learning Processing 第 8 章:Processing/Java 面向对象编程(OOP)实战指南
导读
本文以 Coding Train(The Coding Train)《Learning Processing》课程第 8 章《对象(Objects)》为核心,系统讲解在 Processing/Java 环境中从零理解并实践面向对象编程(OOP)的完整路径:从"类(class)与对象(object)实例"的理论区分,到定义类、编写构造函数、通过构造参数定制对象,再到对象之间的通信、方法重载,以及"按值传递 vs 按引用传递"这一最易踩坑的底层机制。文章以仓库中 8-OOP 系列示例源码 与 7 函数章节 的真实代码为实证,帮助你掌握用自定义类封装数据与行为、用对象组织复杂 sketch 的实战能力,并为后续第 9 章《数组(对象数组)》打下基础。
本系列共 6 个视频小节,配套文档位于仓库 _Courses/learning-processing/8-object-oriented-programming,对应章节索引为 8-object-oriented-programming/index.md。
一、什么是面向对象编程:类与对象实例
本节对应课程视频 8.1 What is Object-Oriented Programming。视频覆盖 Processing/Java 中面向对象编程背后的基础理论,重点讨论"类"与"对象实例"之间的区别。
1.1 为什么要引入对象
在 Processing 中,setup() 与 draw() 构成的全局脚本驱动模式,在小规模 sketch 中足够好用。但随着程序规模增长——例如要同时管理 10 个气泡、100 个粒子——散落的全局变量(bubble1X、bubble2X……)会迅速失控。面向对象编程的核心动机正是模块化(modularity)与复用(reusability),这一点在上一章 7.1 Introduction to Functions and Objects 中已经埋下伏笔:函数让代码块可复用,而类更进一步,把"数据 + 操作这些数据的函数"打包成一个独立单元。
1.2 类(Class)与对象(Object)的区别
- 类(class):一张"蓝图"或"模板",描述一类事物共有的属性(变量)和行为(函数/方法),它本身不占用实际的运行数据。
- 对象(object):依据类这张蓝图**实例化(instantiate)**出来的具体实体,拥有自己的独立数据副本。
用类比来说:class Bubble 是"气泡的制造图纸",而 bubble1 = new Bubble(...) 是按照图纸生产出的一个真实气泡。图纸只有一份,但气泡可以有任意多个。
1.3 从函数到类的演进证据
仓库中 7 函数章节的星形示例 展示了"函数化"的第一步——把绘制一颗星的逻辑封装进 star(x, y) 函数,随后在 draw() 中多次调用:
void draw() {
background(51);
star(100, 100);
star(200, 300);
}
void star(float x, float y) {
beginShape();
fill(102);
stroke(255);
strokeWeight(2);
vertex(x, y-50);
vertex(x+14, y-20);
// ... 其余顶点
endShape(CLOSE);
}
这里的 star() 只封装了"行为",位置数据仍然靠参数传入。面向对象编程则更进一步:把"位置数据(x、y)"与"绘制行为(display())"一起封装进类中,让每个对象自带状态与能力。这正是从第 7 章(函数)迈向第 8 章(对象)的思维转折点。
二、定义一个类:变量、构造函数与方法
本节对应视频 8.2 Defining a Class Part I 与 8.3 Defining a Class Part II。视频逐步演示在 Processing(Java)中定义一个类的完整过程:成员变量(variables)、构造函数(constructor)、成员方法(functions)。
2.1 类的三大组成部分
仓库中的经典示例 Bubble.pde 是"气泡"类的完整定义,几乎逐行对应视频讲授的内容:
class Bubble {
float x; // 成员变量:水平位置
float y; // 成员变量:垂直位置
float diameter; // 成员变量:直径
Bubble(float tempD) { // 构造函数:负责初始化对象
x = width/2;
y = height;
diameter = tempD;
}
void ascend() { // 方法:上浮
y--;
x = x + random(-2, 2);
}
void display() { // 方法:显示
stroke(0);
fill(127, 100);
ellipse(x, y, diameter, diameter);
}
void top() { // 方法:越界回绕
if (y < -diameter/2) {
y = height + diameter/2;
}
}
}
- 成员变量(fields):
x、y、diameter定义在类体中、所有方法之外,它们是每个对象实例独立持有的"状态"。注意width与height是 Processing 的全局窗口尺寸,可以直接在类的方法中读取。 - 构造函数(constructor):与类同名的特殊方法,在
new创建实例时自动调用,负责把对象初始化为可用状态。上述构造函数把气泡初始位置放在窗口底部中央(x = width/2、y = height),直径由传入参数决定。 - 成员方法(methods):
ascend()让气泡每帧上浮 1 像素并左右随机漂移(random(-2, 2));display()以fill(127, 100)(半透明灰色)绘制椭圆;top()实现"回到顶部后从底部重新出现"的回绕逻辑。
2.2 在 sketch 主文件中使用类
类定义好之后,需要在主 sketch 中声明对象变量、实例化并逐帧调用其方法。仓库示例 sketch_8_3_BubbleObject.pde:
Bubble b1; // 声明:b1 是一个 Bubble 类型的引用变量
Bubble b2;
void setup() {
size(640, 360);
b1 = new Bubble(64); // 实例化:创建直径为 64 的气泡
b2 = new Bubble(16); // 实例化:创建直径为 16 的气泡
}
void draw() {
background(255);
b1.ascend();
b1.display();
b1.top();
b2.ascend();
b2.display();
b2.top();
}
关键语法点:
- 声明(declaration):
Bubble b1;只声明一个指向Bubble的引用,此刻对象还不存在。 - 实例化(instantiation):
new Bubble(64)调用构造函数真正创建对象,并把返回的引用赋给b1。new是 Java/Processing 中创建对象的关键字,其作用是分配内存并执行构造函数。 - 调用方法(invocation):通过点号
.调用对象的方法,如b1.display()。 - 独立实例:
b1与b2是互不影响的两个独立对象,各自持有自己的x、y、diameter副本——即使它们来自同一个类蓝图。
2.3 多个 tab 的组织习惯
在 Processing 开发环境中,类通常放在独立的 .pde 标签页(如 Bubble.pde),主程序放在另一个标签页(如 sketch_8_3_BubbleObject.pde)。仓库目录 8_OOP/sketch_8_3_BubbleObject 正是这种组织方式:Bubble.pde 只含类定义,主文件只含 setup() 与 draw()。Processing 会自动合并同目录下的所有 .pde 文件进行编译。
三、构造函数参数:让每个对象各具特色
本节对应视频 8.4 Constructor Arguments。视频展示如何"在创建对象的同时,通过调用构造函数指定对象的参数",从而让不同实例拥有不同配置。
3.1 参数化构造函数的价值
上面的 Bubble 构造函数接收一个直径参数 tempD:
Bubble(float tempD) {
x = width/2;
y = height;
diameter = tempD;
}
于是主程序中 new Bubble(64) 与 new Bubble(16) 分别创建了大、小两个不同的气泡——同一个类,两种形态。这正是对象相对"硬编码多个变量"的核心优势:行为模板只写一次,实例差异全部由构造参数注入。
3.2 参数命名约定
视频中强调一个重要的编程习惯:构造函数参数用 tempD 这类带 temp 前缀的名字,而不是直接叫 diameter。原因在于 Java 中成员变量与局部参数同名会造成遮蔽(shadowing)歧义,diameter = diameter 这种写法难以阅读且易出错。虽然可以用 this.diameter = diameter 解决,但 temp 前缀这种显式区分的方式在课程早期更直观。
3.3 构造函数参数的组合扩展
当需要更多自由度时,可以扩展构造函数的参数列表。仓库中 图像气泡示例 展示了"对象作为数据"的用法——构造函数接收 PImage、坐标与直径四个参数:
class Bubble {
float x;
float y;
float diameter;
PImage img;
Bubble(PImage tempImg, float tempX, float tempY, float tempD) {
x = tempX;
y = tempY;
diameter = tempD;
img = tempImg;
}
// ...
}
对应主程序 sketch_15_2_array_images.pde 中,每个气泡被赋予随机花朵图片与随机直径:
Bubble[] bubbles = new Bubble[5];
for (int i = 0; i < bubbles.length; i++) {
int index = int(random(0, flowers.length));
bubbles[i] = new Bubble(flowers[index], 100 + i*100, 300, random(32, 72));
}
这说明构造参数可以是基本类型(float),也可以是对象类型(PImage)——对象可以"持有"其他对象,这是 8.5 节"More on Objects"的重要伏笔。
四、对象的高级主题:对象作为数据、重载与对象间通信
本节对应视频 8.5 More on Objects,主题包括:对象作为其他对象的数据(objects as data for other objects)、方法重载(overloading)、对象之间互相通信(objects communicating with other objects)。
4.1 对象作为数据:对象中持有对象
如前文 3.3 所示,一个类可以把另一个类的实例作为自己的成员变量。仓库中的 ParticleSystem 示例 是更典型的"对象持有对象集合"结构:ParticleSystem 持有一个 ArrayList<Particle> 粒子列表和一个 PVector 原点,负责批量管理粒子对象:
class ParticleSystem {
ArrayList<Particle> particles;
PVector origin;
ParticleSystem(PVector location) {
origin = location.get();
particles = new ArrayList<Particle>();
}
void addParticle() {
particles.add(new Particle(origin.x, origin.y));
}
void run() {
for (int i = particles.size()-1; i >= 0; i--) {
Particle p = particles.get(i);
p.run();
if (p.isDead()) {
particles.remove(i);
}
}
}
}
这种"管理器对象 + 被管理对象"的分层结构是 OOP 组合(composition)思想的直接体现:一个系统对象负责整体生命周期,粒子对象负责自身的更新与绘制。
4.2 方法重载(Overloading)
重载指在同一个类中定义多个同名但参数列表(数量或类型)不同的方法或构造函数,调用时由编译器根据实参自动选择匹配版本。视频中讨论的重载在仓库中有直接实现证据——sketch_16_1_particles_capture/Particle.pde 中的 Particle() 是一个无参构造函数(在 width/2, height/2 处随机方向发射),而 SimpleParticleSystem/Particle.pde 中的 Particle(float x, float y) 则接收指定坐标。两者均为 Particle 的构造函数重载:
// 版本 1:无参构造,中心随机发射
Particle() {
x = width/2;
y = height/2;
float a = random(TWO_PI);
float speed = random(1, 2);
vx = cos(a) * speed;
vy = sin(a) * speed;
}
// 版本 2:接收显式坐标
Particle(float x, float y) {
acceleration = new PVector(0, 0.05);
velocity = new PVector(random(-1, 1), random(-2, 0));
location = new PVector(x, y);
lifespan = 255.0;
}
重载的价值在于同一个概念入口、多种初始化方式:调用方不必记住多个方法名,只需传入自己拥有的信息量即可。
4.3 对象之间的通信:互相调用方法
视频演示了"对象问另一个对象"的通信模式。仓库中的代表作是 8_OOP/sketch_8_4_communication 示例,Particle 类定义了 overlaps(Particle other) 方法,接收另一个 Particle 对象作为参数并检测碰撞:
class Particle {
float x, y;
float r;
Particle(float x_, float y_, float r_) {
x = x_;
y = y_;
r = r_;
}
void display() {
stroke(255);
noFill();
ellipse(x, y, r*2, r*2);
}
boolean overlaps(Particle other) {
float d = dist(x, y, other.x, other.y);
if (d < r + other.r) {
return true;
} else {
return false;
}
}
}
注意 overlaps 通过 other.x、other.y 直接访问了传入对象的成员变量——在 Java/Processing 中,同类的对象之间可以互相访问对方的成员。主程序 sketch_8_4_communication.pde 让 p2 跟随鼠标,并实时询问 p2.overlaps(p1),一旦两个圆重叠就把背景染成红色:
void draw() {
background(0);
if (p2.overlaps(p1)) {
background(255, 0, 0);
}
p2.x = mouseX;
p2.y = mouseY;
p1.display();
p2.display();
}
这是"对象间通信"最直观的形态:一个对象的方法接收另一个对象作为参数,读取对方状态、做出自己的判断。这种方法级协作正是 OOP 从"封装"走向"协作"的关键一步。
4.4 给对象添加交互:气泡点击示例
仓库中的 sketch_8_3_BubbleObject_pop 示例 演示了对象如何响应外部事件:Bubble 类增加 boolean popped 状态标志和 clicked(mx, my) 方法,用 dist() 判断点击是否落在圆内:
class Bubble {
float x;
float y;
float diameter;
boolean popped = false;
Bubble(float tempD) {
x = random(width);
y = height;
diameter = tempD;
}
void clicked(float mx, float my) {
float d = dist(x, y, mx, my);
if (d < diameter/2) {
popped = true;
}
}
void display() {
if (!popped) {
stroke(0);
fill(127, 100);
ellipse(x, y, diameter, diameter);
}
}
// ...
}
主程序在 mousePressed() 中把 mouseX、mouseY 传给每个对象的 clicked():
void mousePressed() {
b1.clicked(mouseX, mouseY);
b2.clicked(mouseX, mouseY);
}
这里体现了"状态封装"的价值:popped 是对象的内部状态,外界只通过公开方法(clicked、display)间接改变与读取,这正是 OOP 封装性的雏形。
五、按值传递 vs 按引用传递:对象参数的本质
本节对应视频 8.6 Pass by Value vs. Pass by Reference,是系列中最容易产生困惑、也最具面试价值的一节。视频讨论"向函数传入参数时,传对象与传基本类型会发生什么"。
5.1 基本类型:按值传递(Pass by Value)
Java/Processing 中,int、float、boolean、char 等基本类型作为参数传入方法时,传递的是值的副本。方法内部对参数的修改不会影响调用方的变量。例如:
void change(float tempD) {
tempD = tempD + 100; // 只修改副本,调用方的值不变
}
调用 change(b.diameter) 后,b.diameter 仍保持原值。原因在于基本类型变量直接存储数值,传参时系统复制了一份数值给形参。
5.2 对象类型:按引用传递(Pass by Reference)
对象变量存储的是指向堆中对象的引用(reference),而非对象本身。把对象作为参数传入方法时,复制的是"引用"本身——形参与实参指向同一个对象。因此,方法内通过引用修改对象的成员变量,会真实反映到调用方:
void moveBubble(Bubble b) {
b.y = b.y - 10; // 直接修改了实参所指对象的成员
}
调用 moveBubble(b1) 后,b1.y 确实减少了 10。这正是 4.3 节中 overlaps(Particle other) 能读取 other.x、other.y 的底层原因:传入的 other 与调用方的 p1 指向同一块内存。
5.3 一个关键区分:修改"对象内部" vs 重新"赋值引用"
视频强调的细节是:通过引用修改对象内部成员(如 b.x = 5)会持久生效;但对形参本身重新赋值(如 b = new Bubble(...))不会影响调用方的引用变量。前者改变的是对象的状态,后者改变的只是形参这个局部引用,两者指向的"目标"在函数返回后仍由调用方持有。
5.4 引用传递在仓库代码中的实际运用
- ParticleSystem 构造函数 中
origin = location.get()特意用get()复制了一个新PVector,避免与传入对象共享同一实例——这正反衬出"不复制就共享引用"的默认行为。 - overlaps(Particle other) 利用引用传递读取对方坐标并计算距离,是"传引用用于读取/协作"的正面用例。
- clicked(float mx, float my) 传入的是
mouseX、mouseY两个基本类型,属于按值传递,方法只读取、不修改,行为符合直觉。
理解这一节的要义在于:基本类型传值、对象传引用(Java 术语为"按引用传值",即传递的是引用值的副本),在实际编程中表现为"对象参数能改状态、基本类型参数不能改调用方变量"。
六、学完本节后:向对象数组与粒子系统进阶
第 8 章是第 9 章《数组(Arrays)》的直接前置。掌握了类与对象后,自然可以写出"对象数组 + 循环"的高密度 sketch。仓库中 9.3 对象数组示例 用数组管理多个气泡:
Bubble[] bubbles = new Bubble[2];
void setup() {
size(640, 360);
bubbles[0] = new Bubble(64);
bubbles[1] = new Bubble(64);
}
而 9.5 弹性数组示例 则用 total 计数器控制激活数量,12_kinect/SimpleParticleSystem 更进一步用 ArrayList 动态管理粒子并支持删除死亡粒子——这些正是第 8 章"类与对象"知识在更大规模程序中的直接延伸。相关课程文档见 9-arrays 章节。
七、配套资源与学习路径
- 本系列 6 个视频小节的完整目录:8-object-oriented-programming
- 直接可运行的 Processing 源码:
- 气泡类与主程序:8_OOP/sketch_8_3_BubbleObject
- 点击交互版:8_OOP/sketch_8_3_BubbleObject_pop
- 对象通信(碰撞检测):8_OOP/sketch_8_4_communication
- 学习路径建议:先回顾第 7 章 7-functions 建立函数封装概念,再完成本 8 章全部 6 个小节,最后进入第 9 章 9-arrays 学习对象数组,形成"函数 → 对象 → 对象集合"的完整知识链。
运行提示:以上全部示例均为 Processing(Java 模式)
.pde源码,可在 Processing IDE 中直接打开对应目录运行,无需额外库(Kinect 相关示例除外,其依赖org.openkinect.processing库及硬件)。仓库中示例还包含 p5.js 版本(如 Tutorials/P5JS/p5.js/09/9.07_p5.js_Drawing_Object_Trails/ES6_Version/sketch.js 中的 ES6class Particle写法),可供对照学习两种语言的类语法差异。