자바 향상 편(7)-내부 클래스 상세 설명

11783 단어 자바
하나의 클래스 의 정 의 를 다른 클래스 의 정의 내부 에 놓 을 수 있 습 니 다.이것 이 바로 내부 클래스 입 니 다.
내부 류 는 매우 유용 한 특성 이지 만 사용 하 는 특성 을 이해 하기 어렵다.
첫 대면
내부 류 는 우리 가 밖에서 보면 매우 쉽게 이해 할 수 있 는데,단지 하나의 내부 에서 하나의 종 류 를 정의 하 는 것 일 뿐이다.
public class OuterClass {
    private String name ;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    class InnerClass{
        public InnerClass(){
            name = "chenssy";
            age = 23;
        }
    }
}

여기 서 InnerClass 는 내부 류 입 니 다.초보 자 에 게 내부 류 는 정말 많이 사용 되 지 않 습 니 다.저 는 초보 자 하나 도 별로 사용 하지 않 았 습 니 다.(swing 등록 사건 에서 만 사용 한 것 같 습 니 다)그러나 프로 그래 밍 능력 이 향상 되면 서 우 리 는 그 매력 을 깨 닫 게 될 것 입 니 다.이 는 우리 의 프로그램 구 조 를 더욱 우아 하 게 디자인 할 수 있 습 니 다.내부 류 를 사용 하 는 사이 에 우 리 는 왜 내부 류 를 사용 해 야 하 는 지,내부 류 가 우리 에 게 어떤 이익 을 가 져 다 줄 수 있 는 지 알 아야 한다.
1.왜 내부 클래스 를 사용 합 니까?
왜 내부 류 를 사용 합 니까?'Think in java'에 서 는 내부 류 를 사용 하 는 것 이 가장 매력 적 인 이 유 는 모든 내부 류 가 하나의(인터페이스의)실현 을 독립 적 으로 계승 할 수 있 기 때문에 외곽 류 가 이미 어떤(인터페이스의)실현 을 계승 하 든 내부 류 에 영향 을 주지 않 는 다 는 것 이다.
우리 프로 그래 밍 에 가끔 인 터 페 이 스 를 사용 하여 해결 하기 어 려 운 문제 가 존재 할 때 우 리 는 내부 류 가 제공 하 는 여러 가지 구체 적 이거 나 추상 적 인 능력 을 계승 하여 이런 프로 그래 밍 문 제 를 해결 할 수 있다.이렇게 말 하면 인 터 페 이 스 는 일부 문 제 를 해 결 했 을 뿐 내부 류 는 다 중 상속 의 해결 방안 을 더욱 완전 하 게 만 들 었 다.
public interface Father {

}

public interface Mother {

}

public class Son implements Father, Mother {

}

public class Daughter implements Father{

    class Mother_ implements Mother{
        
    }
}

사실 이 실례 에 대해 우 리 는 내부 류 를 사용 하 는 데 어떤 장점 이 존재 하 는 지 확실히 알 수 없다.그러나 만약 에 아버지,어머니 가 인터페이스 가 아니 라 추상 류 나 구체 류 라면?이 럴 때 우 리 는 내부 류 를 사용 해야만 다 중 상속 을 실현 할 수 있다.
사실 내부 클래스 를 사용 하 는 가장 큰 장점 은 다 중 상속 문 제 를 잘 해결 할 수 있다 는 것 이다.그러나 우리 가 다 중 상속 문 제 를 해결 할 필요 가 없다 면 우 리 는 다른 인 코딩 방식 을 사용 할 수 있 지만 내부 클래스 를 사용 하면 다음 과 같은 특성 을 가 져 다 줄 수 있다.
1.내부 류 는 여러 개의 인 스 턴 스 를 사용 할 수 있 고 모든 인 스 턴 스 는 자신의 상태 정 보 를 가지 고 다른 외곽 대상 의 정보 와 서로 독립 할 수 있다.
2.하나의 외곽 류 에서 여러 내부 류 가 서로 다른 방식 으로 같은 인 터 페 이 스 를 실현 하거나 같은 종 류 를 계승 할 수 있다.
3.내부 클래스 대상 을 만 드 는 시간 은 외부 클래스 대상 의 생 성 에 의존 하지 않 습 니 다.
4.내부 유형 은 사람 을 현혹 시 키 는'is-a'관계 가 없고 그 는 독립 된 실체 이다.
5.내부 류 는 더 좋 은 포장 을 제공 하고 이 외곽 류 를 제외 하고 다른 류 는 방문 할 수 없습니다.
2.내부 유형의 기초
이 부분 에 서 는 내부 클래스 가 외부 클래스 의 속성 과 방법 을 어떻게 사용 하 는 지,그리고.this 와.new 를 사용 하 는 지 소개 합 니 다.
우리 가 내부 클래스 를 만 들 때,그것 은 어느새 외곽 클래스 와 연결 되 어 있 으 며,이러한 연결 에 의존 하여,외곽 클래스 의 요 소 를 무제한으로 접근 할 수 있다.
public class OuterClass {
    private String name ;
    private int age;

    /**  getter setter  **/
    
    public class InnerClass{
        public InnerClass(){
            name = "chenssy";
            age = 23;
        }
        
        public void display(){
            System.out.println("name:" + getName() +"   ;age:" + getAge());
        }
    }
    
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();
    }
}
--------------
Output:
name:chenssy   ;age:23

이 프로그램 에서 내부 에서 InnerClass 는 외부 클래스 OuterClass 의 속성 을 빈 틈 없 이 방문 할 수 있 습 니 다.비록 private 가 수 정 했 지만.이것 은 우리 가 특정한 외곽 류 의 내부 클래스 대상 을 만 들 때 내부 클래스 대상 은 반드시 그 외곽 류 대상 을 가리 키 는 인용 을 포착 하기 때문이다.우리 가 외곽 류 의 구성원 을 방문 할 때 이 인용 으로 외곽 류 의 구성원 을 선택 하기 때문이다.
사실 이 프로그램 에서 내부 클래스 를 인용 하 는 방법 도 보 았 습 니 다.내부 클래스 를 인용 하려 면 이 대상 의 유형 을 가리 켜 야 합 니 다:OuterClasName.InnerClassName.또한 내부 클래스 대상 을 만 들 려 면 외부 클래스 의 대상 을 이용 하여.new 를 통 해 내부 클래스 를 만들어 야 합 니 다:OuterClass.InnerClass innerClass=outerClass.new InnerClass().
또한 외부 클래스 대상 의 인용 을 생 성 하려 면 OuterClassName.this 를 사용 하면 외부 클래스 를 정확하게 인용 할 수 있 습 니 다.물론 이 점 은 실제 컴 파일 기간 에 알 수 있 고 운영 시의 비용 이 전혀 없다.
public class OuterClass {
    public void display(){
        System.out.println("OuterClass...");
    }
    
    public class InnerClass{
        public OuterClass getOuterClass(){
            return OuterClass.this;
        }
    }
    
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.getOuterClass().display();
    }
}
-------------
Output:
OuterClass...

여기까지 왔 습 니 다.우 리 는 내부 류 는 컴 파일 할 때의 개념 이 고 컴 파일 에 성공 하면 외곽 류 와 완전히 다른 두 가지 유형 에 속 합 니 다(물론 그들 사이 에는 관계 가 있 습 니 다).OuterClass 라 는 외곽 클래스 와 InnerClass 라 는 내부 클래스 에 대해 컴 파일 에 성공 하면 다음 두 개의 class 파일 이 나타 납 니 다:OuterClass.class 와 OuterClass$InnerClass.class.class.
자바 에서 내부 류 는 주로 구성원 내부 류,국부 내부 류,익명 내부 류,정태 내부 류 로 나 뉜 다.
3.구성원 내부 클래스
구성원 내부 클래스 도 가장 일반적인 내부 클래스 로 외곽 클래스 의 한 구성원 이기 때문에 그 는 외곽 클래스 의 모든 구성원 속성 과 방법 을 무제 한 방문 할 수 있다.비록 private 이지 만 외곽 클래스 가 내부 클래스 의 구성원 속성 과 방법 을 방문 하려 면 내부 클래스 의 인 스 턴 스 를 통 해 방문 해 야 한다.
구성원 내부 클래스 에서 두 가 지 를 주의해 야 한다.첫째,구성원 내부 클래스 에 static 의 변수 와 방법 이 존재 해 서 는 안 된다.둘째,구성원 내부 클래스 는 외곽 클래스 에 의존 하기 때문에 외곽 클래스 를 먼저 만들어 야만 내부 클래스 를 만 들 수 있다.
public class OuterClass {
    private String str;
    
    public void outerDisplay(){
        System.out.println("outerClass...");
    }
    
    public class InnerClass{
        public void innerDisplay(){
            //        
            str = "chenssy...";
            System.out.println(str);
            //        
            outerDisplay();
        }
    }
    
    /*    getxxx()        ,                 */
    public InnerClass getInnerClass(){
        return new InnerClass();
    }
    
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.getInnerClass();
        inner.innerDisplay();
    }
}
--------------------
chenssy...
outerClass...

getxxx()를 사용 하여 구성원 내부 클래스 를 가 져 오 는 것 을 추천 합 니 다.특히 이 내부 클래스 의 구조 함수 가 인자 가 없 을 때.
4.부분 내부 류
이러한 내부 유형 이 있 는데 이것 은 방법 과 작용 에 포 함 된 것 이다.이런 유형의 사용 은 주로 응용 과 해결 이 비교적 복잡 한 문 제 를 해결 하 는 것 이다.우 리 를 보조 하 는 해결 방안 을 만 들 려 고 한다.그 때 는 이런 유형 이 공공 적 으로 사용 되 는 것 을 원 하지 않 기 때문에 국부 내부 류 를 생산 했다.국부 내부 류 는 구성원 내부 류 와 마찬가지 로 컴 파일 되 었 다.다만 그 역할 영역 이 바 뀌 었 을 뿐 이 방법 과 속성 에서 만 사용 할 수 있 고 이 방법 과 속성 이 나 오 면 효력 을 잃 습 니 다.
부분 내부 류 에 대해 서 는 좋 은 예 가 떠 오 르 지 않 아'Think in java'의 대표 적 인 예 를 인용 했다.
방법 에 정의:
public class Parcel5 {
    public Destionation destionation(String str){
        class PDestionation implements Destionation{
            private String label;
            private PDestionation(String whereTo){
                label = whereTo;
            }
            public String readLabel(){
                return label;
            }
        }
        return new PDestionation(str);
    }
    
    public static void main(String[] args) {
        Parcel5 parcel5 = new Parcel5();
        Destionation d = parcel5.destionation("chenssy");
    }
}

역할 영역 에 정의:
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("chenssy");
            String string = ts.getSlip();
        }
    }
    
    public void track(){
        internalTracking(true);
    }
    
    public static void main(String[] args) {
        Parcel6 parcel6 = new Parcel6();
        parcel6.track();
    }
}

5.익명 내부 클래스
스윙 프로 그래 밍 을 할 때,우 리 는 항상 이런 방식 으로 사건 을 귀속 시킨다
button2.addActionListener(  
                new ActionListener(){  
                    public void actionPerformed(ActionEvent e) {  
                        System.out.println("      ");  
                    }  
                });

우 리 는 어떻게 보면 매우 이상 하 다 고 느 낄 수 있 습 니까?왜냐하면 이 내부 류 는 이름 이 없 기 때 문 입 니 다.다음 과 같은 예 를 보고 있 습 니 다.
public class OuterClass {
    public InnerClass getInnerClass(final int num,String str2){
        return new InnerClass(){
            int number = num + 3;
            public int getNumber(){
                return number;
            }
        };        /*   :      */
    }
    
    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        InnerClass inner = out.getInnerClass(2, "chenssy");
        System.out.println(inner.getNumber());
    }
}

interface InnerClass {
    int getNumber();
}

----------------
Output:
5

여 기 는 저희 가 몇 군데 잘 봐 야 돼 요.
1.익명 내부 클래스 는 수정자 에 접근 하지 않 았 습 니 다.
2.new 익명 내부 류,이런 종 류 는 먼저 존재 해 야 합 니 다.만약 우리 가 그 InnerClass 인 터 페 이 스 를 주석 한다 면,컴 파일 오류 가 발생 할 것 이다.
3.getInnerClass()방법의 형 삼 에 주의 하 세 요.첫 번 째 형 삼 은 final 로 수식 한 것 이 고 두 번 째 는 없습니다.이 동시에 두 번 째 형 삼 은 익명 내부 류 에서 사용 한 적 이 없 기 때문에 해당 방법의 형 삼 은 익명 내부 류 에 의 해 사용 되 어야 한다.그러면 이 형 삼 은 반드시 final 이 어야 한다.
4.익명 내부 류 는 구조 방법 이 없다.이름 도 만 드 는 방법 이 없 기 때문이다.
PS:편폭 이 제한 되 어 있 기 때문에 익명 내부 류 에 대해 여기까지 소개 하고 익명 내부 류 에 관 한 더 많은 지식 에 대해 저 는 다음 블 로그(자바 향상 편-익명 내부 류 상세 설명)에서 상세 한 소 개 를 하 겠 습 니 다.왜 형 삼 이 final 로 정의 하고 익명 내부 류 를 어떻게 초기 화 하 는 지 등 을 포함 하여 기대 하 시기 바 랍 니 다.
6.정적 내부 클래스
자바 향상 편-키워드 static 에서 Static 는 구성원 변수,방법,코드 블록 을 수식 할 수 있 고 다른 것 은 내부 류 를 수식 할 수 있 으 며,static 로 수식 하 는 내부 류 를 우 리 는 정적 내부 류 라 고 부 르 지만,우 리 는 내장 내부 류 라 고 부 르 는 것 을 더욱 좋아한다.정적 내부 클래스 와 비 정적 내부 클래스 사이 에 가장 큰 차이 가 존재 합 니 다.우 리 는 비 정적 내부 클래스 가 컴 파일 이 완 료 된 후에 인용 을 은연 중 에 저장 한 다 는 것 을 알 고 있 습 니 다.이 인용 은 그 외곽 을 만 드 는 것 을 가리 키 지만 정적 내부 클래스 는 없습니다.이 인용 이 없 으 면 다음 을 의미 합 니 다.
1.그 생 성 은 외곽 류 에 의존 할 필요 가 없습니다.
2.외부 클래스 의 비 static 구성원 변수 와 방법 을 사용 할 수 없습니다.
public class OuterClass {
    private String sex;
    public static String name = "chenssy";
    
    /**
     *     
     */
    static class InnerClass1{
        /*                 */
        public static String _name1 = "chenssy_static";
        
        public void display(){
            /* 
             *                       
             *                   
             */
            System.out.println("OutClass name :" + name);
        }
    }
    
    /**
     *       
     */
    class InnerClass2{
        /*                 */
        public String _name2 = "chenssy_inner";
        /*                    ,             */
        public void display(){
            System.out.println("OuterClass name:" + name);
        }
    }
    
    /**
     * @desc      
     * @author chenssy
     * @data 2013-10-25
     * @return void
     */
    public void display(){
        /*           :   . */
        System.out.println(InnerClass1._name1);
        /*                         */
        new InnerClass1().display();
        
        /*                  */
        OuterClass.InnerClass2 inner2 = new OuterClass().new InnerClass2();
        /*                          */
        System.out.println(inner2._name2);
        inner2.display();
    }
    
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display();
    }
}
----------------
Output:
chenssy_static
OutClass name :chenssy
chenssy_inner
OuterClass name:chenssy

위의 이 예 는 정적 내부 류 와 비 정적 내부 류 의 차 이 를 충분히 보 여 주 었 다.
여기까지 내부 소개 가 거의 끝 났 습 니 다!내부 류 에 대해 사실은 본인 이 아 는 것 도 모피 일 뿐 입 니 다.초보 에 게 다가 가면 인지 에 한계 가 있 습 니 다!나 는 요 며칠 동안 내부 류 를 잘 연구 할 것 이다!
기 초 를 공 고 히 하고 기술 을 향상 시 키 며 어려움 을 두려워 하지 않 고 고봉 등반!!!!!!

좋은 웹페이지 즐겨찾기