Java에서 익명 내부 클래스는 어떻게 사용됩니까?
Java에서 익명 클래스는 어떤 용도로 사용됩니까?어나니머스 클래스를 사용하는 것도 자바만의 장점 중 하나라고 할 수 있을까요?
어나니머스 내부 클래스는 오버라이드 메서드와 같은 특정 "추가"를 사용하여 객체의 인스턴스를 만들 때 실제로 클래스를 하위 클래스로 분류할 필요 없이 유용할 수 있습니다.
이벤트 청취자를 연결하기 위한 숏컷으로 사용하는 경향이 있습니다.
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// do something
}
});
을 좀 빠르게 할 수 . 이 방법을 사용하면 코딩을 할 때, '코딩'을 때문입니다. 왜냐하면 이 방법을 사용하면ActionListener의 클래스를 할 수 -- 실실 、 실 -- 、 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 。
저는 이 기술을 수업 전체를 불필요하게 만드는 "빠르고 더러운" 작업에만 사용합니다.동일한 작업을 수행하는 여러 개의 익명 내부 클래스가 있는 경우 내부 클래스든 개별 클래스든 실제 클래스로 리팩터링해야 합니다.
익명 내부 클래스는 사실상 폐쇄이므로 람다 표현식 또는 "위임자"를 에뮬레이트하는 데 사용할 수 있습니다.예를 들어 다음 인터페이스를 예로 들 수 있습니다.
public interface F<A, B> {
B f(A a);
}
이를 익명으로 사용하여 Java에서 퍼스트 클래스 함수를 만들 수 있습니다.주어진 목록에서 i보다 큰 첫 번째 숫자를 반환하는 다음 방법이 있다고 가정합니다. 또는 더 큰 숫자가 없는 경우 i를 반환한다고 가정합니다.
public static int larger(final List<Integer> ns, final int i) {
for (Integer n : ns)
if (n > i)
return n;
return i;
}
또한 지정된 목록에서 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 를 사용하면, 다음과 같이 그것들을 1 개의 방법으로 고쳐 쓸 수 있습니다.
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이 직접 쓴 "Can Your Programming Language Do This"를 참조하십시오.
다음과 같은 스타일로 Java를 프로그래밍하기 위한 훌륭한 라이브러리:기능하는 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 map = new HashMap() {{
put("key", "value");
}};
대
Map map = new HashMap();
map.put("key", "value");
많은 put 스테이트먼트를 실행할 때 용장성을 절약할 수 있습니다.그러나 외부 클래스를 리모트로 serialize 할 필요가 있을 때도 문제가 있었습니다.
콜백의 장황한 형태로 자주 사용됩니다.
없는 것과 비교하면 장점이라고 할 수 있지만, 같은 개념은 다른 언어(클로저나 블록 등)에서도 훨씬 잘 구현되어 있습니다.
여기 그네의 예가 있습니다.
myButton.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
// do stuff here...
}
});
아직 장황한 설명이지만 이렇게 모든 리스너에 대해 명명된 클래스를 정의하도록 강요하는 것보다 훨씬 낫다(상황과 재사용에 따라 다르지만 그래도 더 나은 접근법일 수 있음).
예를 들어 리스너, 실행 가능(스레드 생성용) 등 다른 함수 내에서 특정 목적을 위해 클래스를 만들어야 하는 상황에서 사용합니다.
즉, 함수의 코드 내부에서 호출하기 때문에 다른 곳에서 참조하지 않기 때문에 이름을 붙일 필요가 없습니다.컴파일러는 그것들을 열거할 뿐입니다.
그것들은 본질적으로 통사적인 설탕이고, 일반적으로 더 커지면 다른 곳으로 옮겨져야 합니다.
자바의 장점 중 하나인지는 잘 모르겠지만, 만약 여러분이 자바를 사용한다면(불행하게도 우리 모두 자주 사용한다면), 여러분은 자바를 자바의 장점 중 하나라고 주장할 수 있습니다.
어나니머스 클래스 가이드라인
어나니머스 클래스는 선언과 초기화가 동시에 이루어집니다.
어나니머스 클래스는 1개의 클래스 또는 인터페이스 응답만으로 확장 또는 구현해야 합니다.
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();
이 또한 스레드를 사용하는 익명 내부 유형에 대한 예제 중 하나입니다.
내부 클래스는 외부 클래스의 인스턴스와 관련지어지며 Local class와 Anonymous class의 두 가지 특별한 종류가 있습니다.익명 클래스를 사용하면 클래스를 선언하는 동시에 인스턴스화할 수 있으므로 코드가 간결해집니다.이름이 없기 때문에 현지 수업이 한 번만 필요할 때 사용합니다.
doc의 예를 참고해 주세요.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이를 통해 필요한 코드 양을 더욱 줄일 수 있습니다.
새 스레드를 호출하기 위해 익명 개체를 사용합니다.
new Thread(new Runnable() {
public void run() {
// you code
}
}).start();
익명 내부 클래스는 개체마다 다른 구현을 제공하면서 유용합니다.단, 프로그램 가독성에 문제가 생기기 때문에 매우 신중하게 사용해야 합니다.
최종 결선제 가디언이라고 불리는 클래스 파이널라이제이션에서 익명의 클래스가 주로 사용되는 것 중 하나입니다.Java 세계에서는 꼭 필요할 때까지 finalize 메서드를 사용하지 않도록 해야 합니다.하위 클래스의 최종 메서드를 재정의할 때는 항상 호출해야 합니다.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키워드, 컨스트럭터 호출 및 내부 클래스 정의{그리고.}.
스레드 프로그램을 Java로 작성할 때 보통 다음과 같이 표시됩니다.
ThreadClass task = new ThreadClass();
Thread runner = new Thread(task);
runner.start();
그ThreadClass여기서 사용하는 것은 사용자 정의입니다.이 클래스에서는,Runnable스레드 작성에 필요한 인터페이스입니다.에서ThreadClass그run()method(의 메서드만)Runnable)도 실장할 필요가 있습니다.제거한다는 것은 분명하다.ThreadClass그게 바로 '익명의 내부 계층'이 존재하는 이유죠
다음 코드를 보세요.
Thread runner = new Thread(new Runnable() {
public void run() {
//Thread does it's work here
}
});
runner.start();
이 코드는 다음에 대한 참조를 대체합니다.task를 참조해 주세요.별도의 클래스가 아닌 내부 어나니머스 클래스는Thread()는 이름 하고 이 오브젝트를 구현합니다.Runnable 및 합니다.run() the. 법법run()에는 스레드에 필요한 작업을 수행하는 문장이 포함됩니다.
어나니머스 이너 클래스가 Java의 장점 중 하나인지에 대한 질문에 대해 저는 현재 많은 프로그래밍 언어에 익숙하지 않기 때문에 잘 모르겠습니다.하지만 내가 말할 수 있는 것은 이것이 확실히 더 빠르고 쉬운 코딩 방법이라는 것이다.
참고 자료:Sams Learn Yourself Java in 21 Days 제7판
코드를 최적화하는 최선의 방법.또한 클래스 또는 인터페이스의 덮어쓰기 메서드에 사용할 수 있습니다.
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();
}
}
장점 : ★★★★★★★★★★★★★★★★★★★★★★:
아시다시피 Java는 다중 상속을 지원하지 않기 때문에 "스레드" 종류의 클래스를 익명 클래스로 사용할 경우 클래스는 다른 클래스를 확장할 수 있는 공간이 하나 남아 있습니다.
언급URL : https://stackoverflow.com/questions/355167/how-are-anonymous-inner-classes-used-in-java
'programing' 카테고리의 다른 글
| 오류: Django 1.4에서 "사전 업데이트 시퀀스 요소 #0의 길이가 1입니다. 2가 필요합니다" (0) | 2022.10.14 |
|---|---|
| 오브젝트 내의 여러 어레이를 평탄화 및 구별 (0) | 2022.10.14 |
| JavaScript 형식 지정으로 문자열을 datetime으로 변환하려면 어떻게 해야 합니까? (0) | 2022.10.14 |
| 모든 div 콘텐츠를 비활성화하는 방법 (0) | 2022.10.14 |
| '콜 가능'이란? (0) | 2022.10.14 |