는 방법은 익명이 안에 사용되는 클래스 Java?

https://stackoverflow.com/questions/355167

21-08-2019
|

문제

의 사용은 무엇인 익명의 클래스 Java?우리는 말을 사용법 익명의 클래스의 장점 중 하나 Java?

해결책

"익명 클래스"로, 나는 그것을 취한다. 익명의 내부 수업.

익명의 내부 클래스는 실제로 클래스를 서브 클래스하지 않고 메소드를 재정의하는 것과 같은 특정 "엑스트라"를 가진 객체의 인스턴스를 만들 때 유용 할 수 있습니다.

이벤트 리스너를 첨부하기위한 바로 가기로 사용하는 경향이 있습니다.

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // do something
    }
});

이 방법을 사용하면 구현하는 추가 수업을 만들 필요가 없으므로 코딩을 조금 더 빨리 사용합니다. ActionListener - 실제로 별도의 클래스를 만들지 않고 익명의 내부 수업을 인스턴스화 할 수 있습니다.

나는이 기술을 전체 클래스에 불필요하게 느끼게하는 "빠르고 더러운"작업에만 사용합니다. 정확히 동일한 일을하는 여러 익명의 내부 클래스를 사용하는 것은 실제 클래스에 리팩토링되어야합니다. 내부 클래스 또는 별도의 클래스 인 경우.

다른 팁

익명의 내부 클래스는 효과적으로 폐쇄되므로 람다 표현 또는 "대표"를 모방하는 데 사용할 수 있습니다. 예를 들어이 인터페이스를 사용하십시오.

public interface F<A, B> {
   B f(A a);
}

익명으로 사용하여 a를 만들 수 있습니다 일류 기능 자바에서. 주어진 목록에서 I보다 첫 번째 숫자를 반환하는 다음 방법이 있다고 가정 해 봅시다.

public static int larger(final List<Integer> ns, final int i) {
  for (Integer n : ns)
     if (n > i)
        return n;
  return i;
}

그런 다음 주어진 목록에서 I보다 작은 첫 번째 숫자를 반환하는 다른 방법이 있거나 숫자가 더 작은 경우 :

public static int smaller(final List<Integer> ns, final int i) {
   for (Integer n : ns)
      if (n < i)
         return n;
   return i;
}

이러한 방법은 거의 동일합니다. 일류 함수 유형 F를 사용하여 다음과 같이 하나의 메소드로 이들을 다시 작성할 수 있습니다.

public static <T> T firstMatch(final List<T> ts, final F<T, Boolean> f, T z) {
   for (T t : ts)
      if (f.f(t))
         return t;
   return z;
}

익명 클래스를 사용하여 FirstMatch 메소드를 사용할 수 있습니다.

F<Integer, Boolean> greaterThanTen = new F<Integer, Boolean> {
   Boolean f(final Integer n) {
      return n > 10;
   }
};
int moreThanMyFingersCanCount = firstMatch(xs, greaterThanTen, x);

이것은 정말로 고안된 예이지만, 값인 것처럼 함수를 전달할 수 있다는 것은 매우 유용한 기능이라는 것을 쉽게 알기가 쉽습니다. 보다 "당신의 프로그래밍 언어가 이것을 할 수 있습니까" Joel 자신에 의해.

이 스타일의 Java를 프로그래밍하기위한 멋진 라이브러리 : 기능적 자바.

익명의 내부 클래스는 다음 시나리오에서 사용됩니다.

1.) 현재의 경우를 제외하고 클래스 정의를 사용할 수없는 경우 (하위 분류) 재정의 경우 :

class A{
   public void methodA() {
      System.out.println("methodA");
    }
}
class B{
    A a = new A() {
     public void methodA() {
        System.out.println("anonymous methodA");
     }
   };
}

2.) 인터페이스를 구현하려면, 인터페이스 구현이 현재 경우에만 필요할 때 :

interface interfaceA{
   public void methodA();
}
class B{
   interfaceA a = new interfaceA() {
     public void methodA() {
        System.out.println("anonymous methodA implementer");
     }
   };
}

3.) 인수 정의 된 익명 내부 클래스 :

 interface Foo {
   void methodFoo();
 }
 class B{
  void do(Foo f) { }
}

class A{
   void methodA() {
     B b = new B();
     b.do(new Foo() {
       public void methodFoo() {
         System.out.println("methodFoo");
       } 
     });
   } 
 }

나는 때때로 그것들을지도 인스턴스화를위한 구문 해킹으로 사용합니다.

Map map = new HashMap() {{
   put("key", "value");
}};

Map map = new HashMap();
map.put("key", "value");

많은 진술을 할 때 약간의 중복성을 절약합니다. 그러나 외부 클래스를 원격을 통해 직렬화해야 할 때 문제가 발생했습니다.

그들은 일반적으로 사용 자세한 정보의 양식을 콜백입니다.

내 생각을 말할 수 있을 그들에 비해 장점이 있지 않는 그들을 만들라는 클래스를 모든 시간,하지만 비슷한 개념이 구현되는 훨씬 더 나은 다른 언어(으로 폐쇄하거나 차단)

여기에 스윙 예

myButton.addActionListener(new ActionListener(){
    public void actionPerformed(ActionEvent e) {
        // do stuff here...
    }
});

하지만 그것은 여전히 무너진 자세한 정보,그것보다 훨씬 더 당신을 강제로 정의하는 라는 클래스에 대한 모든 버리신 다음과 같이(지만 상황에 따라고 재사용할 수 있는 여전히 될 수 있는 더 나은 방법)

다른 기능 (예 : 리스너, 런 가능) (스레드를 스폰하기 위해) 등으로 특정 목적을 위해 클래스를 만들어야하는 상황에서 사용합니다.

아이디어는 기능 코드 내부에서 전화를 걸어 다른 곳에서는 참조하지 않으므로 이름을 지정할 필요가 없습니다. 컴파일러는 단지 열거합니다.

그것들은 본질적으로 구문 설탕이며, 일반적으로 더 커짐에 따라 다른 곳으로 이동해야합니다.

그것이 Java의 장점 중 하나인지 확실하지 않지만, 당신이 그것들을 사용한다면 (그리고 우리는 모두 불행히도 우리가 자주 사용한다면), 당신은 그것들이 하나라고 주장 할 수 있습니다.

익명 수업에 대한 지침.

익명 클래스는 동시에 선언되고 초기화됩니다.
익명 클래스는 하나의 클래스 또는 인터페이스 resp로 확장 또는 구현해야합니다.
Anonymouse 클래스에는 이름이 없으므로 한 번만 사용할 수 있습니다.

예 :

button.addActionListener(new ActionListener(){

            public void actionPerformed(ActionEvent arg0) {
        // TODO Auto-generated method stub

    }
});

그렇습니다. 익명의 내부 수업은 확실히 Java의 장점 중 하나입니다.

익명의 내부 수업을 사용하면 주변 클래스의 최종 및 회원 변수에 액세스 할 수 있으며 청취자 등에 편리합니다.

그러나 주요 장점은 주변 클래스/메소드/블록에 단단히 결합 된 내부 클래스 코드가 특정 컨텍스트 (주변 클래스, 메소드 및 블록)를 가지고 있다는 것입니다.

new Thread() {
        public void run() {
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                System.out.println("Exception message: " + e.getMessage());
                System.out.println("Exception cause: " + e.getCause());
            }
        }
    }.start();

이것은 또한 스레드를 사용하는 익명의 내부 유형의 예 중 하나입니다.

새 스레드를 호출하기 위해 익명의 개체를 사용합니다 ..

new Thread(new Runnable() {
    public void run() {
        // you code
    }
}).start();

an 내부 수업 외부 클래스의 인스턴스와 관련이 있으며 지역 계급과 익명 수업. 익명의 클래스를 사용하면 동시에 클래스를 선언하고 인스턴스화 할 수 있으므로 코드를 간결하게 만듭니다. 우리는 이름이 없기 때문에 로컬 클래스가 한 번만 필요할 때 사용합니다.

예제를 고려하십시오 문서 우리가있는 곳 Person 수업:

public class Person {

    public enum Sex {
        MALE, FEMALE
    }

    String name;
    LocalDate birthday;
    Sex gender;
    String emailAddress;

    public int getAge() {
        // ...
    }

    public void printPerson() {
        // ...
    }
}

그리고 검색 기준과 일치하는 멤버를 인쇄하는 방법이 있습니다.

public static void printPersons(
    List<Person> roster, CheckPerson tester) {
    for (Person p : roster) {
        if (tester.test(p)) {
            p.printPerson();
        }
    }
}

어디 CheckPerson 다음과 같은 인터페이스입니다.

interface CheckPerson {
    boolean test(Person p);
}

이제 검색 기준을 다음과 같이 지정하기 위해이 인터페이스를 구현하는 익명 클래스를 사용할 수 있습니다.

printPersons(
    roster,
    new CheckPerson() {
        public boolean test(Person p) {
            return p.getGender() == Person.Sex.MALE
                && p.getAge() >= 18
                && p.getAge() <= 25;
        }
    }
);

여기서 인터페이스는 매우 간단하고 익명 클래스의 구문은 다루기 힘들고 불분명 해 보입니다.

Java 8 용어를 소개했습니다 기능 인터페이스 이것은 하나의 추상 방법 만있는 인터페이스이므로 우리는 말할 수 있습니다. CheckPerson 기능 인터페이스입니다. 우리는 사용할 수 있습니다 람다 표현 이를 통해 기능을 메소드 인수로 전달할 수 있습니다.

printPersons(
                roster,
                (Person p) -> p.getGender() == Person.Sex.MALE
                        && p.getAge() >= 18
                        && p.getAge() <= 25
        );

표준 기능 인터페이스를 사용할 수 있습니다 Predicate 인터페이스 대신 CheckPerson, 필요한 코드의 양을 더욱 줄입니다.

익명의 내부 클래스는 다른 객체에 대해 다른 구현을 제공하면서 유익 할 수 있습니다. 그러나 프로그램 가독성에 문제가 생기기 때문에 매우 드물게 사용해야합니다.

Class-Finalization에서 익명 클래스의 주요 사용 중 하나 파이널 라이저 가디언. Java 세계에서는 최종 방법을 사용하여 실제로 필요할 때까지 피해야합니다. 하위 클래스에 대한 최종 메소드를 재정의하면 항상 호출해야합니다. super.finalize() 또한 슈퍼 클래스의 최종 방법은 자동으로 호출되지 않으며 메모리 누출에 어려움을 겪을 수 있으므로.

따라서 위에서 언급 한 사실을 고려하면 다음과 같은 익명 클래스 만 사용할 수 있습니다.

public class HeavyClass{
    private final Object finalizerGuardian = new Object() {
        @Override
        protected void finalize() throws Throwable{
            //Finalize outer HeavyClass object
        }
    };
}

이 기술을 사용하여 자신과 다른 개발자가 전화를 걸었습니다. super.finalize() 각 하위 클래스에서 HeavyClass 마무리 방법이 필요합니다.

이 방법으로 익명 클래스를 사용할 수 있습니다

TreeSet treeSetObj = new TreeSet(new Comparator()
{
    public int compare(String i1,String i2)
    {
        return i2.compareTo(i1);
    }
});

여기서 언급 한 사람은 없지만 익명 클래스를 사용하여 일반적인 유형 인수를 보유 할 수도 있습니다. (유형 삭제로 인해 일반적으로 잃어버린):

public abstract class TypeHolder<T> {
    private final Type type;

    public TypeReference() {
        // you may do do additional sanity checks here
        final Type superClass = getClass().getGenericSuperclass();
        this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
    }

    public final Type getType() {
        return this.type;
    }
}

이 수업을 익명으로 인스턴스화한다면

TypeHolder<List<String>, Map<Ineger, Long>> holder = 
    new TypeHolder<List<String>, Map<Ineger, Long>>() {};

그런 다음 holder 인스턴스에는 전달 된 유형의 비 소멸 정의가 포함됩니다.

용법

이것은 유효성 검사기/사막화기를 구축하는 데 매우 편리합니다. 또한 반사로 일반 유형을 인스턴스화 할 수 있습니다 (그래서 당신이하고 싶었다면 new T() 매개 변수 유형에서 - 환영합니다!).

단점/제한

일반 매개 변수를 명시 적으로 전달해야합니다. 그렇게하지 않으면 유형 매개 변수 손실로 이어질 수 있습니다.
각 인스턴스화는 컴파일러가 추가 클래스를 생성하는 데 비용이 듭니다.

코드를 최적화하는 가장 좋은 방법입니다. 또한 클래스 또는 인터페이스의 우선적 인 방법에 사용할 수 있습니다.

import java.util.Scanner;
abstract class AnonymousInner {
    abstract void sum();
}

class AnonymousInnerMain {
    public static void main(String []k){
        Scanner sn = new Scanner(System.in);
        System.out.println("Enter two vlaues");
            int a= Integer.parseInt(sn.nextLine());
            int b= Integer.parseInt(sn.nextLine()); 
        AnonymousInner ac = new AnonymousInner(){
            void sum(){
                int c= a+b;
                System.out.println("Sum of two number is: "+c);
            }
        };
        ac.sum();
    }

}

an 익명의 내부 수업 다시는 참조되지 않을 객체를 만드는 데 사용됩니다. 이름이없고 같은 진술로 선언되고 작성되었습니다. 이것은 일반적으로 객체의 변수를 사용하는 곳에 사용됩니다. 변수를 다음으로 바꿉니다 new 키워드, 생성자에 대한 호출 및 내부의 클래스 정의 { 그리고 }.

Java에서 스레드 프로그램을 작성할 때는 보통 이렇게 보일 것입니다.

ThreadClass task = new ThreadClass();
Thread runner = new Thread(task);
runner.start();

그만큼 ThreadClass 여기에서 사용되는 것은 사용자 정의입니다. 이 클래스는이를 구현합니다 Runnable 스레드를 작성하는 데 필요한 인터페이스. 에서 ThreadClass 그만큼 run() 메소드 (만 메소드 Runnable)도 구현해야합니다. 제거하는 것이 분명합니다 ThreadClass 더 효율적일 것이므로 익명의 내부 클래스가 존재하는 이유입니다.

다음 코드를보십시오

Thread runner = new Thread(new Runnable() {
    public void run() {
        //Thread does it's work here
    }
});
runner.start();

이 코드는 작성된 참조를 대체합니다 task 맨 위에서 가장 예를 들어. 별도의 클래스를 갖지 않고 익명의 내부 수업은 Thread() 생성자는 Runnable 인터페이스하고 run() 방법. 방법 run() 스레드가 요구하는 작업을 수행하는 내부에 진술이 포함됩니다.

익명의 내부 수업이 Java의 장점 중 하나인지에 대한 질문에 대답하면 현재 많은 프로그래밍 언어에 익숙하지 않기 때문에 확실하지 않다고 말해야합니다. 그러나 내가 말할 수있는 것은 확실히 더 빠르고 쉬운 코딩 방법이라는 것입니다.

참고 자료 : Sams는 21 일 7 일에 Java를 가르치고 있습니다.

한 가지 더 이점 :
Java가 여러 상속을 지원하지 않으므로 "스레드"클래스를 익명 클래스로 사용하는 경우 클래스에는 여전히 다른 클래스가 확장 할 공간이 남아 있습니다.

라이센스 : CC-BY-SA ~와 함께 속성

제휴하지 않습니다 StackOverflow