[JAVA] 함수형 인터페이스라는게 있더라구요..(feat.Lambda)

오늘 교육 도중 함수형 인터페이스라는 것을 배웠습니다.
계속해서 자바를 해왔지만 처음 보는 것이라 매우 신기하고 당황스러웠는데요..
여전히 공부할게 많고 더욱 더 노력해야겠구나 싶었습니다..흑..
이 생소한 듯 익숙했던 함수형 인터페이스에 대해서 알아보겠습니다.

 

 

함수형 인터페이스란?

함수형 인터페이스는 인터페이스 내에 추상메서드가 하나인 인터페이스를 의미합니다.

 

단일 메서드 작성 테스트

간단한 예시를 작성해보겠습니다.

@FunctionalInterface
public interface FcInterface {
    String printStr(String str);
}

@FunctionalInterface 어노테이션을 명시해주면 함수형 인터페이스임을 명시하는 것입니다.
새로 생성한 FcInterface 내에 입력한 String값을 프린트해주는 메서드다 라고 해서 printStr이라는 추상 메서드를 하나 정의해줬습니다.

이제 이 함수형 인터페이스를 사용해보겠습니다.

public class FunctionalInterfaceTest {
    public static void main(String[] args) {
        FcInterface fc = str -> System.out.println("입력한 문자열 : " + str);
        fc.printStr("hello functional interface");
    }
}

인터페이스를 선언 한 후 추상함수의 동작을 작성해줍니다.
생성된 인터페이스를 이용하여 해당 추상 클래스(printStr)을 사용해보니 작성했던 출력이 그대로 되는 것을 확인할 수 있습니다.

그럼 오직 하나의 메서드만 작성이 가능하고 아무것도 못하는 그냥 단일동작 깡통인가요?라고 생각된다면
아니요. static이나 default 메서드는 얼마든지 추가로 작성할 수 있습니다.

 

 

다중 메서드 작성 테스트

또 하나의 예시를 작성해보겠습니다.

@FunctionalInterface
public interface FcInterface {

    void printStr(String str);

    default void printHello(String name) {
        System.out.println("Hello," + name);
    }

    static String getMyInterfaceName() {
        return "FcInterface";
    }
}

위에서 생성했던 FcInterface에 default 메서드와 static 메서드를 작성해보았습니다.
일단 에러는 발생하지 않으니 실행해보겠습니다.

public class FunctionalInterfaceTest {
    public static void main(String[] args) {
        FcInterface fc = str -> System.out.println("입력한 문자열 : " + str);
        fc.printStr("hello functional interface");
        String name = FcInterface.getMyInterfaceName();
        fc.printHello(name);
    }
}

작성했던 static메서드를 통해 이름을 가져오고, 해당 이름을 default 메서드를 사용해 출력해였습니다.
이와같이 추상메서드가 오직 하나만 작성되고, 이외의 static, default 메서드는 얼마든지 들어가도 되는 것입니다.

 

 

 

추상 메서드 개수는 오직 하나여야 한다.

그럼 추상메서드가 작성되지 않았을 때, 혹은 여러개의 추상메서드가 작성되었을 때는 어떻게 될까요?

 

추상 메서드가 없을 때

작성된 추상 메서드가 없다면 @FunctionalInterface에서 '메서드를 찾을 수 없습니다.' 라는 에러가 발생됩니다.

No target method found

@FunctionalInterface // **No target method found**
public interface FcInterface {

    default void printHello(String name) {
        System.out.println("Hello," + name);
    }

    static String getMyInterfaceName() {
        return "FcInterface";
    }
}

 

여러개의 추상메서드가 작성되었을 때

만약 추상메서드가 여러개 작성된다면 @FunctionalInterface에서 ‘오버라이딩 되지 않은 여러개의 추상 메서드가 발견되었습니다.’ 라고 에러가 발생되는 것을 확인 할 수 있습니다.

Multiple non-overriding abstract methods found in interface

@FunctionalInterface // **Multiple non-overriding abstract methods found in interface com.** 
public interface FcInterface {

    void printStr(String str);

    String getHelloStr(String str);

    default void printHello(String name) {
        System.out.println("Hello," + name);
    }

    static String getMyInterfaceName() {
        return "FcInterface";
    }
}

 

 

어디에서 사용되나요?

직접적으로 구현 시에 사용되는 것은 보지 못했지만 자바 자체에서 구현되어있는 인터페이스 들이 있습니다.

[1] Comparator

코딩테스트 문제를 풀다보면 종종 사용하게 되는 인터페이스 입니다.
두 개의 타입을 인자로 받아 int를 반환하는 메서드가 추상화되어있습니다.

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

// 사용 예시
// Arrays.sort(targets, (o1, o2) -> o1[1] - o2[1]);

[2] Runnable

아무런 매개변수도 받지 않고 아무런 반환도 하지 않으며,
추후 구현된 메서드를 그냥 실행시켜주는 역할을 합니다.

@FunctionalInterface
public interface Runnable {
    void run();
}

/*
    사용예시
        Runnable r = () -> System.out.println("Hello, Runnable");
        r.run();
*/

[3] Function

입력한 T타입 매개변수로 받아 R타입을 리턴합니다.
특정 값을 다른 형으로 변환할 때 사용할 수 있다고 합니다.

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}
/*
    사용 예시
   Function<Integer, String> fun = s -> Integer.toString(s);
   System.out.println(fun.apply(10)); -> 출력 10
*/

[4] Predicate

인터페이스 선언 시 정의 된 타입 T를 매개변수로 받아 구현한 조건문에 따른 boolean값을 반환합니다.

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}
/*
    사용 예시
    Predicate<String> p = str -> str.startsWith("h");
    System.out.println(p.test("heollo")); -> 출력 true
    System.out.println(p.test("jelly"));  -> 출력 false
*/

 

 

마무리

예시들을 작성해보면 인터페이스 구현을 기존의 익명 클래스 람다식을 사용하여 간결하게 작성할 수 있는 것을 확인할 수 있었습니다. 이처럼 함수형 인터페이스는 간결한 코드 구조로 표현할 수 있다는 장점이 있습니다.

 

기존에 종종 사용하던 Comparator와 Runnable 인터페이스가 함수형 인터페이스였다는 것을 깨닫고 함수형 인터페이스를 직접 생성하는 방법을 배울 수 있는 좋은 시간이였습니다. 앞으로도 사용하는 인터페이스 및 클래스에 대해서 좀 더 분석해보려 노력하면 좋을 것 같습니다.