Java2 -07. 내부클래스 (inner)

 : inner 클래스
 - 안드로이드 에서 주로 쓰임

  

< 종류 >

  1. instance 이너 클래스
  2. local  이너
  3. static 이너 
  4. (anonymous) 익명 이너 클래스

  (1번과4번을 위주로 공부)

  

#기본 구조

 class Person{
  Eye eye;
 }
 class Eye{}
 ------------------
 class Person{
  class Eye{ // 내부 클래스

  }
 }

  

1. instance 이너 클래스

(1) instance 사용

package instanceex;

class Outer{

//타입  변수
 int   num;    // 인스턴스 변수
 
 //인스턴스 내부 클래스 (instanceInner class)-->타입의 역할 수행
 class Value{
  int val1;
  int val2;
  int val3;

  //class임으로 메서드 생성가능
  void m(){
  }
  void n(){
  }
  
 }
}

public class InstanceInner {

 public static void main(String[] args) {
 
  Outer.Value myValue = new Value();
  // error나는 이유 --> Outer 가 생성되지 않았는기때문에 Value가 나올수 없음
  //Outer에 의해 좌지우지 됨
  

  Outer.Value myValue =null;
  myValue= new Outer().new Value();

  
  myValue.val1=10;
  myValue.val1=20;
  myValue.val1=30;

 }

}

(2) instance inner 사용 이유

ex1)

package instanceex;
class Data{
 int commonValue=0x123456;  //--> 공통값이므로 이 값이 바뀌면 나머지도 같이 바뀌었으면 좋겠다 
 
 class Num3{
  int num3 = commonValue;
  // 외부에 있는 commonValue 를 생성자 없이 언제든 공유할 수 있다
  //num1,num2 처럼 인스턴스를 생성하지않고 바로 사용 가능
 }
 
}
class Num1{
 int num1;
 Num1(){
  Data d = new Data();
  num1= d.commonValue;
 }
}
class Num2{
 int num2= new Data().commonValue;
 
}
public class InstanceInner2 {

 public static void main(String[] args) {
  
 }

(3) 인스턴스이너 호출

package instanceex;

import java.util.Date;

class MyCalendar{
 Date date = new Date();
 

 //instanceInner 클래스
 class Diary{
  void record(){
   System.out.println(date+"다이어리 구매");
  }
 }
 class Household_ledger{
  void buy(){

   System.out.println(date+"에 시장을 감");
  }
 }
}
public class InstanceInner3 {

 public static void main(String[] args) {
  
  //#1. 메서드 호출할 때마다 인스턴스를 만들자
  

  new MyCalendar().new Diary().record();
  new MyCalendar().new Household_ledger().buy();
  
  //#2. 외부 객체를 하나 만든 후 , 내부 인스턴스를 호출하자
  
  MyCalendar cal= new MyCalendar();
  
  cal.new Diary().record();
  cal.new Household_ledger().buy();
  
  //#3. 인스턴스 객체를 만든후에 내부 호출
  
  MyCalendar.Diary myD= new MyCalendar().new Diary();
  myD.record();
  
  MyCalendar.Household_ledger myH= new MyCalendar().new Household_ledger();
  myH.buy();
  
  //#4. 만든 인스턴스 객체에 외부객체를 사용하여 호출
  
  myD=cal.new Diary();
  myH=cal.new Household_ledger();
  
    
 }

}

#실습

package instanceex;

import java.util.Date;
class HumanFace{
 String faceColor="노란색";
 class Eye{
  String eyeColor=faceColor; //인스턴스이너이므로 바로 사용가능
  int eH,eW;
 }
}
class Nose{
 String noseColor;
 int nH,nW;

 //instanceInner이 아니기 때문에 직접 만들어 주어야한다
 Nose(){
  noseColor= new HumanFace().faceColor;
  
 }
}
public class InstanceInner4 {

 public static void main(String[] args) {
  
  String fColor="";
  String eColor="";
  String nColor="";
  
  HumanFace hf= new HumanFace();
  fColor=hf.faceColor;
  
  HumanFace.Eye ec= new HumanFace().new Eye();
  eColor=ec.eyeColor;
  
  Nose nc=new Nose();
  nColor = nc.noseColor;
  
  System.out.println("얼굴색 :" +fColor);
  System.out.println("눈 색 :" +eColor);
  System.out.println("코 색 :" +nColor);
  
  System.out.println("--------------------");
  
  hf.faceColor="빨강색";
  fColor=hf.faceColor;
  eColor=hf.faceColor;
  
  System.out.println("얼굴색 :" +fColor);
  System.out.println("눈 색 :" +eColor);
  System.out.println("코 색 :" +nColor);
  
  System.out.println("--------------------");
  
  //파란색
  hf.faceColor="파란색";
  ec.eyeColor=hf.faceColor;
  
  System.out.println("얼굴색 :" +hf.faceColor);
  System.out.println("눈 색 :" +hf.new Eye().eyeColor);
  System.out.println("코 색 :" +nColor);
  
 }

}

  2. local  이너

  ※ 내부 클래스의 위치가 로컬화 되어 있다
       ( 지역화 )
       ( 메서드 안에 )
       
 1. 지역화 되어 있다 : 해당 {} 안에서만 쓸 수 있다
 2. 내부 클래스가 지역화 되어 있으면
   객체 생성 --> 객체.메서드() 호출 까지를 해당 메서드 안에서 다 처리해야 한다
   *왜? --> 클래스 단어를 메서드 밖에서는 모른다

#실습

package localex;
class Outer{
 int num;// 인스턴스
 class inner{}//인스턴스
 
 void print(int choice){
  
  class localInner{ // local 이너
   void hpPrinter(){
    System.out.println("hp로 인쇄");
   }
   void epsonPrinter(){
    System.out.println("epson으로 인쇄");
   }
   void samsunPrinter(){
    System.out.println("samsung으로 인쇄");
   }
  }// end local 이너 클래스
  // end local 과 end print 사이의 공간에 로컬인스턴스를 만들어줌
  
  localInner local = new localInner();
  
  if(choice==1){
   local.hpPrinter();
  }else if(choice==2){
   local.epsonPrinter();
  }else if(choice==3){
   local.samsunPrinter();
  }
 }//end print : localInner는 여기 밖에서는 쓸수 없다 --> 클래스 단어 자체가 지역화되어있다는 소리
 
}
public class LocalInner {

 public static void main(String[] args) {

  new Outer().print(1);
  new Outer().print(2);
  new Outer().print(3);
 }

}

  3. static 이너 

 
  * 내부 클래스를 만들떄,
   static 이라는 키워드가 붙어있는 상태
 
  1. static 을 붙일 수 밖에 없는 상황
     : 내부 클래스를 구성하는 맴버중에
     static 변수나 static 메서드가 있다면 내부 클래스는  static 키워드를 붙여야 한다
     

#실습

package staticex;
class Outer{

 int num=111;
 // 인스턴스를 만들어야 사용할 수 있는 변수
 
 static int stNum=777;
 // 인스턴스를 만들지 않아도 사용 할수 있는 변수
}
public class StaticInner {

 public static void main(String[] args) {

  System.out.println(Outer.stNum);
  // 인스턴스 없어도 사용 가능
  
  Outer in = new Outer();
  System.out.println(in);
  // 인스턴스를 만들어야 사용 가능
 }

}

#실습 2

package staticex;
class Outer2{
 //static 은 top class에서 사용 가능
 
 class inner{
  
  void innerMethod(){ // <=== new Outer3().new inner() 인스턴스만들고 인스턴스 만든다 
   System.out.println("inner 메서드");
  }
 }
 static class stInner{// <== new Outer3.stInner(); 바로 만드는 것 가능
  static void staticMethod(){
   System.out.println("Inner 메서드2");
   
  }
 }
}

public class StaticInner2 {

 public static void main(String[] args) {

  
  Outer2.stInner.staticMethod();
  //이미 stInner는 인스턴스화 되었기 때문에
  //굳이 new Outer3.stInner()생성자가 필요없다
 }

}