[Java] Anonymous class

Minji Kim·2021년 7월 30일

Java inner class

Java

목록 보기

8/9

Anonymous class

Anonymous class(익명 클래스)는 말 그대로 이름이 없는 Local inner class 이다.
이름이 없으므로 생성자로 만들 수 없고, 클래스의 정의와 동시에 인스턴스를 생성한다.

Java 예제 1

소스 코드

Person Local inner class

public class Person {
	private String name;
    
    public Person(String name) {
    	this.name = name.;
    }
    
    public MyReadable createInstance(int age) {

        MyReadable person = new MyReadable() {
      	    @Override
            public voidi readInfo() {
            	System.out.println("이름 : " + name);
                System.out.println("나이 : " + age);
                System.out.println();
            }
        };
        retrun person;
    }
}

interface MyReadable {
	public abstract void readInfo();
}

🤔 위의 Local inner class에서 본 Person 예제와 다른 점은 무엇일까?

Local inner class 에서는 PersonWithAge 라는 클래스를 명시하여 생성하였다.
그러나 Anonymous inner class는 말그대로 익명 내부 클래스 이므로 따로 명시된 클래스가 존재하지 않는다.

Main에서도 바로 Anonymous inner class를 사용할 수 있다.

Main

public class Main {
	public static void main(String[] args) {
    	System.out.println("Anonymous Inner Class (익명 내부 클래스)\n");
        
        Person p = new Person("홍길동");
        MyReadable r = person.craeteInstance(30);
        r.readInfo();
        System.out.println();
        
        // Anonymous 01
        MyReadable r2 = new MyReadable() {
            int age = 10;
            
            @Override
            public void readInfo() {
                System.out.println("age = " + age);
                System.our.println();
            }
        };
        r2.readInfo();
        
        // Anonymous 02
        new MyReadable() {
            int age = 20;
            
            @Override
            public void readInfo() {
            	System.,out.println("age = " + age);
                System.our.println();
            }
        }.readInfo();
    }
}

실행 결과

Java 예제 2

소스 코드

Main

public class Main {
    public static void(String[] args) {
    	System.out.println("Anonymous Inner Class\n");
        
        // Anonymous 01
        System.out.println(new MyAbstract() {
            int c = 3;
            
            @Override
            int sum(int a) {
            	return a + b + n + c;
            }
        }.sum(10));
        System.out.println();
        
        // Anonymous 02
        System.out.println(new MyClass() {
       	    int d = 40;
            
            @Override
            int sum(int c) {
            	return a + b + c + d;
            };
        }.sum(30));
    }
}

abstract class MyAbstract {
    int a = 1;
    int b = 2;
    
    abstract int sum(int a);
}

class MyClass {
    int a = 10;
    int b = 20;
    
    int sum(int c) {
    	return a + b + c;
    }
}

System.out.println() 메소드 내에서 익명 내부 클래스를 만들어 실행하여 출력되게 한다.
예제 1에서는 인터페이스 (Myreadable)를 이용해 익명 내부 클래스를 만들었다.
예제 2에서는 추상 클래스 (MyAbstract)와 일반 클래스 (MyClass)를 이용해서 익명 내부 클래스를 만들 수 있다는 것을 보인다.

실행 결과

Java 예제 3

클래스를 상속 받아서 구현하는 방법과 익명 클래스를 사용하는 방법이 어떻게 다른지도 살펴본다.

소스 코드

public class Main {
    public static void main(String[] args) {
    	System.out.println("익명 내부 클래스 활용\n");
        
        System.out.println("1. 상속 받아서 구현하는 방법");
        Calculable c1 = new MyMath();
        double result = c1.operate(1.0, 2.0);
        System.out.println("result = " + result);
        System.our.println();
        
        System.out.println("2. 익명 클래스 사용");
        Calculable c2 = new Calculable() {
            @Override
            public double operate(double x, double y) {
            	return x * y;
            }
        };
        System.out.println("result = " + c2.operate(3.0, 4.0));
        System.out.println("result = " + new Calculable() {
            @Override
            public double operate(double x, double y) {
            	return Math.pow(x, y);
            }
        }.operate(5.0, 2.0));
    }
}

inferface Calculable {
    public abstract double operate(double x, double y);
}

class MyMath implements Calculable {
    @Override
    public double operate(double x, double y) {
    	return x + y;
    }
}