Build it step by step

Every step below leaves a scenario that compiles and runs. If you stop halfway you will have something that works, not something broken. Follow along in Greenfoot rather than reading straight through.

1. Step 1

   On your screen A score variable declared inside the act method, with the world showing a score stuck at one.

   // BROKEN. The score never grows past 1.
   public void act()
   {
       int score = 0;
       if (isTouching(Coin.class))
       {
           removeTouching(Coin.class);
           score = score + 1;
       }
   }

   Read this carefully, because it looks completely reasonable.

   act() runs every frame. Every frame, the FIRST thing it does is `int score = 0;`, building a brand new box and putting zero in it. Whatever last frame counted is gone before this frame even checks for a coin.

   It compiles. It runs. The score is 1 at best, and usually 0. No error, ever.

2. Step 2

   On your screen The same variable moved outside act, into the class body, with the score now climbing.

   public class Player extends Actor
   {
       private int score = 0;      // OUTSIDE act, inside the class
   
       public void act()
       {
           if (isTouching(Coin.class))
           {
               removeTouching(Coin.class);
               score = score + 1;
           }
       }
   }

   One line moved. That is the entire fix.

   `score` now belongs to the OBJECT rather than to one run of one method. It is created once, when the player is created, and it survives every frame after that.

   Look at where it sits: inside the class braces, outside every method. That position is what makes it an instance variable, not the word private.

3. Step 3

   On your screen Two player actors in the same world with different scores shown.

   And each OBJECT gets its own. Two players in the world means two separate scores, counting independently.

   That is 1.3 coming back: objects share behavior, because that comes from the class, but they do not share state. An instance variable is exactly the state that is not shared.

4. Step 4

   On your screen A getter method returning the private score field.

   private int score = 0;
   
   public int getScore()
   {
       return score;
   }

   `private` means only this class can touch the variable directly. That sounds inconvenient and is actually protection: nothing else can set your score to a million by accident.

   When something outside genuinely needs to know, you give it a method. `getScore()` hands the value out without handing over control, which is exactly the return type work from 3.4.