Java 设置基于分辨率的长度的最佳时间是什么？

此问题将使用Processing 3+代码语法

假设我有一个类

Bullet

，它在玩家的x位置以设定的高度生成

class Bullet
{
    int x;
    int y = player.y;
    int w = SIZE_X / 150;
    int h = SIZE_Y / 50;

    Bullet()
    {
        x = player.x;
    }

    void display()
    {
        rect(x, y, w, h);
    }
}

假设我正在使用这个

Bullet

类在我的太空入侵者游戏中生成一颗子弹。在

SpaceInvaders.pde

中，我将创建一个代表我的飞船的

Player

类。这个

Player

有一个

Player.x

和

Player.y

组件。因此，在

SpaceInvaders.pde

中调用

player.shoot（）

时，我将在

ArrayList bulletList

中创建一个新的

Bullet

我想知道设置某些变量以确保我的计算机尽可能少地进行计算的最佳时间是什么

现在，我可以想出三种设置方法：

就像上面的代码一样

或：

//在SpaceInvaders.pde中：
int BulletYPos=player.y；
int bulletWidth=大小X/somenumber；
int bullet height=尺寸\ Y/数字；
//其中，SIZE_X/SIZE_Y表示草图的大小
//班内球员：
职业选手
{
// 
空射（）
{
新项目符号（x、BulletYPos、bulletWidth、bulletHeight）；
}
}
`
//类内项目符号：
等级子弹
{
int x，y，w，h；
项目符号（整数x，整数y，整数w，整数h）
{
x=x；
y=_y；
w=_w；
h=_h；
}
无效显示（）
{
rect（x，y，w，h）；
}
}

这当然意味着

SIZE\ux/somenumber

只能计算一次。但是，我也可以看到，由于计算机赋值的周期增加，速度会慢得多

我的问题基本上可以归结为：

如果我在

class Bullet

中说

int y=player.y

，它是计算一次还是每次生成一个新的Bullet类

---

我的理解是，

Bullet

类的构造函数

Bullet（）

中的代码在每次实例化新的

Bullet

时都会运行。但这是否意味着它不会每次都确定我的

inty，w，h

，并且在程序启动时只确定一次？还是每次我创建

Bullet

类的新实例时都会秘密调用它？

在您发布的代码中，这些行只运行一次：

int bulletWidth = SIZE_X / somenumber; 
int bulletHeight = SIZE_Y / somenumber;

每次创建

Bullet

类的新实例时，这些行都将运行：

Bullet(int _x, int _y, int _w, int _h)
{
    x = _x;
    y = _y;
    w = _w;
    h = _h;
}

class Bullet
{
    int x;
    int y = player.y;
    int w = SIZE_X / 150;
    int h = SIZE_Y / 50;

每次创建

Bullet

类的新实例时，这些行也将运行：

Bullet(int _x, int _y, int _w, int _h)
{
    x = _x;
    y = _y;
    w = _w;
    h = _h;
}

class Bullet
{
    int x;
    int y = player.y;
    int w = SIZE_X / 150;
    int h = SIZE_Y / 50;

这些值不会在每次使用时重新计算

请注意，您可以使用函数自己进行测试。试着这样做：

int sketchX = getSketchX();

void setup() {
  size(100, 100);

  for(int i = 0; i < 10; i++) {
    Bullet b = new Bullet();
  }
}

int getSketchX() {
  println("getSketchX");
  return 42;
}

class Bullet {
  int classX = getClassX();

  public Bullet() {
    int constructorX = getConstructorX();
  }

  int getClassX() {
    println("getClassX");
    return 42;
  }

  int getConstructorX(){
    println("getConstructorX");
    return 42;
  }
}

int sketchX=getSketchX（）；
无效设置（）{
大小（100100）；
对于（int i=0；i<10；i++）{
项目符号b=新项目符号（）；
}
}
int getSketchX（）{
println（“getSketchX”）；
返回42；
}
等级子弹{
int classX=getClassX（）；
公众子弹（）{
int constructorX=getConstructorX（）；
}
int getClassX（）{
println（“getClassX”）；
返回42；
}
int getConstructorX（）{
println（“getConstructorX”）；
返回42；
}
}

退一步说，我想说您可能太担心性能了。如果你还没有做过任何基准测试，你不应该千方百计确保你的计算机尽可能少地进行计算。为每一个子弹做一些基本的数学运算不会引起任何问题。（将其与计算机绘制屏幕所需的工作量进行比较，你就会明白我的意思。）

这里有一句名言：这意味着，如果您甚至还没有对代码进行度量，那么就不必过于担心优化代码

如果您测量代码并发现

Bullet

构造函数确实花费的时间太长，那么您可以继续担心它。但是你会发现你的程序花在画图上的时间比把两个数字分开要多得多

回答您的问题：设置基于分辨率的长度的最佳时间是任何可读性最强的地方

---

最具可读性的位置取决于不同的代码片段在大脑中的组合方式。和编码中的许多事情一样，这是一种折衷：如果有很多不变的常量，那么将初始化放在草图的顶部可能是有意义的，但是如果将来可以更改每个项目符号的大小，那么将初始化放在

项目符号

构造函数中可能更具可读性。没有一个“最佳”位置可以放置代码。

屏幕上是否同时有最多的项目符号？与其每次都创建一个新的项目符号，不如使用一个项目符号库，跳过问题的这一方面。您是否搜索？如果您想阅读有关该主题的内容，这就是我刚才所说的。如果需要，我可以详细阐述这个主题，但是tl；dr is：你有一个“池管理器”，它要么提供一个可用的对象，要么在需要时创建一个新的对象，所以你只创建所述对象的最小数量。虽然我很感谢你在这里的笔记，但我认为他们根本没有回答我的问题。这是一种假设情况。我只是对CPU周期之间的假设差异感兴趣。我只是好奇，看看什么是创建基于分辨率长度的对象的最有效的方法，就像这样。我不是说你应该这样编码，我是说我对它背后的计算机科学感兴趣。非常有用的见解！我完全同意我不应该太担心这样的事情。但是，这是一个纯粹出于兴趣而不是出于必要的问题。我不会以这种方式开始编写所有代码，因为我可以在一个简单的处理草图中牺牲这样的性能增量，因为我的计算机很可能只运行草图。但是，我感兴趣的是哪种方式需要最少的CPU