[교재 EffectiveJava] 아이템 42. 익명 클래스보다는 람다를 사용하라

익명클래스

익명 클래스란, 함수 객체를 만드는 주요 수단이다.

함수 객체란, 자바에서 함수 타입을 표현할때 추상 메서드를 1개만 담은 인터페이스를 사용했는데, 이런 인터페이스의 인스턴스를 말한다. 특정 함수나 동작을 나타나는데 사용되었다.

public static void main(String[] args) {
    Collections.sort(List.of("aa", "bbb", "ccc", "dddd"), new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return Integer.compare(o1.length(), o2.length());
        }
    });
}

 

 

람다식

전략 패턴처럼, 함수 객체를 사용하는 과거 객체 지향 디자인 패턴에는 익명 클래스면 충분했다. 자바 8에 와서는 익명 클래스를 대체할 람다식을 사용할 수 있게 되었다. 추상 메서드 1개만 갖고있는 인터페이스를 '함수형 인터페이스'라고 불렀고, 해당 인터페이스의 인스턴스를 '람다식(lambda expression) 을 사용해 만들 수 있게 되었다. 

 

람다는 함수와 익명 클래스와 개념은 비슷하지만 코드는 훨씬 간결하다. 

익명 클래스의 경우

public static void main(String[] args) {
    Collections.sort(List.of("aa", "bbb", "ccc", "dddd"), new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return Integer.compare(o1.length(), o2.length());
        }
    });
}

 

위 익명클래스의 코드를 람다로 바꿔보자.

람다식을 함수 객체로 사용

Collections.sort(List.of("aa", "bbb", "ccc", "dddd"), (s1, s2) -> Integer.compare(s1.length(), s2.length()));

람다의 반환 타입 : Comparator<String>
매개변수 s1의 반환타입 : String
매개변수 s2의 반환타입 : int

이 반환타입들은 코드에서는 명시하지 않았다. 이는 우리 대신 컴파일러가 문맥을 살펴 타입을 추론하기 때문이다. 상황에 따라 컴파일러가 결정하지 못할 경우에는 프로그래머가 직접 명시를 해줘야한다. 타입을 명시해야 코드가 더 명확할 때만 제외하고는, 람다의 모든 매개변수 타입은 생략하자. 컴파일러가 "타입을 알 수 없다"는 오류를 낼때만 해당 타입을 명시하면 된다. 

// 람다 자리에 비교자 생성 메서드 사용 
Collections.sort(list, Comparator.comparingInt(String::length));

// 자바8) List 인터페이스에 추가된 sort 메서드를 이용
list.sort(Comparator.comparingInt(String::length));

 

 

람다식으로의 변환

상수형 클래스 몸체와 데이터를 사용한 열거타입

package com.java.effective.item42;

enum Operation {
    PLUS("+") {
        public double apply(double x, double y) { return x + y; }
    },

    MINUS("-") {
        public double apply(double x, double y) { return x - y; }
    },

    TIMES("*") {
        public double apply(double x, double y) { return x * y; }
    },

    DIVIDE("/") {
        public double apply(double x, double y) { return x * y; }
    };

    private final String symbol;

    Operation(String symbol) { this.symbol = symbol; }

    @Override public String toString() {
        return symbol;
    }

    public abstract double apply(double x, double y);
}

상수별 클래스 몸체를 구현하는 방식 보다는 열거 타입에 인스턴스 필드를 두는 편이 낫다. 람다를 이용하면 열거 타입의 인스턴스 필드를 이용하는 방식으로 상수별로 다르게 동작하는 코드를 쉽게 구현할 수 있다. 

 

람다로 변환

package com.java.effective.item42;

import java.util.function.DoubleBinaryOperator;

enum LambdaOperation {
    //PLUS("+", (x, y) -> x + y),
    PLUS("+", Double::sum),
    MINUS("-", (x, y) -> x - y),
    TIMES("*", (x, y) -> x * y),
    DIVIDE("/", (x, y) -> x / y);

    private final String symbol;
    private final DoubleBinaryOperator op;

    LambdaOperation(String symbol, DoubleBinaryOperator op) {
        this.symbol = symbol;
        this.op = op;
    }

    @Override
    public String toString() { return symbol; }

    public double apply(double x, double y) {
        return op.applyAsDouble(x, y);
    }
}

단순히 각 열거 타입 상수의 동작을 람다로 구현해 생성자에 넘기고, 생성자는 이 람다를 인스턴스 필드로 저장해둔다. 그런 다음 apply 메서드를 사용해서 필드에 저장된 람다를 호출하면 된다. DoubleBinaryOperator 는 여기서 함수형 인터페이스이다. apply 메서드에서 applyAsDouble() 메서드를 호출한다.

 

호출 코드

public class Main {
    public static void main(String[] args) {
        LambdaOperation.PLUS.apply(1, 7);
    }
}

// 기억하기
public double apply(double x, double y) {
    return op.applyAsDouble(x, y);
}

람다 기반 Operation 열거 타입을 보면 상수별 클래스 몸체는 더이상 사용할 이유가 없다고 느낄지 모르지만, 꼭 그렇지는 않다. 메서드나 클래스와 달리, 람다는 이름이 없고 문서화도 못된다. 따라서 코드 자체로 동작이 명확히 설명되지 않거나 코드 줄 수가 많아지면 람다를 쓰지 말아야한다. 람다가 읽기 어렵다면 더 간단히 줄이거나, 람다식을 사용하지 않는 쪽으로 리팩토링 해야한다. 하지만 람다를 열거타입 생성자에 넘겨지는 인수들의 타입도 컴파일러 타임에 추론된다. 따라서 열거 타입 생성자 안의 람다는 런타임 시에 생성되는 열거 타입의 인스턴스 멤버에 접근할 수 없다.

LambdaOperation(String symbol, DoubleBinaryOperator op) {
    this.symbol = symbol;
    this.op = op;
    
    // PLUS 등 인스턴스 멤버에 접근 불가능
}

따라서 상수별 동작을 간결하게 구현이 어렵거나, 인스턴스 필드나 메서드를 사용해야만 하는 상황의 경우 상수별 클래스 몸체를 사용해야한다.

 

 

람다 사용이 불가능한 곳

람다는 함수형 인터페이스에서만 쓰인다. 추상 클래스의 인스턴스를 만들때 람다를 쓸수 없으니, 익명 클래스를 써야한다. 비슷하게 추상 메서드가 여러개인 인터페이스(함수형 인터페이스가 아니다.)를 만들때도 익명 클래스를 쓸 수 있다. 마지막으로 람다는 자신을 참조할 수 없다.

* 람다에서의 this 키워드는 바깥 인스턴스를 기리킨다. 

* 반면, 익명클래스에서의 this는 익명 클래스의 인스턴스 자신을 가리킨다.
   그래서 함수 객체가 자신을 참조해야 한다면 반드시 익명 클래스를 써야한다.

람다도 익명 클래스처럼 직렬화 형태가 구현별로 다를 수 있기 때문에 람다를 직렬화하는 일은 삼가해야한다. 직렬화해야만 하는 함수 객체가 있다면 private 정적 중첩 클래스의 인스턴스를 사용하자.