Learning Processing 第 8 章:Processing/Java 面向对象编程(OOP)实战指南

原创2026-10-12 17:47:301,718 阅读
文章标签:教程文档示例工程

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();
}

关键语法点:

  1. 声明(declaration):Bubble b1; 只声明一个指向 Bubble 的引用,此刻对象还不存在。
  2. 实例化(instantiation):new Bubble(64) 调用构造函数真正创建对象,并把返回的引用赋给 b1。new 是 Java/Processing 中创建对象的关键字,其作用是分配内存并执行构造函数。
  3. 调用方法(invocation):通过点号 . 调用对象的方法,如 b1.display()。
  4. 独立实例: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 章节。

七、配套资源与学习路径

运行提示:以上全部示例均为 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 中的 ES6 class Particle 写法),可供对照学习两种语言的类语法差异。

登录后查看全文
website-archive