자바 8 함수 식 프로 그래 밍

함수 식 프로 그래 밍
추상 을 향 한 것 은 프로 그래 밍 의 한 사상 이다. 개발 과정 에서 우 리 는 많은 인 터 페 이 스 를 정의 한다. 하나의 인 터 페 이 스 는 여러 개의 실현 유형 에 대응 하고 가끔 우 리 는 익명 의 방식 으로 인터페이스의 실현 을 신속하게 완성 한다. 코드 는 항상 이렇다.

public interface ISelfOperate{
  public int myAdd(int a,int b);
}

//      
public static int calBySelfWay(int a,int b,ISelfOperate iSelfOperate) {
  return iSelfOperate.myAdd(a, b);
}

public static void main(String[] args) {
  //      
  int total = calBySelfWay(1, 2, new ISelfOperate() {
  	@Override
  	public int myAdd(int a, int b) {
  		return a + b;
  	}
  });
  System.out.println(total);
}

자바 8 은 새로운 사고방식, 함수 식 프로 그래 밍 사상 을 제공한다.

@FunctionalInterface
public interface ISelfOperate{
  public int myAdd(int a,int b);
}

//      
public static int calBySelfWay(int a,int b,ISelfOperate iSelfOperate) {
  return iSelfOperate.myAdd(a, b);
}

public static void main(String[] args) {
  int total = calBySelfWay(1, 2, (a,b) -> a+b);
  System.out.println(total);
}

위의 코드 인터페이스의 실현 은 전달 (a,b) -> a+b 을 통 해 사용자 정의 함수 기능 을 실현 합 니 다. 이 표현 식 은 Lambada 이 라 고 부 릅 니 다. Lambada 표현 식 을 사용 하여 프로 그래 밍 을 하면 함수 행위 에 더욱 집중 되 는 프로 그래 밍 을 할 수 있 고 간단 하고 편리 합 니 다.
Lambada 표현 식 은 익명 류 프로 그래 밍 을 대체 하 는 새로운 사고방식 으로 Lambada 표현 식 을 통 해 인터페이스의 실현 부분 을 직접 작성 합 니 다.
함수 식 인 터 페 이 스 를 어떻게 설명 합 니까?
함수 식 인터페이스: 추상 적 인 방법 만 있 는 인터페이스;@ FunctionalInterface 주석 표 시 를 자주 사용 합 니 다.

@FunctionalInterface
public interface ISelfOperate{
  public int myAdd(int a,int b);
}

@FunctionalInterface 주 해 는 컴 파일 러 를 도와 인 터 페 이 스 를 함수 식 인터페이스 인지 확인 할 수 있 고 그렇지 않 으 면 오류 정 보 를 알려 줄 수 있다.예 를 들 어 함수 식 인터페이스 에서 두 가지 추상 적 인 방법 을 설명 하면 오 류 를 알 릴 수 있다.

@FunctionalInterface
public interface ISelfOperate{
  public int myAdd(int a,int b);
  public int myMulti(int a,int b);
}

함수 식 인 터 페 이 스 를 설명 하면 Lambada 표현 식 으로 인터페이스 호출 을 할 수 있 습 니 다.
Lambada 표현 식 의 작성 규범

() 에서 인터페이스 에서 방법 적 매개 변수 유형 과 수량 이 일치 하 는 매개 변 수 를 전달 하고 유형 은 생략 하고 쓰 지 않 으 며 컴 파일 러 가 스스로 추정 할 수 있다

.

방법 은 체 내 에 코드 가 한 줄 밖 에 없 을 때 코드 를 직접 쓸 수 있 습 니 다. {} 로 싸 지 않 아 도 됩 니 다. 코드 는 필요 없습니다.끝나다

방법 체 내 에 여러 줄 의 코드 가 있 을 때 {} 을 사용 하여 싸 야 합 니 다. {} 내 코드 는 평소 코드 를 쓰 는 방식 으로 작성 해 야 합 니 다.

예 를 들 면:

int total1 = calBySelfWay(1, 2, (a,b) -> a+b);
int total2 = calBySelfWay(1, 2, (int a,int b) -> a+b);
int total3 = calBySelfWay(1, 2, (int a,int b) -> {return a+b;});

이런 인터페이스 아래

(a,b) -> a+b

... 과 같다

(int a,int b) -> {return a+b;}

따라서 Lambada 표현 식 의 작성 은 함수 식 인터페이스 파라미터 와 반환 값 이 완전히 일치 해 야 컴 파일 을 통과 할 수 있 습 니 다. 함수 식 인 터 페 이 스 를 사용 할 때 우 리 는 매개 변수 와 반환 값 유형 에 만 주 의 를 기울 이면 됩 니 다.
자바 8 내 장 된 함수 식 인터페이스java.util.function 가방 아래 에 자바 8 함수 식 인터페이스 가 놓 여 있 고 자주 사용 하 는 네 개의 함수 식 인 터 페 이 스 는:

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

@FunctionalInterface
public interface Predicate {
    boolean test(T t);
}

@FunctionalInterface
public interface Supplier {
    T get();
}

@FunctionalInterface
public interface Function {
    R apply(T t);
}

내 장 된 함수 식 인 터 페 이 스 를 사용 하면 Lambada 표현 식 에 맞 게 프로 그래 밍 할 수 있 습 니 다.Lambada 표현 식 을 통 해 인터페이스의 인 스 턴 스 를 만 듭 니 다:

Consumer consumer = (str) -> System.out.println(str);
Supplier supplier = () -> Math.random() + "";
Predicate predicate = (str) -> str.length() > 5;
Function function = (integer) -> "  " +integer;

익명 클래스 구현 과 같 습 니 다.

Consumer consumer = new Consumer() {
  @Override
  public void accept(String str) {
  	System.out.println(str);
  }
};

함수 식 인 터 페 이 스 는 우리 가 평소에 사용자 정의 한 일반 인터페이스 와 똑 같 습 니 다. 다만 Lambada 에 대한 지원 을 확대 하여 프로 그래 밍 을 더욱 편리 하 게 합 니 다.java.util.function 가방 아래 에 이 네 개의 함수 식 인터페이스 가 확 장 된 인 터 페 이 스 를 많이 제공 했다. 구체 적 으로 소개 하면 공식 API 와 소스 코드 를 볼 수 있 고 사용 방식 도 유사 하 다.
방법 참조
방법 참조: 연산 자 :: 를 사용 하여 방법 명 과 대상 또는 클래스 의 이름 을 분리 합 니 다.Lambada 표현 식 을 쓸 때 JDK 가 만들어 진 방법 을 사용 할 수 있다 면 더 간단 한 코드 를 만 들 수 있 습 니 다. 예 를 들 어:

Consumer consumer = (str) -> System.out.println(str);

이 함수 식 인터페이스의 실현 부분 은 간단 한 줄 코드 일 뿐 이 며, 이것 System.out.println(str) 도 JDK 가 이미 존재 하 는 방법 이 므 로 방법 인용 으로 간략하게 쓸 수 있다.

Consumer consumer = System.out::println;

방법 인용 은 우리 가 이미 존재 하 는 방법 을 인용 하여 함수 식 인 터 페 이 스 를 실현 하 는 것 이다. 따라서 방법 인용 은 우리 가 인용 하 는 방법 이 함수 식 인터페이스 파라미터 와 반환 값 과 같 으 면 된다. 쓰기 방법 인용 도 매개 변 수 를 쓸 필요 가 없고 간단 한 인용 으로 인 터 페 이 스 를 실현 할 뿐이다.
방법 은 지원 하 는 세 가지 문법 을 참조 합 니 다.
1. 대상: 인 스 턴 스 방법 2. 클래스: 정적 방법 3. 클래스: 인 스 턴 스 방법

//  ::    
BiFunction binaryOperator =Math::pow;
BiFunction binaryOperator1 =(a,b) -> Math.pow(a, b);

//   ::    
Consumer consumer1 = System.out::println;
Consumer consumer = (str) -> System.out.println(str);

//  ::    
BiPredicate biPredicate = String::equals;
BiPredicate biPredicate1 = (a,b) -> a.equals(b);

:: 이런 표기 법 은 이해 하기 어렵 고 만족 조건 은 다음 과 같다.
인용 방법 이 필요 한 첫 번 째 매개 변 수 는 호출 대상 이 고 두 번 째 매개 변 수 는 인용 방법 이 필요 한 두 번 째 매개 변수 일 때: ClassName: methodName
Lambada 표현 식 과 방법 인용 을 배우 면 더 우아 한 코드 를 쓸 수 있 습 니 다.