[JAVA] 함수형 인터페이스

안녕하세요? 주니하랑 입니다!

오늘은 Lamda에 개념에서 연장선상인 함수형 인터페이스에 대해 공부 해 보도록 하는 것이에요.

Lamda가 무엇인지 모르신다면? 람다 피드에 관심을 주세요!

---

 

📌 함수형 인터페이스란?

---

👉 단 하나의 추상 Method만 선언된 인터페이스

interface MyFunction { /* 함수형 인터페이스 예제 코드 */
	public abstract int max ( int a, int b );
}

 

위와 같을 때 아래와 같이 해 주는 것이 좋은 것이에요!

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

컴파일러가 Annotation을 보고, 올바른지를 확인 해 주기 때문에 선언하는 것이 좋답니다.

 

MyFunction f = new MyFunction() {	/* 익명 Class의 선언과 객체 생성 동시에 진행 */
	public int max ( int a, int b ) {
    	return a > b ? a : b;
    }
}

int value = f.max(3, 5);	// 정상 MyFunction에 max()가 있다.

 

👉 함수형 인터페이스 타입의 참조변수로 람다식 참조 가능

단, 함수형 인터페이스의 Method와 Lamda식의 매개변수 개수와 반환타입 일치 했을 시!

MyFunction f = (a, b) -> a > b ? a : b;
int value = f.max(3, 5);		//	실제로는 람다식(익명 함수)이 호출

 

결국 함수형 인터페이스는 람다식을 다루기 위해 사용된다는 것이지요.

 

 

📝 예제 코드

@FunctionalInterface		// 함수형 인터페이스는 단, 하나의 추상 메서드만 갖는다.
interface MyFunction { /* 함수형 인터페이스 선언 */
//	public abstract int max ( int a, int b );
	int max ( int a, int b );		// public, abstract는 생략 가능
}

class lamda_ex { 
	public static void main (Stringp[] args) { 
    // Object obj = (a, b) -> a > b ? a : b // 람다식 작성 (익명 객체) 
    // 위와 같이 하면 함수형으로 다루지 않는다고 Error 발생 // 결국 위와 아래 코드는 같다. 
      MyFunction mf = new MyFunction() { 
         public int max ( int a, int b ) { // 오버라이딩 - 접근 제어자는 오버라이딩 대상보다 좁게 설정할 수 없다.
              	return a > b ? a : b; 
          } 
      }; 
     int value = mf.max(3, 5); // 함수형 인터페이스
    // 위와 같을 때 형변환을 해줘야 하는데, 이런 경우 형변환을 할 수 없다. 
    System.out.println(" value = " + value );
 	}
}


// 출력 결과 : value = 5

 

위의 코드를 람다식 스타일로 줄이면?

@FunctionalInterface		// 함수형 인터페이스는 단, 하나의 추상 메서드만 갖는다.
interface MyFunction { /* 함수형 인터페이스 선언 */
//	public abstract int max ( int a, int b );
	int max ( int a, int b );		// public, abstract는 생략 가능
} // MyFunction 끝

class lamda_ex { 
	public static void main (Stringp[] args) { 
    	
        // 람다식(익명 객체)을 다루기 위한 참조변수의 타입은 함수형 인터페이스로 한다.
    	Myfunction mf = (a, b) -> a > b ? a : b;
    
     int value = mf.max(3, 5); // 함수형 인터페이스
    // 위와 같을 때 형변환을 해줘야 하는데, 이런 경우 형변환을 할 수 없다. 
    System.out.println(" value = " + value );
 	}
}


// 출력 결과 : value = 5

 

람다식은 이름이 없는 것이에요. 그렇다면 람다식은 하나의 Method인데, 이것을 사용하려면 어떻게 해야 하는 것일까요?

결국 이름이 있어야 그 Method를 호출할 수 있는 것이잖아요?

이것을 위해서 함수형 인터페이스를 선언하고, 그 안에 추상 메서드를 만들어 주는 것이에요.

위의 코드를 통해 mf라는 참조 객체에는 int max라는 Method가 있다는 것을 알 수 있는 것이에요.

람다식을 mf에 넣고, 이것을 사용할 때 mf.max(매개변수)를 해 준다면 호출이 가능 해 지는 것이지요.

 

 

    📍함수형 인터페이스 - example

👉 익명 객체를 람다식으로 바꾸면?

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

List<String> list = Arrays.asList("abc", "aaa", "bbb", "ddd", "aaa");

collections.sort ( list, new Comparator<String>() {
	public int compare(String str1, String str2) {
    	return str2.compareTo(str1);
    }
});


// 위의 compare를 람다식으로 바꾸면?

Collections.sort( list, ( str1, str2 ) -> str2.compareTo ( str1 ) );

 

 

 

    📍함수형 인터페이스 타입의 매개변수, 반환타입

👉 함수형 인터페이스 타입의 매개변수

@FunctionalInterface
interface MyFunction {
	void myMethod();

}	// MyFunction 끝


void aMethod ( MyFunction mf ) {
	mf.myMethod();	// MyFunction에 정의된 람다식 Method Call
}

위의 코드는 aMethod의 매개변수로 함수형 인터페이스인 mf를 받고 있는 것인데, 이것은 결국 람다식을 받겠다는 의미인 것이에요.

 

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

위와 같이 람다식으로 myMethod()을 호출 할 수 있는 것이에요.

이것을 더 간략화하게 되면 아래와 같습니다.

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

 

👉 함수형 인터페이스 타입의 반환 타입

MyFunction myMethod() {
	MyFunction mf = () -> {};
   	return mf;
}

위의 MyFunctiond은 람다식을 반환한다는 의미인 것이에요. 이것을 더욱 축약하게 되면 아래와 같은 것이에요.

MyFunction myMethod() {
	return () -> {};
}

 

 

📝 예제 코드

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

Class Function_Interface_ex {
	static void execute( MyFunction mf ) {	/* 매개변수 타입이 MyFunction인 Method
    	mf.run();
    }
    
    static MyFunction getMyFunction() {		/* 반환 타입이 MyFunction인 Method */
    	MyFunction mf = () -> System.out.println( "mf.run()" );
        return mf;
    }
    
    public static void main(String[] args) {
    // 람다식으로 MyFunction의 run() 구현
    	MyFunction mf1 = ()-> System.out.println( "mf1.run()" );
        
        Myfunction mf2 = new MyFunction() { 	/* 익명클래스로 run() 구현 */
        	public void run()	{	// public 필수!
            	System.out.println( "mf2.run()" );
            }
        }
        
        MyFunction mf3 = getMyFunction();
        
        mf1.run();
        mf2.run();
        mf3.run();
        
        execute( () -> System.out.println( "mf1.run()" );
        excute( () -> System.out.println( "run()" ) );
        
	}
}

// ######################################################################

// 실행 결과
mf1.run()
mf2.run()
mf3.run()
mf1.run()
run()

 

 

 

---

주니하랑의 글이 마음에 드셨나요? 구독과 공감! 그리고, 댓글은 주니하랑에게 많은 힘이 됩니다!