《 Thinking in java 》 - 내부 류 소결

1. 하나의 클래스 A 에서 내부 클래스 B 를 정의 한 후에 외부 클래스 에서 이 내부 클래스 B 를 예화 하려 면 클래스 A 의 인용 이 있어 야 new 를 사용 하여 내부 클래스 를 예화 할 수 있 습 니 다.예 는 다음 과 같다.
 

public class DotNew {

	public class Inner{
		
	}
	
	public static void main(String[] args){
		
		DotNew dotNew = new DotNew();
		Inner inner = dotNew.new Inner();
	}
}

 
2. 내부 클래스 B 에서 외부 클래스 A 의 인용 을 얻 으 려 면 외부 클래스 의 클래스 이름 +. this 키 워드 를 사용 할 수 있 습 니 다.예 는 다음 과 같다.
 

public class DotThis {

	void f(){
		
		System.out.println("DotThis.f()");
	}
	
	public class Inner{
		
		public DotThis outer(){
			
			return DotThis.this;
		}
	}
	
	public Inner inner(){
		
		return new Inner();
	}
	
	public static void main(String[] args){
		
		DotThis dotThis = new DotThis();
		DotThis.Inner inner = dotThis.inner();
		inner.outer().f();
	}
}

 
3. 외부 클래스 A 에 내부 클래스 B 가 있 고 이 내부 클래스 B 가 내장 클래스 (정적 내부 클래스) 라면 이 내부 클래스 를 예화 하려 면 외부 클래스 의 인 스 턴 스 를 참조 하지 않 아 도 됩 니 다.예 코드 는 다음 과 같다.
 

public class Parcel3 {

	static class StaticDestination{
		
		private String label;
		
		StaticDestination(String whereTo) {
			this.label = whereTo;
		}
		
		String readLabel(){
			
			return label;
		}
		
	}
	
	public static void main(String[] args){
		
		Parcel3.StaticDestination staticDestination = new Parcel3.StaticDestination("Tasmania");
	}
}

 
4. 내부 클래스 는 클래스 에서 정의 할 수 있 고 방법, 방법의 특정한 범위 에서 정의 할 수 있다.예 코드 는 다음 과 같다.
 

public class Parcel6 { 
  private void internalTracking(boolean b) { 
    if(b) { 
      class TrackingSlip { 
        private String id; 
        TrackingSlip(String s) { 
          id = s; 
        } 
        String getSlip() { return id; } 
      } 
      TrackingSlip ts = new TrackingSlip("slip"); 
      String s = ts.getSlip(); 
    } 
    //           ，         
    //! TrackingSlip ts = new TrackingSlip("x"); 
  }  
  public void track() { internalTracking(true); } 
  public static void main(String[] args) { 
    Parcel6 p = new Parcel6(); 
    p.track(); 
  } 
} 

 
5. 익명 내부 류 는 기본 구조 기 를 사용 합 니 다. 만약 에 기본 적 인 구조 방법 이 매개 변 수 를 전달 해 야 한다 면 이 익명 내부 류 의 구조 방법 도 매개 변 수 를 전달 해 야 합 니 다.인 자 를 전달 하지 않 으 면 컴 파일 러 가 잘못 보고 할 수 있 습 니 다.그리고 이 익명 의 내부 류 는 계승 이나 기 류 를 실현 한 것 으로 보인다.예 코드 는 다음 과 같다.
 

public class Parcel8 {
	
	class Wrapping{
		
		private int x;
		
		public Wrapping(int x) {

			this.x = x;
		}
		
		int value(){
			return x;
		}
	}

	public Wrapping warrping(int x){
		return new Wrapping(x){

			@Override
			int value() {
				return super.value()*47;
			}
			
		};
	}
}

 
6. 익명 내부 클래스 에서 이 익명 내부 클래스 에서 외부 클래스 의 변 수 를 직접 인용 해 야 한다 면 이 변 수 는 final 이 어야 합 니 다.상례 에서 익명 내부 클래스 에서 x 를 직접 인용 하지 않 고 구조 방법 으로 매개 변 수 를 전달 하기 때문에 x 는 final 일 필요 가 없다.코드 예 는 다음 과 같다.
 

abstract class Destination{
	
	abstract String readLabel();
}

public class Parcel10 {

	public Destination destination(final String dest,final float price){
		
		return new Destination(){
			
			private int cost;
			
			{
				cost = Math.round(price);
				if(cost>100){
					System.out.println("Over budget!");
				}
			}
			
			private String label = dest;
			
			@Override
			String readLabel() {
				return label;
			}
			
		};
	}
	
	public static void main(String[] args){
		
		Parcel10 parcel10 = new Parcel10();
		parcel10.destination("Tasmania", 101.95F);
	}
}

 
7. 익명 내부 류 는 일반적인 계승 과 유사 하 다. 왜냐하면 그들 은 하나의 유형 을 계승 하거나 하나의 인 터 페 이 스 를 실현 할 수 있 지만 둘 다 있 을 수 없 기 때문이다.하나의 인 터 페 이 스 를 실현 한다 면 하나의 인터페이스 만 실현 할 수 있다. 
 
8. 내부 클래스 와 외부 클래스 사이 에 연결 이 필요 하지 않 으 면 내장 클래스 를 사용 할 수 있 습 니 다. 즉, 이 내부 클래스 는 정적 (static) 입 니 다.끼 워 넣 기 클래스 사용 은 다음 을 의미 합 니 다:
 
a. 외부 클래스 를 사용 하여 끼 워 넣 는 대상 을 만 들 필요 가 없습니다.
b. 포 함 된 클래스 에서 비정 상 외부 클래스 의 대상 에 접근 할 수 없습니다.
c. 정적 도 메 인, 정적 데이터 가 있 을 수 있 습 니 다.
d. 내장 류 내부 에 내장 류 가 있 을 수 있 습 니 다.
 
일반적인 내부 류 와 내장 류 를 비교 해 보면 다음 과 같은 차이 점 이 있다.
 
a. 외부 클래스 의 인용 을 통 해 내부 클래스 의 대상 을 만들어 야 합 니 다.
b. 내부 클래스 는 외부 클래스 의 도 메 인, 방법 (정적 비 정적 모두 가능) 에 접근 할 수 있 습 니 다.
c. 일반 내부 클래스 는 정적 필드, 정적 방법 을 정의 할 수 없고 내장 클래스 를 정의 할 수 없 지만 상수 (static final 상수) 를 정의 할 수 있 습 니 다.
 
9. 내장 류 는 인터페이스의 일부분 일 수 있다.인터페이스 에 있 는 모든 종 류 는 기본적으로 Public 와 static 이기 때문에 인터페이스 에 포 함 된 종 류 를 정의 하 는 것 은 인터페이스의 규칙 을 위반 하지 않 습 니 다.예 코드 는 다음 과 같다.
 

public interface ClassInInterface {

	void howdy();
	
	class Test implements ClassInInterface{

		@Override
		public void howdy() {
			
			System.out.println("Test.howdy()");
		}
		
		public static void main(String[] args){
			
			new Test().howdy();
		}
		
	}

}

 
 
미 완성 계속.