为何object.variable可在主类及其他类中正常工作？

嘿，我刚看了你的问题，其实核心是搞清楚对象引用和实例的关系就行，咱们结合你的Space Invaders代码一步步说：

1. 先搞懂引用和实例的区别 #

你在主类里写的这段代码：

// 声明引用变量
Alien aliens;
Player player;

void setup() {
  // 创建实例，并把实例的地址赋值给引用
  aliens = new Alien();
  player = new Player();
}

• Alien aliens;只是声明了一个引用变量，它就像一个“指针”，暂时没指向任何东西。
• new Alien()才是在内存里真正创建了一个Alien对象（也就是实例），然后把这个实例的内存地址存到aliens引用里。

不管你在主类还是其他类里拿到这个aliens引用，它指向的都是同一个内存里的Alien实例——就像你和朋友都拿着同一把钥匙，打开的是同一扇门，门里的东西（变量）自然是同一个。

2. Processing的默认访问权限帮了忙 #

在Processing里，类的成员变量如果没写private或者public，默认是包级访问权限——简单说就是同一个项目里的所有类都能直接访问这些变量。

比如你的Alien类如果是这样：

class Alien {
  int x; // 默认权限，主类和其他类都能访问
  int y;
}

那主类里写aliens.x = 100;，或者其他类拿到aliens引用后写aliens.x += 5;，操作的都是同一个实例的x变量，所以两边都会看到变化，就像“同时生效”了一样。

3. 怎么让其他类拿到这个引用？ #

比如你的Player类需要和Alien交互，有两种常见方式：

方式一：方法参数传递

修改Player类的方法，把Alien引用传进去：

class Player {
  int playerX = width/2;
  int playerY = height - 50;

  // 传入Alien引用，检测碰撞
  boolean isColliding(Alien alienInstance) {
    // 这里的alienInstance和主类的aliens指向同一个实例
    return (playerX < alienInstance.x + 30 && playerX + 30 > alienInstance.x 
            && playerY < alienInstance.y + 30 && playerY + 30 > alienInstance.y);
  }
}

然后在主类的draw()里调用：

void draw() {
  if (player.isColliding(aliens)) {
    // 处理碰撞逻辑
  }
}

方式二：在其他类里保存引用

初始化Player的时候把aliens传进去，让Player自己存着这个引用：

class Player {
  Alien alienRef; // 保存Alien实例的引用
  int playerX = width/2;
  int playerY = height - 50;

  // 构造方法接收Alien引用
  Player(Alien alienInstance) {
    alienRef = alienInstance;
  }

  void update() {
    // 直接用alienRef访问同一个Alien实例的变量
    if (playerX < alienRef.x) {
      playerX += 1;
    }
  }
}

主类里初始化的时候改成：

void setup() {
  aliens = new Alien();
  player = new Player(aliens); // 把aliens引用传给Player
}

总结一下 #

你觉得object.variable在主类和其他类同时生效，本质是所有地方用的都是指向同一个对象实例的引用——不管从哪个引用进去操作变量，都是在修改同一个内存里的数据，所以所有引用都会看到变化。

内容的提问来源于stack exchange，提问作者Jordan Green