Java의 메서드 내에서 클래스 정의 사용

Java의 메서드 내에서 클래스 정의 사용

---

예:

public class TestClass {

    public static void main(String[] args) {
        TestClass t = new TestClass();
    }

    private static void testMethod() {
        abstract class TestMethod {
            int a;
            int b;
            int c;

            abstract void implementMe();
        }

        class DummyClass extends TestMethod {
            void implementMe() {}
        }

        DummyClass dummy = new DummyClass();
    }
}

위의 코드가 Java에서 완벽하게 합법적이라는 것을 알았습니다. 다음과 같은 질문이 있습니다.

1. 메서드 내부에 클래스 정의를 갖는 용도는 무엇입니까?
2. 클래스 파일이 생성됩니까? DummyClass
3. 이 개념을 객체 지향 방식으로 상상하기는 어렵습니다. 동작 내부에 클래스 정의가 있습니다. 아마도 누군가가 동등한 실제 사례로 나에게 말할 수있을 것입니다.
4. 메서드 내부의 추상 클래스는 나에게 약간 미친 것처럼 들립니다. 그러나 인터페이스는 허용되지 않습니다. 그 뒤에 이유가 있습니까?

---

이를 로컬 클래스라고합니다.

2는 쉬운 것입니다. 예, 클래스 파일이 생성됩니다.

1과 3은 같은 질문입니다. 하나의 메서드를 제외하고 어디에서나 인스턴스화하거나 구현 세부 사항에 대해 알 필요가없는 로컬 클래스를 사용합니다.

일반적인 사용은 일부 인터페이스의 일회용 구현을 만드는 것입니다. 예를 들어 다음과 같은 내용이 자주 표시됩니다.

  //within some method
  taskExecutor.execute( new Runnable() {
       public void run() {
            classWithMethodToFire.doSomething( parameter );
       }
  }); 

이것들을 많이 만들어서 뭔가를해야한다면 이것을 다음과 같이 변경할 수 있습니다.

  //within some method
  class myFirstRunnableClass implements Runnable {
       public void run() {
            classWithMethodToFire.doSomething( parameter );
       }
  }
  class mySecondRunnableClass implements Runnable {
       public void run() {
            classWithMethodToFire.doSomethingElse( parameter );
       }
  }
  taskExecutor.execute(new myFirstRunnableClass());
  taskExecutor.execute(new mySecondRunnableClass());

인터페이스 관련 : 로컬에서 정의 된 인터페이스를 컴파일러에 문제로 만드는 기술적 문제가 있는지 확실하지 않지만 그렇지 않더라도 가치를 추가하지 않습니다. 로컬 인터페이스를 구현하는 로컬 클래스가 메서드 외부에서 사용 된 경우 인터페이스는 의미가 없습니다. 그리고 로컬 클래스가 메서드 내에서만 사용되는 경우 인터페이스와 클래스 모두 해당 메서드 내에서 구현되므로 인터페이스 정의가 중복됩니다.

---

Those are called local classes. You can find a detailed explanation and an example here. The example returns a specific implementation which we doesn't need to know about outside the method.

---

1. The class can't be seen (i.e. instantiated, its methods accessed without Reflection) from outside the method. Also, it can access the local variables defined in testMethod(), but before the class definition.

2. I actually thought: "No such file will be written." until I just tried it: Oh yes, such a file is created! It will be called something like A$1B.class, where A is the outer class, and B is the local class.

3. Especially for callback functions (event handlers in GUIs, like onClick() when a Button is clicked etc.), it's quite usual to use "anonymous classes" - first of all because you can end up with a lot of them. But sometimes anonymous classes aren't good enough - especially, you can't define a constructor on them. In these cases, these method local classes can be a good alternative.

---

The real purpose of this is to allow us to create classes inline in function calls to console those of us who like to pretend that we're writing in a functional language ;)

---

The only case when you would like to have a full blown function inner class vs anonymous class ( a.k.a. Java closure ) is when the following conditions are met

1. you need to supply an interface or abstract class implementation
2. you want to use some final parameters defined in calling function
3. you need to record some state of execution of the interface call.

E.g. somebody wants a Runnable and you want to record when the execution has started and ended.

With anonymous class it is not possible to do, with inner class you can do this.

Here is an example do demonstrate my point

private static void testMethod (
        final Object param1,
        final Object param2
    )
{
    class RunnableWithStartAndEnd extends Runnable{
        Date start;
        Date end;

        public void run () {
            start = new Date( );
            try
            {
                evalParam1( param1 );
                evalParam2( param2 );
                ...
            }
            finally
            {
                end = new Date( );
            }
        }
    }

    final RunnableWithStartAndEnd runnable = new RunnableWithStartAndEnd( );

    final Thread thread = new Thread( runnable );
    thread.start( );
    thread.join( );

    System.out.println( runnable.start );
    System.out.println( runnable.end );
}

Before using this pattern though, please evaluate if plain old top-level class, or inner class, or static inner class are better alternatives.

---

The main reason to define inner classes (within a method or a class) is to deal with accessibility of members and variables of the enclosing class and method. An inner class can look up private data members and operate on them. If within a method it can deal with final local variable as well.

Having inner classes does help in making sure this class is not accessible to outside world. This holds true especially for cases of UI programming in GWT or GXT etc where JS generating code is written in java and behavior for each button or event has to be defined by creating anonymous classes

참고URL : https://stackoverflow.com/questions/2428186/use-of-class-definitions-inside-a-method-in-java