Question: I'm programming a big game in Java and I'm trying to optimize the code but also to keep the code neat and well organized. Now I am unsure if I should use the public static field of single classes that have a couple of variables that are used by a lot of instances. 

For example the class camera has an x and y position that define what part of the map the user is looking at and what needs to be drawn to the screen. Currently I'm benchmarking with 50 000 units and I have the following options to draw them. 

1: Store a reference to the instance of the camera in each unit and call getX() and getY() when it should be drawn:

```
public void paint()   
{   
   paint(x - camera.getX(), y - camera.getY());  
}  

```

2: Supply the coordinates of the camera as arguments to each unit when it should be drawn:

```
public void paint(int cameraX, int cameraY)  
{   
   paint(x - cameraX, y - cameraY);  
}

```

3: Make the x and y variables of the camera class static:

```
public void paint()   
{   
   paint(x - Camera.x, y - Camera.y);  
}

```

I'm interested as what is generally seen as the best solution and if it affects performance. Perhaps there are more ways to do this I haven't thought of yet? 

Thanks!

Answer: 
If you have only one camera at all times, i would choose the third way. Otherwise i would choose the second way.

I think that from performance point of view, using a public static field is a good idea. As far as code readability goes, if it is easily understood that there is only one camera at all times, this should be ok too.
Overall the second should provide a good balance; it also will ensure that you don't accidently hold references to the camera beyond when you anticipate, or that you don't run into conflicts with stateful static fields.

Keep in mind that you should still profile the performance regardless of whatever solution you choose--but don't anticipate this being a bottleneck until you have evidence that it is one.