java #19 내부클래스, 중첩클래스, 지역클래스, 익명클래스

java #19 내부클래스, 중첩클래스, 지역클래스, 익명클래스

 

* inner class

- Event를 처리하기 위하여 만들어진 클래스

- 클래스안에 정의되는 클래스

- 아래 4가지 형태가 있음.

- 내부클래스(inner class)

- 중첩클래스(nested class)

- 지역클래스(local class)

- 익명클래스(anonymous inner class)

1. 내부 클래스(inner class)

가. 정의

- 안쪽 클래스를 인스턴스 변수처럼 사용하기 위하여 사용한다.

class outer 변수 메서드 public class Inner 변수   메서드

- 바깥 클래스에서 안쪽 클래스를 사용하려면 바깥 클래스의 객체 사용하여 안쪽 클래스를 객체화하고 그 객체로 안쪽 클래스의 자원을 사용한다.

- 안쪽 클래스에서 바깥쪽 클래스의 자원(변수와 메소드)을 직접 사용가능하다. 하지만 바깥쪽 클래스에서 안쪽 클래스의 자원을 사용하려면 반드시 바깥 클래스에서 안쪽 클래스를 객체화하여야만 사용 가능하다.

나. 사용법

- 객체화 하여 사용한다.

1) 바깥클래스 생성

바깥클래스명 객체명 = new 바깥클래스생성자();
outer out = new outer();

2) 안쪽 클래스 생성

바깥클래스명.안쪽클래스명 객체명 = 바깥클래스객체명.new 안쪽클래스생성자();
Outter.Inner in = out.new Inner();

- 컴파일하면 outter.class와 outter$Inner.class가 생성된다.

다. 예제

package day0226;
/**
* 안쪽 클래스를 인스턴스변수처럼 사용할 수 있는 InnerClass의 사용
*/
public class TestInner {
     int i;
     public TestInner() {
          System.out.println("바깥클래스 생성자");
     }// TestInner
     public void outMethod() {
          System.out.println("바깥클래스의 메서드");
     }
     // //////////Inner Class의 시작//////////////
     public class Inner {
          int j;
          public Inner() {
               System.out.println("안쪽클래스의 생성자");
          }// Inner
          public void inMethod() {
               System.out.println("안쪽클래스의 메서드");
               System.out.println("안쪽메서드 바깥변수 i="+i);
          }
     }// class
     // //////////Inner Class의 끝//////////////
     public static void main(String[] args) {
          TestInner ti = new TestInner();
          ti.i = 10;
          // ti.j=10;//안쪽 클래스의 변수는 직접 사용 불가능
          // ti.inMethod(); //안쪽 클래스의 메서드는 직접 사용 불가능
          // 바깥클래스에서 안쪽클래스의 자원을 사용하려면 안쪽클래스를 
          // 객체화하여 사용
          TestInner.Inner in = ti.new Inner();
          // 안쪽 클래스의 자원 사용
          in.j = 100;
          in.inMethod();
     }// main
}// class

2. Nested Class(중첩클래스)

가. 정의

메서드

나. 사용법

- 안쪽 클래스는 객체화하여 사용하지 않는다.(static)

다. 예제

package day0226;
/**
* 안쪽 클래스를 static 변수처럼 사용하는 중첩 클래스의 사용
*
*/
public class TestNested {
     int i;
     static int j;
     public TestNested(){
          System.out.println("바깥클래스의 생성자");         
     }//TestNested
     public void outMethod(){
          System.out.println("인스턴스메서드");         
     }//outMethod    
     public static void outStaticMethod(){
          System.out.println("바깥 클래스의 스태틱메서드");
     }//outstaticMethod    
     ///////////중첩클래스 시작////////////
     static class Nested{
     static int k;
     public Nested(){
          System.out.println("안쪽생성자");
     }//Nested    
     public static void inMethod(){
          //i=10; //static영역에서는 instance 영역의 자원을 직접 사용할 수 없음.
          System.out.println("안쪽 메서드");
          TestNested.j=10; // = "j=10;"
          //outMethod(); //static영역에서는 instance 영역의 자원을 직접 사용할 수 없음.
          TestNested.outStaticMethod(); // = outStaticMethod();
     }//inMethod
     }//class
     ///////////중첩클래스 끝////////////
     public static void main(String[] args) {
          //안쪽클래스의 자원 사용
          Nested.k=10;
          Nested.inMethod();
     }
}

3. 지역클래스(Local Class)

가. 정의

나. 예제

package day0226;
 
public class TestLocal {
     int out_i;
     public TestLocal(){
          System.out.println("바깥 클래스의 생성자");
     }//TestLocal    
     public void method(int param_i, final int param_j){
          int local_i=0;
          final int local_j=0;         
          ///////지역클래스 시작//////
          //바깥클래스명$1안쪽클래스명.class
        class Local{
             int i;
             public Local(){
                  System.out.println("지역클래스의 생성자");                 
             }//local
             public void localMethod(){
                  System.out.println("바깥클래스의 인스턴스변수"+out_i);
                  
                  //final이 붙어있지 않은 파라메터는 지역클래스에서 사용할 수 없다.
                  //System.out.println("파라메터 param_i="+param_i);
 
                  System.out.println("파라메터 param_j="+param_j); 
 
                  //final이 붙어있지 않은 클래스는 지역클래스에서 사용할 수 없다.                
                  //System.out.println("지역변수 local_i"+local_i);
 
                  System.out.println("지역변수 local_j="+local_j);
                  System.out.println("지역클래스의 메소드");                 
             }//localMethod
        }//class       
        Local local = new Local();
        local.i=10;
        local.localMethod();                
     }//method
     public static void main(String[] args) {         
          TestLocal tl = new TestLocal();
          tl.method(100,200);              
     }
}

4. 익명 클래스(anonymous innerclass)

가. 정의

- 클래스를 값(arguments:메서드 호출시 넣어주는 값)으로 사용하는 클래스

나. 사용법

method명(new 부모클래스명(){
  메서드 정의
});
----------------------------
Test t=new Test(); 부모
t.useT(new In(){
  이름이 없는 자식클래스
});
------------------------
- compile 하면
바깥클래스명$1.class,
바깥클래스명$2.class,... 생성됨

다. 예제

interface Fly

package day0226; /** * 비행하는 객체가 구현해야할 기능의 목록을 정의 */ public interface Fly { public abstract String speed(); //속도 public String height();//높낮이 }

Fly를 구현하는 클래스

package day0226; /** * class를 arguments로 사용하는 anonymous innerclass의 사용 */ public class TestAnonymous { public void useFly(Fly f) { System.out.println(f.speed()); System.out.println(f.height()); }// useFly public static void main(String[] args) { TestAnonymous ta = new TestAnonymous(); // class, interface를 매개변수로 하는 메소드를 호출할 때에는 // arguments로 선언된 클래스를 생성하여 arguments로 넣어준다. ta.useFly(new Fly() { @Override public String speed() { return "속도"; } @Override public String height() { return "높이"; } }); } }

package day0226; import java.awt.Button; import java.awt.Frame; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; public class TestAnonymous1 extends Frame { public TestAnonymous1() { super("익명클래스 연습"); Button btn = new Button("클릭~!!!"); add(btn); setSize(300, 300); setVisible(true); addWindowListener(new WindowAdapter(){ @Override public void windowClosing(WindowEvent e) { System.exit(0); } }); }// TestAnonymous1 public static void main(String[] args) { new TestAnonymous1(); }// main }// class