클래스 고급 - 중첩 클래스(내부 클래스)

중첩 클래스 (내부 클래스) 란?

중첩 클래스(또는 내부 클래스)란 클래스 안에 다른 클래스가 설계되어 있는 형태로 클래스 내부에서만 사용할 보조 클래스가 필요한 경우 클래스를 중첩하여 프로그램의 구조를 보다 더 간단하고 알아보기 쉽도록 만들 수 있는 클래스이다. 이는 특정 클래스를 자신의 클래스 내부적인 용도로만 사용할 목적으로 쓰이는데 특정 클래스를 마치 자신의 멤버 변수나 메소드처럼 사용할 수 있게 한다.

 

중첩 클래스의 종류 4가지

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

 

클래스 내부에...
public static class 클래스명

내부 클래스를 감싸는 외부 클래스 {} 안에 static이 붙은 새로운 클래스를 설계하는 것으로 모든 접근제어지시자를 사용할 수 있다. static 중첩 클래스가 포함하고 있는 메소드에서는 외부 클래스의 인스턴스 변수나 인스턴스 메소드는 접근할 수 없고, 클래스 변수와 클래스 메소드만 접근할 수 있다.

 

• 프로그램 구조를 보다 더 간단하고 알아보기 쉽게 구성할 수 있다.

• static으로 선언된 내부 클래스이다.

• 중첩 클래스의 객체는 중첩 클래스를 포함하고 있는 외부 클래스의 객체와 동등하다.

• 외부 클래스의 클래스 변수와 클래스 메소드는 바로 접근하여 사용하는 것이 가능하다.

• 중첩 클래스와 중첩 클래스를 포함하고 있는 외부 클래스의 인스턴스 변수와 인스턴스 메소드는 객체를 생성하여 서로 접근하는 것이 가능하다.

• 중첩 클래스를 외부에서 단독으로 사용하는 것이 가능하다.

예제)

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

	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();
	}
}

public class Test127
{
	public static void main(String[] args)
	{
		Test ob1 = new Test();
		ob1.print();
		// --==>> write()...
		//		  a : 10
		//		  c : 30

		//StaticNested ob2 = new StaticNested();
		//--==>> 에러 발생

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

		//Test.a
		//Test.method()

		Test.StaticNested ob2 = new Test.StaticNested();
		ob2.write();
	}
}

 

 

2. 내부 클래스(inner class)

 

클래스 내부에...
public class 클래스명

 

• static 중첩 클래스와 마찬가지로 프로그램 구조를 보다 더 간단하고 알아보기 쉽도록 할 수 있다.

• 외부 클래스의 메소드에서 내부 멤버 클래스를 사용하기 위해서는 반드시 내부 멤버 클래스 객체를 생성해 주어야 한다.

• 외부 클래스의 멤버 변수와 메소드를 객체 생성 없이 바로 사용하는 것은 가능하다.

• 내부 멤버 클래스는 외부에서 단독으로 객체를 생성하여 사용할 수 없다. 즉, 내부 멤버 클래스는 외부 클래스의 인스턴스 생성이 선행되어야 한다는 것이다.

• static으로 선언된 변수 또는 메소드를 가질 수 없다.

예제)

// outer
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 ob1 = new InnerNested();
		ob1.write();	// -- inner 의 write() 메소드 호출
	}
}

public class Test129
{
	public static void main(String[] args)
	{
		InnerOuterTest ob2 = new InnerOuterTest();
		ob2.write();	// -- outer 의 write() 메소드 호출

		//InnerNested ob3 = new InnerNested();
		//--==>> 에러 발생

		//InnerOuterTest.InnerNested ob3 = new InnerOuterTest.InnerNested();
		//--==>> 에러 발생

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

		InnerOuterTest.InnerNested ob5 = ob2.new InnerNested();
		ob5.write();
		// --==>> inner 의 write()...
		//		  a : 10
		//		  b : 20
		//        c : 30

		InnerOuterTest.InnerNested ob6 = new InnerOuterTest().new InnerNested();
		ob5.write();
		// --==>> inner 의 write()...
		//		  a : 10
		//		  b : 20
		//        c : 30
	}
}

 

 

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

 

메소드 내부에...
class 클래스명 (or) static class 클래스명

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

 

예제)

class Test2
{
	static int a = 10;		// 전역변수, Test2의 멤버변수, static 변수(클래스 변수)
	int b = 20;				// 전역변수, Test2의 멤버변수, instance 변수

	void write()			// >> 첫 번째 write() 메소드
	{
		System.out.println("write()...①");
		final int c = 30;	// 지역변수, 상수화된 변수(값이 변하지 않는 수)
		int d = 40;			// 지역변수, 값이 수시로 변할 수 있는 변수
		
		// 메소드 안에 존재하는 또다른 클래스(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 는 둘 다 지역변수이지만...
		//    c 는 final 변수이기 때문에
		//    두 번째 write() 메소드에서 언제 접근하더라도
		//    고정된 값임을 보장받을 수 있다.
		//	  반면에 d 는 그 값이 수시로 변동될 수 있는 상황이므로
		//	  LocalTest 클래스의 인스턴스 생성 시점을
		//    보장받을 수 없기 때문에 d 에 접근하는 것은 피해야 하는 것이다.

		d = 10;

		LocalTest ob1 = new LocalTest();
		ob1.write();	//-- 두 번째 write() 메소드 호출

		d += 10;
	}
}

public class Test128
{
	public static void main(String[] args)
	{
		Test2 ob2 = new Test2();
		ob2.write();	//-- 첫 번째 write() 메소드 호출
	}
}

 

 

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

이름 없는 클래스

 

• 클래스 또는 인터페이스에 대한 객체를 생성하면서 바로 클래스 또는 인터페이스를 정의하는 클래스

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

• AWT나 안드로이드 이벤트 처리에서 일반적으로 사용

• 상위 클래스 메소드를 하나 정도 재정의할 필요성이 있을 때 사용

• 클래스의 객체가 필요하면 또다시 클래스를 생성해야 하는 번거로움으로 인해 익명의 클래스를 생성하여 처리할 수 있다.

new 상위 클래스의 생성자()
{
    접근제어지시자 자료형 메소드()
    {
        ...;
    }
}; <- 꼭 세미콜론을 붙여줘야 한다.

 

예제)

// package default;

// import java.lang.*; -> import java.lang.Object;

class Test3 //extends Object
{
	/*
	
	Object 클래스의 멤버들...
	...
	...
	
	public String toString();
	{
		...;
	}

	*/

	public Object getString()
	{
		//return ...;
		//       ----
		//     Object 타입

		///return new Object(){...};
		//         ---------
		//         Objedctdio



		return new Object()
		{
			@Override
			public String toString()
			{
				return "익명의 클래스...";
			}
		};		// <- 세미콜론 check~!!!
	}
}

public class Test130	// extends Object
{
	/*
		Object가 갖고있는 멤버들
		즉, Object 로 부터 상속받은 멤버들
		...
	*/


	public static void main(String[] args)
	{
		Test3 ob1 = new Test3();
		Test3 ob2 = new Test3();

		System.out.println(ob1.toString());
		// --==>> Test3@15db9742

		System.out.println(ob2.getString());
		// --==>> 익명의 클래스...

	}
}