[JAVA] 내부클래스

내부 클래스의 종류

내부 클래스는 클래스 안에 다른 클래스를 선언하고 활용하는 것인데 이는 멤버변수와 같이 선언되는 위치에 따라서 종류가 나뉜다. 사용되는것도 멤버변수와 비슷하다. (JDK 1.1 이후에 추가된 기능)

내부클래스는 주로 AWT나 Swing과 같은 GUI어플리케이션의 이벤트처리 외에는 잘 사용하지 않을 정도로 사용빈도가 높지 않기 때문에 내부 클래스의 기본 원리와 특징을 이해하는 정도까지만 학습해도 충분하다.

내부 클래스의 종류는 다음과 같다

1. 멤버 내부 클래스

- 멤버 변수 선언하는 위치에 정의하는 내부 클래스

- 외부 클래스의 인스턴스가 생성되어야만 객체 생성 가능

- 주로 인스턴스 멤버들과 관련된 작업에 사용될 목적으로 선언

2. static 내부 클래스 (중첩클래스)

- 멤버 변수를 선언하는 위치에서 static으로 정의한 내부 클래스

- 외부 클래스와 상관없는 클래스라고 생각해도 됨

- static멤버, 특히 static메서드에서 사용될 목적으로 선언

3. 지역 내부 클래스

3-1. 이름이 있는 지역 클래스

- 외부 클래스의 메서드나 초기화블럭 안에 선언하며, 선언된 영역 내부에서만 사용 가능

3-2. 이름이 없는 지역 클래스 (익명 클래스) - 람다 표현식(lambda expression)

- 클래스의 선언과 객체의 생성을 동시에 하는 이름없는 클래스(일회용)

한 클래스를 다른 클래스의 내부 클래스로 선언하면 두 클래스의 멤버들간에 서로 접근이 쉬워지고 외부에는 불필요한 클래스를 감춤으로서 코드의 복잡성을 줄일 수 있다.

순서대로 예제를 살펴보자.

예제 1

class InnerEx1 { 
      class InstanceInner { 
            int iv=100; 
            // static int cv=100;                   // 에러! static변수를 선언할 수 없다. 
            final static int CONST = 100;       // static final은 상수이므로 허용한다. 
      } 
      static class StaticInner { 
            int iv=200; 
            static int cv=200;       //       static클래스만 static멤버를 정의할 수 있다. 
      } 
      void myMethod() { 
            class LocalInner { 
                  int iv=300; 
                  // static int cv=300;                   // 에러! static변수를 선언할 수 없다. 
                  final static int CONST = 300;       // static final은 상수이므로 허용한다. 
            } 
      } 
      public static void main(String args[]) { 
            System.out.println(InstanceInner.CONST); 
            System.out.println(StaticInner.cv); 
      } 
}

[실행결과]

100
200

내부 클래스의 유형 중에서 static 내부 클래스(중첩클래스)만 static멤버를 가질 수 있다. 거의 쓰이지 않지만 내부클래스에서 static변수를 선언해야하는 경우 static 내부 클래스를 선언해야만 한다.

예제 2

class InnerEx2 { 
      class InstanceInner {} 
      static class StaticInner {} 
 
      InstanceInner iv = new InstanceInner(); // 인스턴스 멤버간에는 서로 직접 접근이 가능하다. 
      static StaticInner cv = new StaticInner();    // static 멤버간에는 서로 직접 접근이 가능하다. 
 
      static void staticMethod() { 
              // static멤버는 인스턴스 멤버에 직접 접근할 수 없다. 
            // InstanceInner obj1 = new InstanceInner();       
            StaticInner obj2 = new StaticInner(); 
 
               // 굳이 접근하려면 아래와 같이 객체를 생성해야한다. 
            // 인스턴스 내부클래스는 외부클래스를 먼저 생성해야만 생성할 수 있다. 
            InnerEx2 outer = new InnerEx2(); 
            InstanceInner obj1 = outer.new InstanceInner(); 
      } 
 
      void instanceMethod() { 
              // 인스턴스 메서드에서는 인스턴스멤버와 static멤버 모두 접근 가능하다. 
            InstanceInner obj1 = new InstanceInner(); 
            StaticInner obj2 = new StaticInner(); 
              // 메서드 내에 지역적으로 선언된 내부클래스는 외부에서 접근할 수 없다. 
            // LocalInner lv = new LocalInner(); 
      } 
 
      void myMethod() { 
            class LocalInner {} 
            LocalInner lv = new LocalInner(); 
      } 
}

인스턴스 멤버는 같은 클래스에 있는 인스턴스멤버와 static멤버 모두 직접호출이 가능하지만, static멤버는 인스턴스멤버를 직접 호출할 수 없듯이, 내부클래스의 인스턴스클래스와 static클래스 역시 마찬가지다. 예를들어 다음과 같은 예제에서 인스턴스클래스는 외부 클래스의 인스턴스 멤버를 객체 생성없이 바로 사용할 수 있지만, 스태틱클래스는 외부클래스의 인스턴스멤버를 객체 생성을 해주어야 사용할 수 있다.

예제 3

class InnerEx3 { 
      private int outerIv = 0; 
      static int outerCv = 0; 
 
      class InstanceInner { 
            int iiv = outerIv;             // 외부클래스의 private멤버도 접근가능하다. 
            int iiv2 = outerCv; 
      } 
 
      static class StaticInner { 
            // static클래스는 외부클래스의 인스턴스 멤버에 접근할 수 없다. 
            // int siv = outerIv; 
            static int scv = outerCv; 
      } 
 
        void myMethod() { 
            int lv = 0; 
            final int LV = 0; 
 
            class LocalInner { 
                  int liv = outerIv; 
                  int liv2 = outerCv; 
                    // 외부클래스의 지역변수는 final이 붙은 변수(상수)만 접근가능하다. 
                  // int liv3 = lv; 
                  int liv4 = LV; 
            } 
      }
}

지역 클래스는 외부 클래스의 인스턴스멤버와 static멤버를 모두 사용할 수 있으며, 지역 클래스가 포함된 메서드에서 정의된 지역변수도 사용할 수 있다. 단, final이 붙은 지역변수만 접근 가능하다. 메서드가 수행을 마쳐서 지역변수가 소멸된 시점에도, 지역 클래스의 인스턴스가 소멸된 지역변수를 참조하려는 경우가 발생할 수 있기 때문에 그렇다고 한다.

예제 4

class Outer { 
      int value=10;       // Outer.this.value                         
 
      class Inner { 
            int value=20;       // this.value 
            void method1() { 
                  int value=30; 
                  System.out.println(" value :" + value); 
                  System.out.println(" this.value :" + this.value); 
                  System.out.println("Outer.this.value :" + Outer.this.value); 
            } 
      }
}
 
class InnerEx5 { 
      public static void main(String args[]) { 
            Outer outer = new Outer(); 
            Outer.Inner inner = outer.new Inner(); 
            inner.method1(); 
      } 
}

[실행결과]

value :30 

this.value :20 

Outer.this.value :10 

위의 예제는 내부클래스와 외부클래스에 선언된 변수의 이름이 같을 때 변수 앞에 'this' 또는 '외부클래스명.this'를 붙여서 서로 구별할 수 있다는 것을 보여준다.

익명 클래스 예제

익명 클래스는 이름이 없기 때문에 생성자도 가질 수 없으며, 조상클래스의 이름이나 구현하고자 하는 인터페이스의 이름을 사용해서 정의한다. 때문에 하나의 클래스로 상속받는 동시에 인터페이스를 구현하거나 하나 이상의 인터페이스를 구현할 수 없다. 오로지 단 하나의 클래스를 상속받거나 단 하나의 인터페이스만을 구현할 수 있다.

class InnerEx{ 
      Object iv = new Object(){ void method(){} };             // 익명클래스 
      static Object cv = new Object(){ void method(){} };       // 익명클래스 
 
      void myMethod() { 
            Object lv = new Object(){ void method(){} };       // 익명클래스 
      } 
}

위의 예제는 단순히 익명클래스의 사용 예를 보여 준 것이다. 이 예제를 컴파일 하면 다음과 같이 4개의 클래스파일이 생성된다.

InnerEx.class

InnerEx$1.class ← 익명클래스

InnerEx$2.class ← 익명클래스

InnerEx$3.class ← 익명클래스

익명클래스는 이름이 없기 때문에 '외부클래스명$숫자.class'의 형식으로 클래스파일명이 결정된다.

import java.awt.*; 
import java.awt.event.*; 
 
class InnerEx
{ 
      public static void main(String[] args) 
      { 
            Button b = new Button("Start"); 
            b.addActionListener(new EventHandler()); 
      } 
} 
 
class EventHandler implements ActionListener 
{ 
      public void actionPerformed(ActionEvent e) { 
            System.out.println("Action Event occured!!!"); 
      } 
}

위의 예제를 익명클래스를 이용해서 변경하면 다음과 같이 된다.

import java.awt.*; 
import java.awt.event.*; 
 
class InnerEx8 
{ 
      public static void main(String[] args) 
      { 
            Button b = new Button("Start"); 
            b.addActionListener(new ActionListener() { 
                        public void actionPerformed(ActionEvent e) { 
                              System.out.println("Action Event occured!!!"); 
                        } 
                  } 
            ); 
      }
}

위의 예제를 람다식을 이용해서 변경하면 다음과 같이 된다.

import java.awt.*; 
import java.awt.event.*; 
 
class InnerEx
{ 
      public static void main(String[] args) 
      { 
            Button b = new Button("Start"); 
            b.addActionListener(()->{ 
                   System.out.println("Action Event occured!!!"); 
            ); 
      }
}

이런식으로 주로 AWT나 Swing과 같은 GUI어플리케이션의 이벤트처리에 사용된다.

람다식은 함수를 변수에 담아둘 수 있는데 자바 8에서 람다식이 추가되고 나서는 하나의 변수에 하나의 함수를 매핑할 수 있게 되었다.

Func add = (int a, int b) -> a + b;

위와같이 변수에 함수를 담고 싶을때 Func이라는 타입은 무엇이어야 할까?

바로 interface이다. 아래와 같이 Func인터페이스를 작성하면 된다

interface Func {
    public int calc(int a, int b);
}

이 인터페이스에서는 calc라는 하나의 추상메서드를 가지고 내부 구현은 어떻게 할지 아직 정해지지 않았다.

내부 구현을 위에서 람다식을 통해서 구현해준 것인데 여기서 의문은 Func인터페이스에 메서드를 추가하게 되면?? 어떻게 될까

람다식으로 구현했던 add 함수 코드에서 오류가 발생한다. 기본적으로 람다식을 위한 인터페이스에서 추상메서드는 단 하나여야한다. 이를 위해 람다식을 위한 인터페이스임을 표현하기 위해서 @FunctionalInterface라는 어노테이션을 사용한다. 실제로 이 어노테이션을 선언하면 해당 인터페이스에 메서드를 두 개 이상 선언하면 유효하지 않다는 오류를 낸다. (컴파일러 수준에서 오류 확인이 가능)

@FunctionalInterface
interface Func {
    public int calc(int a, int b);
}

위의 add 변수에 담은 함수를 다음과 같이 활용할 수 있다.

int result = add.calc(1,2) + add.calc(3, 4); // 10

참고 : http://jhmocu.tistory.com/41

https://m.blog.naver.com/kjc8108/220654750643

http://linuxism.tistory.com/1002