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 method with a single int parameter, with the parameter highlighted in the signature and again in the body.

   public void addScore(int points)
   {
       score = score + points;
   }

   `int points` inside the parentheses is the parameter. It declares a variable that only exists inside this method, and whoever calls decides what goes in it.

   Inside the body you use it like any other variable.

2. Step 2

   On your screen Three different calls to the same method with different values.

   addScore(1);    // a coin
   addScore(10);   // a gem
   addScore(50);   // the treasure chest

   One method, three behaviors. That is the whole point.

   Without the parameter you would need addOne(), addTen() and addFifty(), and a fourth method the moment you invent a new pickup.

3. Step 3

   On your screen A call passing a variable whose name differs from the parameter name.

   int gemValue = 10;
   addScore(gemValue);   // points becomes 10 inside the method

   The names do not have to match, and this is worth pausing on.

   `gemValue` is the caller's name for it. `points` is the method's name for it. The VALUE is copied across; the names are private to each side.

   Inside addScore there is no such thing as gemValue. Outside it, there is no such thing as points.

4. Step 4

   On your screen A method taking two parameters separated by a comma.

   public void moveBy(int dx, int dy)
   {
       setLocation(getX() + dx, getY() + dy);
   }
   
   moveBy(3, 0);    // right
   moveBy(0, -3);   // up

   Two parameters, separated by a comma. The caller must supply two arguments, in the same order.

   Order is positional, not by name: `moveBy(0, -3)` puts 0 into dx and -3 into dy. Swap them and the actor goes the wrong way, with no error, because both are ints.