java 기초 공부 내용 정리(내부클래스)

내부클래스

클래스 내부에서 생성된 클래스

class OuterClass{
	class InnerClass{
    	...
	}
}

내부클래스의 사용 목적

클래스간 관계가 긴밀할 때 사용하여 코드를 간결하게 하기 위해 사용

내부클래스의 종류

내부클래스는 선언된 위치에 따라 인스턴스 클래스, 스태틱 클래스, 지역 클래스, 익명클래스로 구분된다.

1. 인스턴스클래스

1. 외부 클래스에서 멤버 변수 위치에 선언
2. 클래스 내부에서 인스턴스(객체)멤버처럼 다뤄지며, 인스턴스 멤버들과 상호작용이 가능하다.

class OuterClass{
	class InnerClass{
    	...
	}
}

2. 스태틱(static) 클래스

1. 외부클래스에서 멤버 변수 위치에 선언
2. 클래스 내부에서 static 멤버처럼 다뤄지며 static 멤버들과 상호작용 가능

class OuterClass{
	static class InnerClass{
    	...
	}
}

3. 지역 클래스

1. 메서드 내부 지역변수 위치에 선언
2. 메서드나 초기화 블록의 내부에서 다뤄지며 선언된 영역 내부에서 사용

class OuterClass{
	void A(){
    	class InnerClass{
        	...
        }
    }
}

4. 익명 클래스

무명 클래스라고도 하며, 이름이 없는 클래스를 의미
기존 클래스를 오버라이딩해서 만든다.
익명 클래스는 일회성임

<기존 클래스 구조>
class Some{
	private int a=3;
    int getter(){
    	return this.a
    }
    void setter(int a){
    	this.a=a;
    }
}

<익명 클래스 구조>
Some annoy=new Some(){
	private int a=3;
    int getter(){
    	return this.a
    }
    void setter(int a){
    	this.a=a;
    }
}

	public static void main(String[] args) {
		OuterClass1 o = new OuterClass1() {
			void a() {
				System.out.println("새롭게 정의된 익명클래스 메서드입니다.");
			}
		};
		o.a(); //출력값 : 새롭게 정의된 익명클래스 메서드입니다.
		OuterClass1 ok = new OuterClass1();
		ok.a(); // 출력값은 method a가 나옴. >> 익명클래스는 1회성임
	}
}

class OuterClass1{
	void a() {System.out.println("method a");}
	void b() {}
	
}

추상클래스 구현하는 익명클래스
	public static void main(String[] args) {
		Abstract ab = new Abstract() {
			@Override
			void f2() {
				System.out.println("Abstract extends f2()");
			}
		};
		ab.f2();		
	}
}

abstract class Abstract{
	abstract void f2();
}

인터페이스 구현하는 익명클래스

	public static void main(String[] args) {
		
		Inter1 it = new Inter1() {

			@Override
			public void f1() {
				System.out.println("inter1 imple f1()");
				
			}
			
		};
		it.f1();

	}
}

interface Inter1{
	void f1();
}

//일반 클래스
class Inter1Impl implements Inter1 {
	@Override
	public void f1() {
		
	}
}

내부 클래스의 접근성

내부클래스도 클래스이기 때문에 선언부에 접근제어자를 사용할 수 있다.

class OuterClass{
	private class InnerClass{
    ...
    }
    protected class InnerClass{
    ...
    }   
}

class A{
	static class StaticInner{}
	class InstanceInner{}
	
	StaticInner st1 = new StaticInner();
	InstanceInner ii1 = new InstanceInner();
	
	static void StaticMethod() {
		StaticInner st2=new StaticInner();
//		InstanceInner 112 = new InstanceInner(); -> 스테틱에서는 인스턴스 멤버에 접근 불가능
	}
	void InstanceMethod() {
		StaticInner st3=new StaticInner();
		InstanceInner ii3=new InstanceInner();
		
	}
}

	public static void main(String[] args) {

		OuterClass oc = new OuterClass();
		System.out.println("OuterClass의 a의 값: "+oc.a);
		System.out.println("OuterClass의 b의 값: "+OuterClass.b);
		
		System.out.println("===inner 클래스 접근하기 ===");
		OuterClass oc2 = new OuterClass();
		OuterClass.Inner i = oc2.new Inner();
		
		System.out.println("Inner의 c 값: "+i.c);
		i.innerMethod();
		
		//내부 static class 접근
		OuterClass.StaticInner si = new OuterClass.StaticInner();
		System.out.println("StaticInner의 d의 값: "+si.d);
		
		si.staticMethod(); // 객체를 사용하지 않고 클래스명을 사용해서 호출 가능
		OuterClass.StaticInner.staticMethod(); //위와 동일한 말임
	}
}

class OuterClass{
	int a=3;
	static int b=4;
	class Inner{
		int c=5;
		public void innerMethod() {
			System.out.println("<Inner Class>");
		}
	}
	
	static class StaticInner{
		int d=6;
		static int stat=10;
		public static void staticMethod() {
			System.out.println("<Static Inner>");
		}
	}
}