What is a "this-escape" warning, and how do I deal with it?

Question

I struggle to find resources on this, and yet, so many of my classes are running into this error when I compile my code on the latest Java (21).

Here is a code example.

public class ThisEscapeExample
{

        public Object o;

        public ThisEscapeExample()
        {

                this.overridableMethod();

        }

        public void overridableMethod()
        {

                this.o = new Object();

        }

}

And here is my compilation command.

javac -Xlint:all ThisEscapeExample.java
ThisEscapeExample.java:9: warning: [this-escape] possible 'this' escape before subclass is fully initialized
                this.overridableMethod();
                                      ^
1 warning

Answer 1

Here is the JDK Bug System entry that introduces this new warning - https://bugs.openjdk.org/browse/JDK-8299995

Long story short, the this-escape warning is to warn you when a subclass may be able to @Override a method that is also called in the superclass' constructor.

This is dangerous because overriding a method that is used in the constructor allows subclass' to unintentionally introduce a bug during a subclass' initialization. What if that method depends on state that has not yet been created because we are still in the super constructor? After all, you cannot do anything in the subclass' constructor before calling the super constructor (for now).

There are a few ways to remedy this.

1. Only use methods in the constructor that cannot be overridden.

   • static methods.

   • final methods.

     • MUST BE IN THE SAME CLASS AS YOUR CONSTRUCTOR, YOU CANNOT USE PARENT FINAL INSTANCE METHODS IN THE CHILD CLASS' CONSTRUCTOR

   • private methods.

2. Make the class itself final.

3. Don't pass in/use this to begin with - instead, pass in the particular component of this that you needed.

   • Basically, quit being lazy and be explicit with what you need. Don't just pass in your God object -- pass in only the specific attributes you need.

Please note - these rules apply recursively. Meaning, when you call a method in the constructor, not only does that method have to be "not-overridable", but the methods that that method passes this into must ALSO match one of the rules above. If your top-level method is not overridable, but one of the methods inside of it is, and that method has this in its scope, then you will receive a this-escape error upon compilation. Here is an example.

import javax.swing.*;

public class GUI
{

   private final JFrame frame;

   public GUI()
   {
   
      this.frame = new JFrame();
   
      this.frame.add(this.createBottomPanel());
   
   }

   //final! Does that mean we are safe?
   final JPanel createBottomPanel()
   {
   
      final JButton save = new JButton();
   
      save
         .addActionListener
         (
            /*
             * No. We get the warning here at the start of this lambda.
             * The reason is because we have given this lambda the
             * ability to call this.toString(), and we don't know when
             * it will do that. Maybe now, maybe later. But if it does
             * it now, then we could end up doing things before the
             * object is fully created. And if that were to happen, then
             * that would be a this-escape. So, the warning occurs here,
             * to let you know that it is possible.
             */
            actionEvent ->
            {
           
               this.toString();
           
            }
           
         )
         ;
   
      return null;
   
   }

}