[JAVA 8] 함수형 인터페이스(Functional Interface)

함수형 인터페이스(Functional Interface)

여러 개의 디폴트 메서드와는 상관없이 추상 메서드가 오직 하나인 함수형 인터페이스이다.

람다식은 함수형 인터페이스를 기반으로만 작성될 수 있다.

🧐 인터페이스 및 추상 클래스와 추상 메서드
인터페이스와 추상 클래스는 상속(extends) 받거나 구현(implements)하는 클래스가 인터페이스나 추상 클래스 내 추상 메서드를 구현하도록 강제한다.
- 인터페이스 (다형성의 특징)
공통 기능이 필요할 때 추상 메서드를 정의해놓고 구현하는 클래스에서 각 기능을 오버라이딩 하여 여러 형태, 기능으로 구현할 수 있다.
- 추상 클래스 (상속의 특징)
상속 관계에서 같은 부모 추상 클래스를 상속받는 자식 클래스 간에 공통 기능을 각각 구현하고 확장시킨다.
그 자체로는 클래스의 역할을 다 하지 못하지만 새로운 클래스를 작성하는데 바탕이 되며 하나 이상의 추상 메소드를 가지고 있다.
- 추상 메서드
메서드의 선언부만 작성하고 구현부는 작성하지 않은 채로 남겨두어 상속 받는 클래스에서 구현하도록 한다.

 

함수형 인터페이스 만들기

함수형 인터페이스는 하나의 추상 메서드를 가져야 하지만, 여러 개의 static 메서드와 default를 정의할 수 있다.

@FunctionalInterface 어노테이션은 함수형 인터페이스의 조건에 부합하는지 확인하여 둘 이상의 추상 메서드가 존재하면 컴파일 오류를 발생시킨다.

 

@FunctionalInterface
public interface printerInterface<T> {
	T printSomething();	// 추상 메서드
    static void printName() {
    	System.out.println("Kuromi");
    }
    default void printAge() {
    	System.out.println("10");
    }
}


// 실제로 사용할 클래스 내 구현
printerInterface<String> printerInterface = () -> "hello";
System.out.println(printerInterface.printSomething());
printerInterface.printName();
printerInterface.printAge();

 

기본적으로 제공하는 함수형 인터페이스

java.lang.function 패키지에 java에서 기본으로 제공하는 함수형 인터페이스가 미리 정의되어 있다.

종류	인자	반환	메서드	설명
Runnable			void run()	기본적인 형태의 인터페이스, 인자와 반환값 모두 없음
Supplier<T>		<T>	T get()	인자가 없이 제너릭 타입의 반환값만 있는 인터페이스, 항상 같은 값을 반환
Consumer<T>	<T>		void accept(T t)	제너릭 타입의 인자만 있고 반환값이 없는 인터페이스
Predicate<T>	<T>	Boolean	boolean test(T t)	제너릭 타입의 인자와 Boolean 타입의 반환값을 가지는 인터페이스
Function<T, R>	<T>	<R>	R apply(T t)	제너릭 타입의 인자와 다른 제너릭 타입의 반환값이 같이 있는 인터페이스
UnaryOperator<T>	<T>	<T>	T apply(T t)	같은 제너릭 타입의 인자와 반환값을 가지고 있는 인터페이스
BinaryOperator<T>	<T, T>	<T>	R apply(T t, U u)	같은 제너릭 타입의 인자 2개를 받고 같은 제너릭 타입의 반환값을 가지는 인터페이스
BiConsumer<T, U>	<T, U>		void accept(T t, U u)	다른 제너릭 타입의 인자 2개를 받고 반환값이 없는 인터페이스
BiPredicate<T, U>	<T, U>	Boolean	boolean test(T t, U u)	다른 제너릭 타입의 인자 2개를 받고 Boolean 타입의 반환값을 가지는 인터페이스
BiFunction<T, U, R>	<T, U>	<R>	R apply(T t, U u)	다른 제너릭 타입의 인자 2개를 받고 다른 제너릭 타입의 반환값을 가지는 인터페이스
Comparator<T>	<T, U>	int		같은 제너릭 타입의 인자 2개를 받고 Integer 반환값을 가지는 인터페이스, 객체간의 값을 비교하기 위한 compare 기능을 위한 인터페이스

 

함수형 인터페이스 사용 예제

1. Predicate : T → boolean

인자 하나를 받아서 boolean 타입을 리턴한다.

public interface Predicate<T> {
    boolean test(T t);
    ....
}

import java.util.function.Predicate;

public class Example {
    public static void main(String[] args) {
        Predicate<Integer> predicate1 = (num) -> num > 0;
        System.out.println(predicate1.test(100));	// true
        
        Predicate<Integer> predicate2 = (num) -> num < 100;
        System.out.println(predicate1.and(predicate2).test(100));	// false
        System.out.println(predicate1.or(predicate2).test(100));	// true
    }
}

 

2. Consumer : T → void

인자 하나를 받고 아무 것도 리턴하지 않는다.

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}

import java.util.function.Consumer;
import java.util.Arrays;
import java.util.List;

public class Example {
    public static void main(String[] args) {
        Consumer<String> consumer = s -> System.out.println(s.toUpperCase());
        consumer.accept("hello world");	// HELLO WORLD
        List<String> list = Arrays.asList("hello", "world");
        list.forEach(consumer);	// HELLO, WORLD
    }
}

 

3. Supplier : () → T

아무 것도 입력 받지 않고 T 타입의 객체를 리턴한다.

public interface Supplier<T> {
    T get();
}

import java.util.function.Supplier;

public class Example {
    public static void main(String[] args) {
        Supplier<String> supplier= () -> "HelloWorld";
        System.out.println(supplier.get());	// HelloWorld
    }
}

 

4. Function : T → R

T 타입 인자를 받아 R 타입을 리턴한다.

public interface Function<T, R> {
    R apply(T t);
}

import java.util.function.Function;

public class Example {
    public static void main(String[] args) {
        Function<Integer, Integer> func1 = n -> n * 10;	// 10배한 값
        System.out.println(func1.apply(3));	// 30
        
        Function<Integer, String> func2 = n -> "RESULT: " + n;	// 문자열로 변경
        String result = func1.andThen(func2).apply(3);	// func1 먼저 실행 후 결과가 func2로 전달
        System.out.println(result);	// RESULT: 30
    }
}

 

참고자료 및 출처 🙇‍♂️

https://bcp0109.tistory.com/313

https://codechacha.com/ko/java8-predicate-example/

https://jogeum.net/18

https://zzang9ha.tistory.com/303

https://ykh6242.tistory.com/112

https://bcp0109.tistory.com/313