JAVA :: Test122~124_중첩 클래스

○ 중첩 클래스

중첩 클래스란 클래스 안에 다른 클래스가 설계되어 있는 형태로

클래스 내부에서만 사용할 보조 클래스가 필요한 경우 클래스를 중첩하여 프로그램의 구조를 보다 더 간단하고 알아보기 쉽도록 만들 수 있는데 이러한 클래스를 중첩 클래스라 한다.

이는, 특정 클래스를 자신의 클래스 내부적인 용도로만 사용할 목적으로 쓰이는데

특정 클래스를 마치 자신의 멤버 변수나 메소드처럼 사용할 수 있게 한다.

 

○ 중첩 클래스의 종류(4가지)

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

  → 클래스 내부에.. 『public static class  클래스명』

• 중첩 클래스를 감싸는 외부 클래스의 『{}』 안에 static을 붙인 새로운 클래스를 설계하는 것으로 모든 접근제어지시자를 사용할 수 있다.
• static 중첩 클래스가 포함하고 있는 메소드에서는 외부 클래스의 인스턴스 변수나 인스턴스 메소드에는 접근할 수 없고, (외부 클래스의 객체를 생성하지 않은 상태) 클래스 변수와 클래스 메소드만 접근할 수 있다.
• 프로그램의 구조를 보다 더 간단하고 알아보기 쉽게 구성할 수 있다.
• static 으로 선언된 내부 클래스이다.
• 중첩 클래스의 객체는 중첩 클래스를 포함하고 있는 외부 클래스의 객체와 동등하다.
• 외부 클래스의 클래스 변수와 클래스 메소드는 바로 접근하여 사용하는 것이 가능하다.
• 중첩 클래스와 중첩 클래스를 포함하고 있는 외부 클래스의 인스턴스 변수와 인스턴스 메소드는 객체를 생성하여 서로 접근하는 것이 가능하다.
• 중첩 클래스를 외부에서 단독으로 사용하는 것이 가능하다.

2. 내부 클래스 (inner class)

  → 클래스 내부에... 『public class  클래스명』

• static 중첩 클래스와 마찬가지로 프로그램 구조를 보다 더 간단하고 알아보기 쉽도록 하기 위해 구성한다.
• 외부 클래스의 메소드에서 내부 멤버 클래스를 사용하기 위해서는 반드시 내부 멤버 클래스 객체를 생성해 주어야 한다.
• 외부 클래스의 멤버 변수와 메소드를 객체 생성 없이 바로 사용하는 것이 가능하다.
• 내부 멤버 클래스는 외부에서 단독으로 객체를 생성하여 사용할 수 없다.
• 즉, 내부 멤버 클래스는 외부 클래스의 인스턴스 생성이 선행되어야 한다는 것이다.
• static 으로 선언된 변수 또는 메소드를 가질 수 없다.

3. 지역 클래스 (로컬 클래스, local class)

  → 메소드 내부에... 『class  클래스명』 또는 『static class 클래스명』

• 클래스의 메소드 안에서 클래스를 정의하는 것으로 내부 멤버 클래스와 유사한 성격을 가지고 있긴 하지만 접근제어지시자는 붙일 수 없다.

4. 무명 클래스 (익명 클래스, annoymous class)

   → 이름 없는 클래스

• 클래스 또는 인터페이스에 대한 객체를 생성하면서 바로 클래스 또는 인터페이스를 정의하는 클래스
• 정의하는 부분과 생성하는 부분이 하나로 묶여져 new 수식이 있는 곳에서 바로 클래스 또는 인터페이스를 정의하는 것을 의미한다.

 

▼ Test122 (static 중첩 클래스)

// outer
class Test
{
	static int a = 10;			//-- static 클래스 변수(클래스가 로딩되는 시점에 메모리 할당. 클래스 변수는 클래스 이름으로 접근)
	int b = 20;

	// inner
	public static class StaticNested
	{
		int c = 30;
		void write()
		{
			System.out.println("write()...");
			System.out.println("a : " + a);
			//System.out.println("b : " + b);
			System.out.println("c : " + c);

		}
	}
	void print()
	{
		StaticNested sn = new StaticNested();
		sn.write();			
	}
}

// main() 메소드가 포함된 클래스
public class Test122
{
	public static void main(String[] args)
	{	
		// 밖에서... Test 기반 인스턴스 생성(→ outer)
		Test ob = new Test();
		ob.print();
		//--==>>write()...
		//      a : 10
		//		c : 30


		// 밖에서... StaticNested 기반 인스턴스 생성(→ inner)
		//StaticNested ob2 = new StaticNested();
		//--==>> 에러 발생(컴파일 에러)

		// ※ 중첩 내부 클래스는 외부에서 단독으로 객체를 생성한다.
		//	  단, 위와 같은 방법으로 객체를 생성해서는 안되고,
		//	  클래스 변수 접근이나 클래스 메소드를 호출하는 것과 같은 방식을 통해
		//	  접근하여 인스턴스를 생성할 수 있도록 처리해야 한다.

		// Test.a;

		Test.StaticNested ob2 = new Test.StaticNested();			// Test.StaticNested → Test클래스 안에 들어있는 StaticNested야~
		ob2.write();
		//--==>> write()...
		//		 a : 10
		//		 c : 30
	}
}

▼ Test123 (내부 클래스)

// outer
class Test2
{
	static int a = 10;
	int b = 20;

	void write()								//-- 첫 번째 write() 메소드
	{
		System.out.println("write()...①");
		final int c = 20;
		int d = 40;

		// inner
		// 메소드 안에 존재하는 또다른 클래스(로컬 클래스, local class, 지역 클래스)
		class LocalTest
		{
			void write()						//-- 두 번째 write() 메소드
			{
				System.out.println("write()...②");
				System.out.println("a : " + a);
				System.out.println("b : " + b);
				System.out.println("c : " + c);
				//System.out.println("d : " + d);			//-- 안정적인 상태가 아니니까 문제 삼는거야!
				//--==>> 에러 발생(컴파일 에러)
			}
		}

		// ※ 변수 c와 변수 d는 둘 다 지역변수이지만...
		//	  (첫 번째 write() 메소드 안에서 선언된 변수이므로...)
		//    c는 final 변수이기 때문에
		//	  두 번째 write() 메소드에서 언제 접근하더라도
		//	  고정된 값 20이 담겨있음을 보장받을 수 있다.
		//    반면에 d는 그 값이 수시로 변화될 수 있는 상황이므로
		//	  LocalTest 클래스의 인스턴스 생성 시점이
		//	  언제가 될지 알 수 없기 때문에
		//	  이로 인해 인스턴스 생성 시점에 d에 어떤 값이 담겨있을지를
		//	  보장받을 수 없게 된다.
		//	  변수 d에 접근하는 것은 피할 수 있도록 문법적으로 처리하는 것이다.

		//d+=10;

		d++;
		
		// LocalTest 클래스 기반 인스턴스 생성 (→ inner)
		LocalTest lt = new LocalTest();
		lt.write();								//-- 두 번째 write() 메소드 호출


		d+=20;

	}
}

public class Test123
{
	public static void main(String[] args)
	{
		// Test2 클래스 기반 인스턴스 생성(→ outer)
		Test2 ob = new Test2();
		ob.write();								//-- 첫 번째 write() 메소드 호출

	}
}

▼ Test124 (지역 클래스)

class InnerOuterTest
{
	static int a = 10;
	int b = 20;

	class InnerNested
	{
		int c = 30;

		void write()
		{
			System.out.println("inner 의 write()...");
			System.out.println("a : " + a);
			System.out.println("b : " + b);
			System.out.println("c : " + c);
		}
	}

	void write()
	{
		System.out.println("outer 의 write()...");
		
		// InnerNested 클래스 기반 인스턴스 생성(→ inner)
		InnerNested ob1 = new InnerNested();
		ob1.write();					//-- inner의 write() 메소드 호출
	}
}


// main() 메소드를 포함하고 있는 다른 클래스
public class Test124
{
	public static void main(String[] args)
	{
		// InnerOuterTest 클래스 기반 인스턴스 생성(→ outer)
		InnerOuterTest ob2 = new InnerOuterTest();
		ob2.write();					//-- outer 의 write() 메소드 호출
		//--==>> outer 의 write()...
		//		 inner 의 write()...
		// 		 a : 10
		//		 b : 20
		//		 c : 30

		// InnerNested 클래스 기반 인스턴스 생성(→ inner)
		//InnerNested ob3 = new InnerNested();
		//--==>> 에러 발생(컴파일 에러)

		// check~!!! → Test122.java 파일과 비교~!!!
		// InnerNested 클래스 기반 인스턴스 생성(→ inner)
		//InnerOuterTest.InnerNested ob4 = new InnerOuterTest.InnerNested();
		//--==>> 에러 발생(컴파일 에러)

		// ※ 중첩 내부 클래스(static 중첩 클래스)와는 달리
		//	  외부 클래스의 인스턴스(객체)를 사용하지 않고
		//	  단독으로 내부 클래스의 인스턴스를 생성하는 것은 불가능하다.
		//	  → 단, 외부 클래스의 객.체. 를 사용하면
		//		 내부 클래스의 객체를 생성하는 것이 가능하다.

		// check~!!! → Test122.java 파일과 비교~!!!
		
		InnerOuterTest.InnerNested ob5 = ob2.new InnerNested();		
		ob5.write();
		//--==>> inner 의 write()...
		//		 a : 10
		//		 b : 20
		//		 c : 30

		// check~!!! → Test122.java 파일과 비교~!!!
		InnerOuterTest.InnerNested ob6 = new InnerOuterTest().new InnerNested();
		ob6,write();

		// outer클래스명.inner클래스명 참조변수명 = new outer생성자().new inner생성자();

		//cf) static → 중첩 내부 클래스
		// outer클래스명.inner클래스명 참조변수명 = new outer클래스명.inner생성자();
	}
}

▼ Test125 (익명 클래스)