Java의 기능적 인터페이스
Java는 영원히 객체 지향 프로그래밍 언어로 남아 있습니다. 객체지향 프로그래밍 언어를 사용하면 무결성과 단순성을 위해 일부 원시 데이터 유형과 원시 메소드를 제외하고 Java 프로그래밍 언어에 있는 모든 것이 객체 전체에서 회전한다고 선언할 수 있습니다. Java라는 프로그래밍 언어에는 함수만 존재하지 않습니다. Java 프로그래밍 언어의 함수는 클래스의 일부이며 누군가 이를 사용하려면 클래스나 클래스의 객체를 사용하여 함수를 호출해야 합니다.
Java 기능 인터페이스
ㅏ 기능적 인터페이스 하나의 추상 메서드만 포함하는 인터페이스입니다. 표시할 기능은 하나만 가질 수 있습니다. 자바 8부터, 람다 표현식 기능적 인터페이스의 인스턴스를 나타내는 데 사용할 수 있습니다. 기능적 인터페이스에는 기본 메서드가 여러 개 있을 수 있습니다. 실행 가능 , 액션리스너 , 그리고 유사한 기능적 인터페이스의 몇 가지 예입니다.
기능적 인터페이스는 다음과 같이 추가로 인식됩니다. 단일 추상 메소드 인터페이스 . 간단히 말해서, 그들은 다음으로도 알려져 있습니다. SAM 인터페이스 . Java의 기능적 인터페이스는 사용자에게 기본적인 프로그래밍 접근 방식을 제공하는 새로운 기능입니다.
Java SE 8에는 코드를 더 읽기 쉽고 깔끔하고 간단하게 만들기 위해 Lambda 표현식 및 메소드 참조와 함께 기능적 인터페이스가 포함되어 있습니다. 기능적 인터페이스는 정확하게 하나의 추상 메서드만 포함하도록 보장하는 인터페이스입니다. 기능적 인터페이스는 인터페이스를 다음과 같이 표현하여 사용 및 실행됩니다. 호출된 주석 @FunctionalInterface . 앞서 설명한 것처럼 기능적 인터페이스에는 하나의 추상 메서드만 포함될 수 있습니다. 그러나 여기에는 원하는 만큼의 기본 및 정적 메서드가 포함될 수 있습니다.
Functional 인터페이스에서는 기본적으로 인터페이스 내부에 정의된 메서드가 추상 전용이기 때문에 abstract 키워드를 사용하는 것은 선택 사항이므로 abstract 키워드를 사용할 필요가 없습니다. 기능적 인터페이스의 인스턴스로 Lambda 표현식을 호출할 수도 있습니다.
Java 기능 인터페이스 예
예시 1:
Java 8 이전에는 익명의 내부 클래스 객체를 생성하거나 이러한 인터페이스를 구현해야 했습니다.
자바
// Java program to demonstrate functional interface> class> Test {> > public> static> void> main(String args[])> > {> > // create anonymous inner class object> > new> Thread(> new> Runnable() {> > @Override> public> void> run()> > {> > System.out.println(> 'New thread created'> );> > }> > }).start();> > }> }> |
산출
New thread created
예 2:
Java 8 이상에서는 할당할 수 있습니다. 람다 식 다음과 같이 기능적 인터페이스 객체에:
자바
// Java program to demonstrate Implementation of> // functional interface using lambda expressions> class> Test {> > public> static> void> main(String args[])> > {> > // lambda expression to create the object> > new> Thread(() ->{> > System.out.println(> 'New thread created'> );> > }).start();> > }> }> |
산출
New thread created
@FunctionalInterface 주석
@FunctionalInterface 주석은 기능적 인터페이스가 두 개 이상의 추상 메소드를 가질 수 없도록 보장하는 데 사용됩니다. 둘 이상의 추상 메서드가 있는 경우 컴파일러는 '예기치 않은 @FunctionalInterface 주석' 메시지에 플래그를 지정합니다. 그러나 이 주석을 반드시 사용해야 하는 것은 아닙니다.
다음은 위 주제의 구현입니다.
자바
// Java program to demonstrate lambda expressions to> // implement a user defined functional interface.> @FunctionalInterface> interface> Square {> > int> calculate(> int> x);> }> class> Test {> > public> static> void> main(String args[])> > {> > int> a => 5> ;> > // lambda expression to define the calculate method> > Square s = (> int> x) ->x * x;> > // parameter passed and return type must be> > // same as defined in the prototype> > int> ans = s.calculate(a);> > System.out.println(ans);> > }> }> |
산출
25
일부 내장 Java 기능 인터페이스
Java SE 1.8 이후에는 기능적 인터페이스로 변환되는 인터페이스가 많이 있습니다. 이러한 모든 인터페이스에는 @FunctionalInterface라는 주석이 달려 있습니다. 이러한 인터페이스는 다음과 같습니다 -
- Runnable –> 이 인터페이스에는 run() 메서드만 포함되어 있습니다. Comparable –> 이 인터페이스에는 CompareTo() 메서드만 포함되어 있습니다. ActionListener –> 이 인터페이스에는 actionPerformed() 메서드만 포함되어 있습니다. Callable –> 이 인터페이스에는 call() 메서드만 포함되어 있습니다.
Java SE 8에는 네 가지 주요 기능 인터페이스가 포함되어 있습니다. 이는 아래와 같이 여러 상황에 적용될 수 있습니다.
- 소비자 조건자 함수 공급자
이전 4개의 인터페이스 중에서 처음 3개의 인터페이스(예: Consumer, Predicate 및 Function)에도 마찬가지로 아래에 제공되는 추가 기능이 있습니다.
- 소비자 -> 이중소비자
- 술어 -> 이중 술어
- 함수 -> 이중 함수, 단항 연산자, 이항 연산자
1. 소비자
기능적 인터페이스의 소비자 인터페이스는 하나의 인수 또는 고급화된 인수만 허용하는 인터페이스입니다. 소비자 인터페이스에는 반환 값이 없습니다. 아무것도 반환하지 않습니다. 소비자의 기능적 변형인 DoubleConsumer, IntConsumer 및 LongConsumer도 있습니다. 이러한 변형은 기본 값을 인수로 허용합니다.
이러한 변형 외에도 Bi-Consumer로 알려진 Consumer 인터페이스의 변형이 하나 더 있습니다.
이중 소비자 – Bi-Consumer는 Consumer 인터페이스의 가장 흥미로운 변형입니다. 소비자 인터페이스는 하나의 인수만 사용하지만, Bi-Consumer 인터페이스는 두 개의 인수를 사용합니다. Consumer와 Bi-Consumer 모두 반환 값이 없습니다. 또한 Consumer 인터페이스처럼 아무것도 반환하지 않습니다. 지도 항목을 반복하는 데 사용됩니다.
소비자 기능 인터페이스의 구문/프로토타입 –
Consumer consumer = (value) ->System.out.println(값);
Java 소비자 기능 인터페이스의 이 구현은 print 문에 매개변수로 전달된 값을 인쇄합니다. 이 구현에서는 Java의 Lambda 기능을 사용합니다.
2. 술어
과학적 논리에서는 인수를 받아들이고 그에 대한 답으로 부울 값을 생성하는 함수를 술어라고 합니다. 마찬가지로 Java 프로그래밍 언어에서 Java의 조건자 기능 인터페이스는 단일 값이나 인수를 받아들이고 이에 대해 일종의 처리를 수행하고 부울(True/False) 응답을 반환하는 함수 유형입니다. Predicate 기능 인터페이스의 구현은 Java에서 필터링 논리(제공된 조건자를 기반으로 스트림 구성 요소를 필터링하는 데 사용되는 프로세스)도 캡슐화합니다.
소비자 기능 인터페이스와 마찬가지로 Predicate 기능 인터페이스에도 몇 가지 확장이 있습니다. IntPredicate, DoublePredicate 및 LongPredicate가 있습니다. 이러한 유형의 술어 기능 인터페이스는 기본 데이터 유형 또는 값만 인수로 허용합니다.
이중 술어 – Bi-Predicate는 Predicate 기능 인터페이스의 확장이기도 합니다. 이 인터페이스는 하나 대신 두 개의 인수를 사용하여 일부 처리를 수행하고 부울 값을 반환합니다.
술어 기능 인터페이스의 구문 -
public interface Predicate { boolean test(T t); } 조건자 기능 인터페이스는 클래스를 사용하여 구현할 수도 있습니다. 클래스를 사용하여 조건자 기능 인터페이스를 구현하기 위한 구문은 다음과 같습니다.
public class CheckForNull implements Predicate { @Override public boolean test(Object o) { return o != null; } } Java 조건자 기능 인터페이스는 Lambda 표현식을 사용하여 구현할 수도 있습니다. Predicate 기능 인터페이스 구현의 예는 다음과 같습니다.
Predicate predicate = (value) ->값 != null;
Java Lambda 표현식을 사용하여 Java에서 기능 인터페이스를 구현하는 것은 클래스를 사용하여 구현한 것보다 관리하기 쉽고 효과적입니다. 두 구현 모두 동일한 작업을 수행하므로(예: 동일한 출력 반환)
3. 기능
함수는 단일 인수만 받고 필요한 처리 후에 값을 반환하는 Java의 기능적 인터페이스 유형입니다. 기본 유형은 일반 유형 인수를 암시할 수 없기 때문에 다양한 버전의 함수 인터페이스가 있으므로 이러한 버전의 함수 인터페이스가 필요합니다. 다양한 버전의 함수 인터페이스는 도구이며 일반적으로 double, int, long과 같은 기본 유형에 사용됩니다. 이러한 기본 유형의 다양한 시퀀스도 인수에 사용됩니다.
이러한 버전은 다음과 같습니다.
이중 기능
Bi-Function은 실질적으로 Function과 관련되어 있습니다. 게다가 두 개의 인수를 사용하는 반면 Function은 하나의 인수를 허용합니다.
Bi-Function의 프로토타입과 구문은 다음과 같습니다.
@FunctionalInterface public interface BiFunction { R apply(T t, U u); ....... } 위의 인터페이스 코드에서 T와 U는 입력이고 출력은 R뿐입니다.
단항 연산자 및 이항 연산자
단항 연산자(Unary Operator)와 바이너리 연산자(Binary Operator)라는 두 가지 다른 기능 인터페이스도 있습니다. 둘 다 각각 Function과 Bi-Function을 확장합니다. 간단히 말해서 단항 연산자는 함수를 확장하고 이항 연산자는 이중 기능을 확장합니다.
단항 연산자와 바이너리 연산자의 프로토타입은 다음과 같습니다.
나. 단항 연산자
@FunctionalInterface public interface UnaryOperator extends Function { ……... } ii . 바이너리 연산자
@FunctionalInterface public interface BinaryOperator extends BiFunction { ……... } 위의 예를 보면 단항 연산자는 하나의 인수만 허용하고 단일 인수만 반환한다는 것을 이해할 수 있습니다. 그러나 단항 연산자에서는 입력 값과 출력 값이 모두 동일하고 유형이 같아야 합니다.
반면에 이항 연산자는 두 개의 값을 가져와 Bi-Function과 비교할 수 있는 하나의 값을 반환하지만 단항 연산자와 유사하므로 입력 및 출력 값 유형은 동일해야 하며 동일한 유형이어야 합니다.
4. 공급자
공급자 기능 인터페이스는 입력이나 인수를 사용하지 않지만 단일 출력을 반환하는 기능 인터페이스 유형이기도 합니다. 이러한 유형의 기능적 인터페이스는 일반적으로 값의 지연 생성에 사용됩니다. 공급자 기능 인터페이스는 시퀀스 생성을 위한 논리를 정의하는 데에도 사용됩니다. 예를 들어 – 피보나치 시리즈의 논리는 스트림의 도움으로 생성될 수 있습니다. 공급자 기능 인터페이스에 의해 구현되는 생성 메소드입니다.
공급자 기능 인터페이스의 다양한 확장에는 BooleanSupplier, DoubleSupplier, LongSupplier 및 IntSupplier와 같은 다른 많은 공급자 기능이 포함되어 있습니다. 이러한 모든 추가 특수화의 반환 유형은 해당 기본 형식뿐입니다.
공급업체 기능 인터페이스의 구문/프로토타입은 –
@FunctionalInterface public interface Supplier{ // gets a result …………. // returns the specific result ………… T.get(); } 다음은 위 주제의 구현입니다.
자바
// A simple program to demonstrate the use> // of predicate interface> import> java.util.*;> import> java.util.function.Predicate;> class> Test {> > public> static> void> main(String args[])> > {> > // create a list of strings> > List names = Arrays.asList(> > 'Geek'> ,> 'GeeksQuiz'> ,> 'g1'> ,> 'QA'> ,> 'Geek2'> );> > // declare the predicate type as string and use> > // lambda expression to create object> > Predicate p = (s) ->s.startsWith(> 'G'> );> > // Iterate through the list> > for> (String st : names) {> > // call the test method> > if> (p.test(st))> > System.out.println(st);> > }> > }> }> |
산출
Geek GeeksQuiz Geek2
중요사항/관찰 ns:
다음은 Java의 기능적 인터페이스와 관련된 몇 가지 중요한 사항입니다.
- 기능적 인터페이스에서는 하나의 추상 메서드만 지원됩니다. @FunctionalInterface와 같은 기능적 인터페이스의 주석이 구현되지 않거나 함수 인터페이스로 작성되지 않은 경우 내부에 두 개 이상의 추상 메소드가 선언될 수 있습니다. 그러나 둘 이상의 기능이 있는 상황에서는 해당 인터페이스를 기능적 인터페이스라고 부르지 않습니다. 이를 비기능적 인터페이스라고 합니다.
- @FunctionalInterface 주석은 자발적이므로 필요하지 않습니다. 이는 컴파일러 수준을 확인하는 데 도움이 되기 때문에 작성되었습니다. 이 외에도 선택사항입니다.
- 기능적 인터페이스에는 무한한 수의 메서드(정적이든 기본이든)를 추가할 수 있습니다. 간단히 말해서 정적 메서드와 기본 메서드를 포함하는 기능적 인터페이스에는 제한이 없습니다.
- 상위 클래스의 메서드를 재정의하는 것은 Java의 기능적 인터페이스 규칙을 위반하지 않습니다.
- 그만큼 java.util.함수 패키지에는 Java 8의 많은 내장 기능 인터페이스가 포함되어 있습니다.
