Can someone explain me how this code works? (it's about using "final")

Question

I am a beginner in java programming and I am currently studying programming for libGDX. In the book "Beginning Java Game Development with libGDX" there are instructions on how to make some basic games. One of them (the game that is an introduction to processing mouse and touch input) we make a game where balloons spawn on the left side of the screen and these balloons keep moving to the right side and each of them is removed from the game either when you click on it, or when it goes off screen (when X is greater than the width of the screen) I have a problem understanding the use of final in this code:

spawnTimer += delta;

// check time for next balloon spawn
if(spawnTimer > spawnInterval)
{
    spawnTimer -= spawnInterval;
    final Balloon b = new Balloon();
    b.addListener
    (
        new InputListener()
        {
            public boolean touchDown (InputEvent event, float x, float y, int pointer, int buttoon)
            {
                popped++;
                b.remove();
                return true;

            }
        }
    );
    mainStage.addActor(b);
}

The code inside of the if statement is responsible for creating the instance of an actor called Balloon and add to it an Input Listener so it will execute this code:

popped++;
b.remove();
return true;

when it is touched. In the book final wasn't used for creating a new instance of Balloon and I only used it because Android Studio made me do it ( it said that I couldn't use b.remove() because it is a code that will be used inside the instance or something like that) and it seems like it works. I want to know why using final works.

Is the final object disposed of when the method (update()) is finished doing its thing (and that's why it won't bug then the line is used again)?

When the b.remove() is executed, how will it know what it is going to remove?

And when I create an instance like that I thought it was giving it a name but it is just creating an instance and a pointer, right? So, if I kind of loose that pointer I just created I can only get another one from the inside of the instance (or maybe from the mainStage)?

Answer 1

So, when you're calling new InputListener() {... you probably already understand that you're creating an anonymous inner class. One of the major benefits of using an anonymous inner class is that you can declare it inside of a class member (such as a method) and therefore the inner class can have access to elements of the enclosing member, such as the variable Balloon b. You have captured the value that's a variable of an enclosing method. In other languages this is commonly called a 'closure'. if you examine the bytecode that is produced, you will see that your new inner class will have a field of type Balloon and a constructor parameter of type Balloon. Using the constructor, the variable b is copied into the field of your inner class.

Before Java, there have been plenty of programming languages that allowed you capture values in this way, but many of them have caused difficult-to-see problems in code, because those variables can normally be freely changed within a method. The touchDown method of your inner class will probably not be executed immediately after b.addListener gets called. What if code in that enclosing method assigns a different object to b before touchDown is executed? Which reference of b should be used when it's being executed? The original one, or the new one?

The way that Java solves this problem is by insisting that any method variable that is captured by an inner class be final, which ensures that it will not be changed later in the method. If you attempt to capture a variable that is not final, the compiler will fail with an error.

As a side-note, Java 8 style lambda expressions compile down internally to inner classes, but they actually have slightly different rules for capturing variables, but the results are the same. Instead of insisting that any variable captured be explicitly final, the enclosing method is statically analyzed to ensure that no code assigns to that variable. If it does, you will get an error that the variable must be 'effectively' final.