(기초)자바 의 내부 클래스

내부 클래스/내장 클래스,주로 클래스 의 디자인 에 사 용 됩 니 다.
사물 A 를 분석 할 때 사물 A 의 내부 에 다른 사물 X 가 존재 하고 사물 X 는 사물 A 의 내용 을 사용 하 는 것 을 발견 합 니 다.이때 자바 는 내부 디자인 을 제공 하여 이런 수 요 를 실현 합 니 다!!
 
 
접근 특성:
내부 클래스 는 외부 클래스 의 한 구성원 으로서 외부 클래스 의 구성원 을 직접 방문 할 수 있 으 며 개인 구성원 을 포함한다.
외부 에서 내부 클래스 에 접근 하려 면 내부 클래스 의 대상 을 만들어 야 접근 할 수 있 습 니 다.
 
내부 류 출현 의 원인
심장 과 인체 의 관계 등 두 가지 유형 간 의 폐쇄 는 특히 긴밀 하 다.
A 는 외부 류 로 하고 B 는 내부 류 로 한다.
B 가 A 의 내부 클래스 로 정의 되면:
우선,B 는 A 를 떠 날 수 없고 단독으로 존재 하기 때문에 절차 가 더욱 엄밀 하고 합리적이다.
그 다음으로 B 는 A 의 자원 을 방문 하고 직접 방문 하 며 A 를 만 들 지 않 아 도 대상 을 호출 할 수 있 고 과정 을 간소화 했다.
 
내부 클래스 호출
 
 
외부 클래스 에서 내부 클래스 를 호출 하려 면 내부 클래스 대상 을 만들어 서 호출 해 야 합 니 다.

//   
public class Body {
	
	private int times;
	
	//   
	class Heart {
		
		void heartBeat() {
			//                 
			System.out.println("Body.Heart.heartBeat():\t"+times);
		}
		
	}
	
	public void invoke() {
		//                      
		Heart inner = new Heart();
		inner.heartBeat();
	}
	
}

 

public class Test {
	public static void main(String[] args) {
		Body body = new Body();
		body.invoke();
	}
	
}

 결과:Body.Heart.heartBeat():    0
 
 
다른 클래스 에서 내부 클래스 를 호출 하려 면 외부 클래스 대상 과 내부 클래스 대상 을 만들어 야 합 니 다.
 

//   
public class Body {
	
	private int times;
	
	//   
	class Heart {
		
		void heartBeat() {
			//                 
			System.out.println("Body.Heart.heartBeat():\t"+times);
		}
		
	}
	
}

 

public class Test {
	public static void main(String[] args) {
		Body.Heart heart =  new Body().new Heart();
		heart.heartBeat();
	}
	
}

 실행 결과:Body.Heart.heartBeat():    0
 
 
다른 클래스 에서 정적 내부 클래스 의 비정 상 구성원 을 방문 하려 면 대상 이 필요 합 니 다.정적 구성원 에 게 접근 하여 대상 이 필요 하지 않 습 니 다.

//   
public class Body {
	
	private static int times;
	
	//     
	static class Heart {
		
		void heartBeat() {
			//                 
			System.out.println("Body.Heart.heartBeat():\t"+times);
		}
		
		//           
		static void size() {
			System.out.println("Body.Heart.size()");
		}
		
	}
	
}

 

public class Test {
	public static void main(String[] args) {
		//             
		Body.Heart heart =  new Body.Heart();
		heart.heartBeat();
		
		//             
		Body.Heart.size();
	}
	
}

 실행 결과:
Body.Heart.heartBeat():    0Body.Heart.size()
 
내부 클래스 는 외부 클래스 의 인용 을 통 해 외부 클래스 에 접근 하 는 구성원 변 수 를 실현 합 니 다.

public class Outer {

	private int num = 1;
	private String name = "kk";
	
	class Inner {
		private int num = 2;
		
		void method() {
			int num = 3;
			System.out.println(num);//     ，      num，    ，   ：3
			System.out.println(Inner.this.num);//  Inner        num，   ：2
			System.out.println(Outer.this.num);//  Outer        num，   ：1
			
			//   Inner.this    ，    ，  Outer  ！
			System.out.println(name);//   ：kk
			//            
			System.out.println(Outer.this.name);//   ：kk
		}
	}
}

 
 
내부 클래스 접근 부분 변수,이 부분 변 수 는 final,즉 상수 여야 합 니 다.방법 이 스 택 에서 나 온 후에 도 이 변 수 를 사용 할 수 있 도록 확보 해 야 합 니 다.
 

public class Outer {
	
	//    
	public Object method() {
		
		//           ，     final
		//       (      )，                 
		final int num = Integer.MAX_VALUE;
		
		//     
		class Inner {
			public String toString() {
				return "local inner class,num="+num;
			}
		}
		
		//         
		return new Inner();
	}
	
}

 

public class Test {
	public static void main(String[] args) {
		Object obj = new Outer().method();//  
		String str = obj.toString();//             
		System.out.println(str);
	}
	
}

 
 
=============================================================================
 
 
익명 내부 클래스
 
 
익명 내부 류 는 사실상 내부 류 의 약자 방식 이다.
일반적으로 인터페이스 에 있 는 방법 이 많 지 않 으 면 익명 내부 류 로 문 제 를 해결한다.
       인터페이스 에 방법 이 많 으 면 내부 클래스 를 표시 하여 인 터 페 이 스 를 조작 하 는 것 을 권장 합 니 다.
응용 필드:
인터페이스 프로 그래 밍 을 할 때 방법 은 인터페이스 형식 으로 들 어가 고 이 때 는 익명 내부 클래스 를 통 해 하위 클래스 대상 을 인 스 턴 스 할 수 있 습 니 다.
이렇게 설계 되 었 습 니 다.
1.익명 내부 클래스 는 인 터 페 이 스 를 실현 하 는 클래스 를 표시 하지 않 고 인터페이스 에 있 는 방법 을 직접 실현 합 니 다.
2.인 터 페 이 스 를 대상 으로 대상 을 만 듭 니 다.하위 클래스 에 이름 이 없 기 때문에 부모 클래스 이름 으로 만 대체 할 수 있 습 니 다.
3.다 중,부모 인터페이스 형식의 인용 을 통 해 하위 클래스 대상 을 가리킨다.
 
인터페이스 프로 그래 밍 시 익명 내부 클래스 사용

public interface InterfaceA {
	public abstract String fun();
}

 

public class Main {
	
	//      ，     
	public String say(InterfaceA a) {
		return "Anonymouse inner class :"+a.fun();//  ，    ，      
	}
}

 

public class Test {
	public static void main(String[] args) {
		
		//         ，          
		//    
		String str = new Main().say(new InterfaceA() {
						@Override
						public String fun() {
							return "fun ?";
						}
					});
		
		System.out.println(str);
	}
	
}

 
실행 결과:
Anonymouse inner class :fun ?
 
 
또 다른 작은 예:
인터페이스
 

public interface InterfaceA {
	public String fun();
}

 
 
인터페이스 로 대상 만 들 기
 

public class Outer {
	
	//    
	public InterfaceA method() {
		
		final int num = Integer.MAX_VALUE;
		
		//         
		return new InterfaceA() {
			@Override
			public String fun() {
				return "Anonymous inner class, num="+num;
			}
		};
	}
	
}

 
 
 테스트
 
 

public class Test {
	public static void main(String[] args) {
		InterfaceA a = new Outer().method();
		String str = a.fun();
		System.out.println(str);
	}
	
}

 
 결실
Anonymous inner class, num=2147483647
 
 
 다른 예

public class Main {
	
	/**
	 *        ，     ，     ，       
	 */
	public void test1() {
		class Inner extends Object {
			public void funny() {
				System.out.println("Main.funny()");
			}			
		}
		
		new Inner().funny();
	}
	
	/**
	 *   Object        ，    
	 *                
	 */
	public void test2() {
		
		new Object() {
			public void funny() {
				System.out.println("Main.funny()");
			}
		}.funny();

	}
	
	/**
	 *   
	 *   ：  ，    ，              ，    ！
	 */
	public void test3() {
		
		Object obj = new Object() {
						public void funny() {
							System.out.println("Main.funny()");
						}
					};
		//obj.funny(); //          ，          ，    Object   funny()，    ！
	}
}