Scala 클 로즈 드 와 자바 클 로즈 드

Scala 클 로즈 드
* 8195 함수 가 변수 가 효과 적 인 역할 영역 에 있 지 않 을 때 변 수 를 방문 할 수 있 습 니 다.다음은 예 를 들 어 설명 한다.

//     ，            
def getFunc(msg : String) = (name : String) => println(msg + "," + name)

//         
val fuc1 = getFunc("hello")
val fuc2 = getFunc("hi")
//   
fuc1("world")
fuc2("java") 

  위 에서 보 듯 이 getFunc 는 두 개의 서로 다른 msg 를 전송 하고 두 개의 서로 다른 변 수 를 되 돌려 줍 니 다. 여기 msg 는 임시 변수 일 뿐 이지 만 getFunc 가 생 성 된 후에 생 성 된 함수 변수 fuc 1 과 fuc 2 에 계속 저장 할 수 있 습 니 다.fuc 1 ("World") 을 호출 합 니 다. 값 이 "hello" 인 msg 는 함수 내부 에 보존 되 어 있 고 반복 적 으로 사용 되 며, 이미 그 역할 영역 을 초과 하 였 습 니 다. 이러한 상황 은 폐쇄 입 니 다.  사실 Scala 는 각 함수 에 하나의 대상 을 만들어 서 패 킷 을 닫 습 니 다. getFunc 함수 가 만 든 함수 에 대해 msg 는 함수 대상 으로 존재 하고 서로 다른 함수 가 서로 다른 msg 를 가지 고 있 습 니 다.  사실은 Spark 소스 코드 에서 여러 곳 에서 폐쇄 를 사 용 했 습 니 다. 전형 적 인 예 를 들 어 RDD 연산 자 함수 에서 map, flatMap 등 은 clean (f) 의 조작 이 있 는데 이것 은 폐쇄 를 제거 하기 위 한 것 입 니 다.연산 자 함수 가 외부 변 수 를 사용 해 야 한다 면 Driver 단 은 모든 task 노드 에 데 이 터 를 복사 하고 큰 변 수 는 broadcast 를 사용 할 수 있 습 니 다.
자바 패키지
  자바 에서 패 킷 을 닫 는 것 은 일반적으로 인터페이스 + 내부 클래스 를 사용 하여 이 루어 지고 내부 클래스 도 익명 내부 클래스 일 수 있다.자바 8 에 서 는 람 다 표현 식 이 있 습 니 다. 실제로 도 익명 류 입 니 다.
특징.

패 키 징 클래스 의 비 final 멤버 에 접근 할 수 없습니다. 익명 내부 클래스 에 구성원 변수 가 외부 구성원 이름과 같 으 면 내부 에 외부 구성원 변 수 를 덮어 씁 니 다. 이 경우 외부 구성원 은 익명 내부 클래스 에서 볼 수 없고 this 키 워드 를 사용 하여 접근 할 수 없습니다.

public void test() {
	String str = "string in test";
	new Thread(
		new Runnable(){
			String str = "string in runnable";
			public void run() {
				String str = "string in run";
				System.out.println(str);
				System.out.println(this.str);
			}
		}
	).start();
}
//     
string in run
string in runnable

functional interfaces 는 하나의 방법 만 있 는 인터페이스 입 니 다.대부분의 리 셋 인 터 페 이 스 는 functional interfaces, 예 를 들 어 runnable, callable 등

이다.

Lambda 표현 식 은 8195 ° Lambda 표현 식 도 실제 적 으로 익명 류 입 니 다. 이것 은 방법 처럼 보 입 니 다. 우 리 는 그것 으로 패 키 지 를 닫 습 니 다.

public class closure {
    String str = "string in closure";

    public static void main(String[] args){
        new closure().test();
    }

    public void test() {
        String str = "string in test";
        new Thread(
                () -> {
                    System.out.println(str);
                    System.out.println(this.str);
                }
        ).start();
    }
}
//     
string in test
string in closure

  Lambda 표현 식 은 익명 의 내부 클래스 가 외부 변 수 를 방문 하 는 가시 적 인 문 제 를 해결 합 니 다. 덮어 쓰기 변 수 를 만 들 수 없습니다. 정의 하면 바로 오 류 를 보고 할 수 있 습 니 다.5. 가방 을 닫 으 면 발생 할 수 있 는 문 제 는 8195 ℃ 이 고 변수의 생명 주기 가 길 어 질 수 있 습 니 다.패키지 간 공유 변 수 는 final 키 워드 를 사용 합 니 다.다음 과 같다.

public class DefaultMethod {
    public static void main(String[] args){
        MyClass my = new MyClass();
        It it = my.subNum();
        it.sub();
        it.sub();
        my = null;
        System.out.println("myclass is null");
        it.sub();
        it.sub();
    }
}

interface It {
    void sub();
}

class MyClass {

    public int num = 10;
    public MyClass() {
        System.out.println("init num = " + num);
    }

    public It subNum() {
        return () -> {
            num--;
            System.out.println("num = " + num);
        };
    }

}
init num = 10
num = 9
num = 8
myclass is null
num = 7
num = 6

  MyCalss 대상 은 이미 null 이지 만 it 는 여전히 사용 할 수 있 습 니 다.