[Java] 람다식 - 2. 함수형 인터페이스에 대해

함수형 인터페이스 - @FunctionalInterface

단 하나의 추상 메소드만 선언된 인터페이스 

interface MyFunction {
	public abstract int max(int a, int b);
}

MyFunction f = new MyFunction(){
		public int max(int a, int b){
        	return a > b ? a : b;
        }
    };

위처럼 인터페이스에 추상메소드로 선언해두면 람다식으로 운영또한 가능합니다.

MyInterface f = (int a, int b) -> a > b ? a : b; 
int big = f.max(5, 3);

 

이처럼 MyInterface 인터페이스를 구현한 익명 객체를 람다식으로 대체가 가능한 이유는, 람다식은 실제로는 익명 객체이고, MyInterface 를 구현한 익명 객체의 메소드와 람다식의 매개변수의 타입과 개수, 그리고 리턴값이 일치하기 때문입니다.

 

따라서 함수형 인터페이스를 정의해서 람다식을 다루는 것이 일반적입니다.

람다식을 다루기 위한 인터페이스 ➡️ 함수형 인터페이스

@FunctionalInterface
interface MyFunction {
	public abstract int max(int a, int b);
}

@FunctionalInterface를 붙이면 컴파일러가 함수형 인터페이스를 올바르게 정의하였는지 알려주기 떄문에 꼭 붙이는 것이 좋습니다.

+ 참고로 함수형 인터페이스에서 default, static 메소드에는 개수 제약이 없음

// 기존 방식
List<String> list = Arrays.asList("abc","aaa","bbb");

Collections.sort(list, new Comparator<String>() {
	public int compare(String s1, String s2) {
    	return s2.compareTo(s1);
    }
});

// 람다식으로 처리한 방식 
@FunctionalInterface
interface Comparator<T>(){
	public abstract int compare(T o1, T o2);
}

List<String> list = Arrays.asList("abc","aaa","bbb");
Collections.sort(list, (s1, s2) -> s2.compareTo(s1));

이제 람다식으로 이렇게 간단히 처리할 수 있게 되었습니다.

---

매개변수가 함수형 인터페이스 타입인 경우

만약 메소드의 매개변수가 함수형 인터페이스 타입인 경우 의미하는 바는 이 메소드를 호출할 때 람다식을 참조하는 참조변수를 매개변수로 지정해야 한다는 것입니다.

 

@FunctionalInterface
interface MyInterface {
	public abstract void myMethod();
}

void aMethod(MyInterfcae f){ // 매개변수의 타입이 함수형 인터페이스인 메소드.
	f.myMethod(); //함수형 인터페이스에 정의된 메소드 호출 
} 

MyInterface f = () -> System.out.println("myMethod()");
aMethod(f);

이 때는 참조변수 없이 람다식을 매개변수로 지정하는 것 또한 가능합니다.!

aMethod( () -> System.out.println("myMethod()") );

---

리턴타입이 함수형 인터페이스 타입인 경우

메소드의 리턴타입이 함수형 인터페이스인 경우에 이 함수형 인터페이스의 추상 메소드와 동등한 람다식을 가리키는 참조변수를 리턴하거나, 람다식을 직접 반환할 수 있습니다.

말이 좀 어려운데 예시를 봅시다.

@FunctionalInterface
interface MyFunction {
    public abstract void run();
}

class Example {

    static MyFunction getMyFunction() {
        MyFunction f = () -> System.out.println("f3.run()");
        return f;
    };
	
//	static MyFunction getMyFunction() {
//		return () -> System.out.println("f3.run()");
//    };

    public static void main(String[] args) {
        MyFunction f1 = () -> System.out.println("f1.run()");

        MyFunction f2 = new MyFunction() {
            @Override
            public void run() {
                System.out.println("f2.run");
            }
        };

        MyFunction f3 = getMyFunction(); // 람다식을 직접 반환

        f1.run();
        f2.run();
        f3.run(); 
    }
}

 

람다식을 참조변수로 다룰 수 있다 ? 
-> 덕분에 위와 같이 메소드를 통해 람다식을 주고받을 수 있음
-> 다시 말해 람다식을 "객체"처럼 사용할 수 있습니다.

 

메소드가 아니라 객체를 주고받는 것이라 근본적으로 달라진 것은 없지만, 람다식 덕분에 예전보다 코드가 훨씬 더 간결하고 이해하기 쉬워졌습니다.

---

람다식의 타입, 형변환

함수형 인터페이스로 람다식을 참조할 수는 있지만, 그 말이 곧 람다식의 타입이 함수형 인터페이스의 타입과 일치하는 것은 아닙니다.

• 람다식 -> "익명 객체" -> 타입이 없음 
• 함수형 인터페이스 -> 단순히 람다식을 참조할 수 있는 타입변수

엄밀히 람다식에도 타입은 있습니다만, 컴파일러가 임의로 이름을 정하기 때문에 알 수는 없습니다.

그래서 연산자의 양 변의 타입을 일치시키기 위해 아래와 같이 형변환이 필요합니다. 

@FunctionalInterface
interface MyFunction(){
	public abstract void myMethod();
}

MyFunction f = (MyFunction) ( ()-> {} );

물론 람다식이 인터페이스를 구현한 클래스의 객체( () -> {} )와 완전히 동일하기 때문에 위와같은 형변환을 허용하지만, 이 경우에는 생략 또한 가능합니다.

---

외부 변수를 참조하는 람다식

람다식은 "익명 객체", 즉 "익명 클래스"의 인스턴스이므로 람다식에서 외부에 선언된 변수에 접근하는 규칙은 익명 클래스와 동일합니다.

@FunctionalInterface
interface MyFunction {
    void myMethod();
}

class Outer {
    int val = 10;

    class Inner {
        int val = 20;

        void method(int i) {
            int val = 30;
            
            // val = 10 ; -> 에러
            // i = 10 ;  -> 에러 

            MyFunction f = () -> {
                System.out.println("i = " + i);
                System.out.println("val = " + val);
                System.out.println("++this.val = " + ++this.val);
                System.out.println("++Outer.this = " + ++Outer.this.val);
            };
            f.myMethod();
        }
    }
}

class Example {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.method(10);
    }
}

람다식 내에서 사용하는 지역변수는 상수로 간주되기 때문에 final이 붙지않았어도 상수로 간주 됩니다.

위의 경우 지역변수 i와 지역변수 val을 람다식에서 참조하고 있기 때문에, 이 값을 변경하는 것을 어느 곳에서도 허용하지 않습니다. 

하지만 지역변수가 아닌 인스턴스 변수인 Outer.val, Outter.Inner.val은 상수로 간주되지 않으므로 값의 변경이 가능합니다.

 

---

<정리>

• 람다식은 "익명 함수", "익명 메소드"가 아닌 "익명 객체" 입니다.
• 람다식의 참조변수로 함수형 인터페이스를 활용합니다.
• 함수형 인터페이스에는 하나의 추상 메소드만 정의할 수 있지만, default, static 메소드에는 개수의 제약이 없습니다.
• 람다식을 이용하여 코드를 간결하게 줄일 수 있었습니다.
• 연산자의 양 변의 타입을 일치시키기 위해 형변환이 필요합니다.
• 하지만 람다식이 인터페이스를 구현한 클래스의 객체와 완전히 동일한 경우에는 이 형변환을 생략할 수 있습니다.
• 람다식 내에서 참조하는 지역변수는 상수로 간주되므로 람다식 내부적으로나 외부적으로 변경이 불가능합니다.