How can I avoid synthetic access compiler warning with inline-anonymous class declaration and what does it mean?

I have the following code:

public class SomeClass {
   //InterfaceUpdateListener is an interface
   private InterfaceUpdateListener listener = new InterfaceUpdateListener(){
        public void onUpdate() {
           SomeClass.this.someMethod();  //complier complains on this line of cod开发者_开发技巧e
        }
   };

   private void someMethod() {
     //do something in here on an update event occuring
   }

   //other code to register the listener with another class...
}

My compiler in Eclipse complains that

Access to enclosing method 'someMethod' from type SomeClass is emulated by a synthetic accessor method.

Can anyone explain exactly

1. what this means,
2. what the possible ramifications might mean if I leave it as is (since its only a warning), and
3. how I might fix it?

Thanks

---

I would just deactivate the rule (i.e. make the compiler not generate warning for this). If the construction is legal, and if an additional method is added by the compiler to support it, then it's the way it must be done.

I doubt there is a significant loss of performance caused by this synthetic method. The JIT must inline it anyway if necessary.

---

How about this? There's only one class declaration that has to be keept by your JVM (PermGen), implementing class is still not available outside SomeClass (I think this is the only legal intention to write an nested class anyway) and last but not least you might also provide a second constructor with InterfaceUpdateListener as argument (if needed for mor flexibility and testability). And ther's no need to change warnings.

expect

public interface InterfaceUpdateListener {
    public void onUpdate();
}

is provided, SomeClass might be implemented like this

public class SomeClass {
   //InterfaceUpdateListener is an interface
   private final InterfaceUpdateListener listener;
   private static class SomeClassInterfaceUpdateListener implements InterfaceUpdateListener {
       private final SomeClass internal;
       public SomeClassInterfaceUpdateListener(final SomeClass aSomeClass) {
           internal = aSomeClass;
       }
       @Override
       public void onUpdate() {
           internal.someMethod();  //complier complains on this line of code
       }
   }
   public SomeClass() {
       listener =  new SomeClassInterfaceUpdateListener(this);
   }
   private void someMethod() {
     //do something in here on an update event occuring
   }
}