Why use method local abstract inner classes

Question

One of the legal modifiers you can use with method local inner classes is abstract.

For example:

public class Outer {     public void method(){         abstract class Inner{         }     } } 

Is there any situation where you would actually use this?

You have to know this for the SCJP exam.

Answer 1

The are some invalid assumptions in the original question. That something is legal/valid Java doesn't mean that it is something that you need to use, or need to know.

I can't recall that the SCJP contains odd corner case questions.

I tried to come up with a case where I would have used an abstract class declared in a method, but everything looks very odd, and reeks of bad design. Here's however a code example that I came up with (still bad code design IMHO)

public class BatchExecutor {      public static enum ResultNotification {         JMS,         MAIL     };      public Runnable createRunnable(ResultNotification type) {         abstract class Prototype implements Runnable {             public void run() {                 performBusinessLogic();                 publishResult();             }              abstract void publishResult();         }          switch (type) {             case JMS: {                 return new Prototype() {                     void publishResult() {                         //Post result to JMS                     }                 };             }             case MAIL: {                 return new Prototype() {                     void publishResult() {                         //Post result to MAIL                     }                 };             }         }         return null;     }      private void performBusinessLogic() {         //Some business logic     }  } 

Answer 2

I can think only in this case

class Outer {     public void method() {         abstract class A {             void bar(){}             abstract void foo();         }         class B extends A {             @Override             void foo() {             }         }         final class C extends A {             @Override             void foo() {             }         }         A a1 = new B();         A a2 = new C();     } } 

But I can't imagine real usage