클래스 안의 클래스 Inner class <- Outer class 에게 허락을 맡아라

< *내부 클래스 > 

class B{ } 만들어두면 
다른 클래스들에서 모두 B b1 = new B( ); 객체 생성해서 쉽게 사용가능

 
근데 일단은 나만 쓰고 싶다.

다른 클래스에스 쓰고싶으면 나한테 허락맡고 쓰게하고싶다?  
=> 내부클래스로 만들면 된다. 

 

class Outer{  int i = 10;
    class Inner {  int j = 20;
        void innermethod( ){
            System.out.println(j); } }

    static class Inner2{ static int k =30;    }

    //outer 메소드
    void outermethod(){
        class Inner3{               //지역변수로 쓰이는 이너클래스. => 이 메소드 내부에서만 사용 가능
            int n = 40;}  } }

< Inner class 는 > 

=> (기본) 그 클래스에서만 객체로 사용 가능
=> 다른 클래스에서 사용하고 싶으면, 
    Outer 부터 객체생성하고 => 그 객체로 inner객체 까지 생성해야 사용가능 (허락 맡아라!) 

 

=>내부클래스는 멤버변수처럼 사용할 수 있다 
=>  static class 가능 ( 클래스로 바로소환 )

 

 

< 일반이너클래스 VS static 이너클래스 > 

=> static inner클래스는 외부,내부클래스로 객체생성없이 접근 가능                         

 

System.out.println(Outer.Inner2.k);      
Outer.Inner oi = new Outer.Inner();
객체 생성도 클래스 이용해서 이렇게 바로 할 수 있음 ( static ) 

=> 일반 inner 클래스의 경우,  ( 다른 클래스에서 일반 inner 클래스에 접근하고 싶으면 ) 

 

- 먼저 Outer 클래스부터 객체생성 

Outer out = new Outer();       

System.out.println(Outer.Inner.j);   (X)   
//일반 inner클래스는 Outer 클래스를 객체화 했어도 바로 접근 불가능
//Inner 클래스까지 객체화를 완료해야 사용 가능

Outer.Inner oi = new Outer.Inner( );  (X)   
// 이렇게 객체생성 못함. static 이너클래스일때만 이렇게 클래스 직접이용 가능
// Outer 클래스 "객체"를 통해서만 Inner 클래스에 접근이 가능하기 때문

 

Outer 객체 out 생성해둔걸 이용해서 

Outer.Inner oi = out.new Inner( );   (O)     < 객체.new Class >

(1) out .new inner( ); 

Outer 클래스의 객체 (out) 를 이용해서 ( . 쩜찍기 ) new 새로운 Inner 객체를 만들겠다.

(- 이 표현문법에 익숙해져야한다!)

 

(2) Outer . Inner oi   =  

이렇게 만들어진 Inner 객체 (oi) 의 타입은 단순한 Inner 클래스 타입이 아니다. ( Inner 로만 받으면 오류가 납니다! ) 

이 내부객체는 특이한놈이다. 이름그대로 내부에 있는 놈이다. 그렇기 때문에, 타입 자체도 단순한 클래스들과 달리, 

 

     " 저 내부에 있는 놈이에요! "

 

하고 알려주는 타입을 써야한다. 

 

<외부클래스 . 내부클래스>  타입       

Outer.Inner  oi             

 

(- 이 표현문법에도 익숙해져야한다! )

 

 

=>  일반 이너클래스는  
       Outer 클래스의 객체 (out) 를 이용해서 => 이너클래스의 객체를 생성   ( oi ) 
   

=>  이렇게 이너클래스 객체까지 생성을 완료해두면,  그걸로 이너클래스 사용 가능

System.out.println( oi. j );               
                                     
oi. innermethod( );

 

--

=> 이 과정을 단축해서 쓰면  ( A - 외부클래스 /  B - 내부클래스 ) 

A a2 = new A (  );           // 외부클래스 객체화 
A.B b2 = a2.new B( );    // 외부클래스 객체이용해서 내부클래스 객체생성 

 

=> 이걸 한방에

     내부객체b2  =    외부객체 A 생성. 내부객체 B 생성 ; 

A.B   b2    =    new A( ).new B( );

 

 

이렇게도 가능하다.   

(  외부객체 A ( = out) 를 생성함과 동시에 그대로 가져다가  . (쩜) 으로 바로 쓰는것

      newA ( )   =  out                                 )  

 

--- 

< 내부클래스 -  멤버변수  > 

 

내부클래스    =>   외부클래스의 멤버변수 사용 가능                                                 ( 1.8 이후 가능 )  

 

class A { int a = 10; 
class B{ int b = 20; 
sout (a);   } }                  Ok 

반대로 외부클래스 => 내부클래스 멤버변수는 사용 불가능 
class A { int a = b; <= 오류 
class B{ int b = 20; } } 

--- 

 

 

 

 

< 밖에서 만든 class => Inner class 로 만들기 > 

 

class B { ~~ }                     // 밖에서 만들어진 B 클래스. 



class A { B b1= new B( );  //원래 쓰듯이 객체생성하고  
class B{ }     }       <= 이렇게 클래스 내부에서 클래스를 "선언"만 하게되면   
이게 InnerClass (내부클래스) 가 됨. 
=> A 전용 클래스임을 선언하는 것 
=> 다른 클래스에서는 이제 바로는 사용 불가능

 

class C{ B b1 = new B( ); }   =>  오류. 

=> Outer 허락맡고, Outer 부터 객체 생성 => 이용해서 inner 객체 생성 => 하고 나서 그때부터 사용가능 

 

람다식 등에 필요한 개념이니 잘 숙지해둬야겠다.