JAVA 자바 중첩클래스, comparator 인터페이스

🎯 자바 중첩클래스와 comparator 인터페이스를 활용한 배열정렬을 알아본다.

 

 

---

🔖 목차

중첩클래스

익명클래스

comparator 정렬 인터페이스

---

 

 

중첩클래스

public class Outer{

	class Inner{

	}//end Inner

}//end Outer

클래스 안에 또 다른 클래스를 가진 형태다. A라는 클래스가 B 클래스에서만 사용된다면, 독립적인 클래스로 작성하기보다 B클래스의 중첩형태로 작성하는 게 관리하기 쉬워진다.

중첩된 이너클래스는 아우터 클래스의 멤버(변수, 메소드)를 자신의 것처럼 사용할 수 있다. Outer 멤버의 접근지정자가 private이라도 접근할 수 있다.

이너클래스 안에선 static 변수를 사용할 수 없다. static 선언은 변수가 아닌 이너 클래스에만 지정할 수 있다. 이너클래스는 아우터 클래스를 통해서만 접근할 수 있지만 스태틱 이너 클래스는 직접 접근 가능하다.

중첩클래스는 정의되는 위치에 따라서 4가지 형태로 나뉜다.

 

 

member Inner 클래스

Outer 클래스의 멤버처럼 정의된 클래스. 멤버와 같이 객체생성 후 사용할 수 있다. 반드시 Outer 클래스의 객체를 먼저 생성해야 한다.

public class Outer {
	// 멤버변수
	public int n = 10;
	protected int n2 = 20;
	int n3 = 30;
	private int n4 = 40;
	static int n5 = 50;
	// 멤버 메서드
	public void x() {}
    
	// 멤버 inner클래스
	class Inner {
		int k = 10;
		static final int NUM = 20; // 상수 가능
		// static int k2 =20; //static변수 사용 불가

		public void info() {
			System.out.println(n);
			System.out.println(n2);
			System.out.println(n3);
			System.out.println(n4);
			System.out.println(n5);
			System.out.println(k);
			System.out.println(NUM);
		}

	}// end Inner
	// 1. Outer에서 Inner생성
	public void innerCreate() {
		Inner i = new Inner();
		i.info();
	}
}

Inner 클래스가 통째로 Outer 클래스의 멤버 자리에 위치해있다. Outer의 멤버변수엔 다양한 접근지정자가 붙어있지만 Inner클래스는 제한 없이 Outer의 모든 멤버를 자기것처럼 사용할 수 있다. Outer의 innerCreate() 메소드를 보면 Outer클래스에서 이너클래스에 접근할 땐 직접 이너클래스의 객체를 생성하고 이너클래스의 info함수에 접근하는 것을 볼 수 있다.

public class TestOuter {
	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.innerCreate();
		//2. Outer밖에서 Inner 생성==>반드시 Outer부터생성한다.
		Outer outer2 = new Outer(); //바깥에 있는 클래스 생성
		outer2.n=1; 
		Outer.Inner inner = outer2.new Inner();
		inner.info();
	}
}

외부클래스의 main 함수 안에서 이너클래스를 사용하기 위해선 먼저 Outer 클래스의 객체생성을 해야한다. 그 다음 Outer.Inner 타입으로 이너클래스의 객체를 생성하고 이너클래스의 info함수를 호출한다.

 

 

local Inner 클래스

Outer클래스의 특정 메소드 안에서 로컬변수처럼 정의된 클래스를 의미한다. 로컬변수 자리에 이너클래스가 선언되었기 때문에 메소드가 종료될 때 이너클래스도 사라진다. 

class Outer2 {
	int a = 10;
	private int b = 20;
	static int c = 30;
	
	public void info() {
		int size = 100;
			class Inner {
				int d = 40;
				public void print() {
					System.out.println(a);
					System.out.println(b);
					System.out.println(c);
					System.out.println(d);
					System.out.println(size);
				}
			}
			Inner inner = new Inner();
			inner.print();
	}
}
public class Ex07_5 {
	public static void main(String[] args) {
		Outer2 outer = new Outer2();
		outer.info();
	}
}

Outer클래스의 info()메소드 안에서 이너클래스의 객체를 생성하고 print() 메소드를 호출한다. 이 print 메소드는 info()메소드가 호출되어야 실행된다.

 

 

static Inner 클래스

static 키워드를 사용해 이너클래스를 정의한 형태다. static 이너클래스는 static 변수를 사용할 수 있고, Outer 클래스를 생성할 필요없이 이너클래스에 직접 접근할 수 있다. 하지만 이 경우 Outer클래스의 멤버에 접근할 수 없기 때문에 static 변수가 필요한 상황에서만 사용한다.

public class Outer3 {
	// 멤버변수
	public int n = 10;
	protected int n2 = 20;
	int n3 = 30;
	private int n4 = 40;
	static int n5 = 50;

	// 멤버 메서드
	public void x() {}

	static class Inner {
		int k = 10;
		static final int NUM = 20; // 상수 가능
		static int k2 = 20;

		public void info() {
//			System.out.println(n);
//			System.out.println(n2);
//			System.out.println(n3);
//			System.out.println(n4);  
			System.out.println(n5);
			System.out.println(k);
			System.out.println(k2);
			System.out.println(NUM);
		}
	}// end Inner
}// end class

static으로 선언된 이너클래스는 static변수를 제외한 Outer의 멤버를 사용할 수 없다.

 

 

anonymous Inner 클래스(익명클래스)

이름없는 이너클래스이며, 일반적으로 인터페이스나 추상클래스를 구현하는 용도로 사용된다. 원래 인터페이스는 객체생성을 할 수 없으며 implements로 연결한 하위클래스를 통해 추상메소드를 구현한다. 반면에 익명클래스는 인터페이스를 구현하는 하위클래스 기능을 하며, 하위클래스 없이 바로 new 키워드로 자신을 생성하고 블록을 열어 추상메소드를 구현한다. 맨 마지막에 반드시 세미콜론을 붙인다.

인터페이스명 변수명  = new 인터페이스명() {추상메소드 오버라이딩};

public interface Flyer {
	public abstract void takeOff();
}

takeOff() 추상메소드를 가진 Flyer 인터페이스를 만든다.

public class Bird implements Flyer {
	@Override
	public void takeOff() {
		System.out.println("Bird.takeOff");
	}
}

인터페이스를 구현하는 Bird 클래스를 만들고 추상메소드를 오버라이딩해서 구현한다.

public class TestOuter4 {
	public static void main(String[] args) {
		
		//1. 일반적인 방법==> 이름있는 클래스로 처리
		Flyer b = new Bird();
		b.takeOff();
		
		//2. 익명클래스
		Flyer b2 = new Flyer(){
			@Override
			public void takeOff() {
				System.out.println("SuperMan.takeOff");
			}
		}; //세미콜론
		b2.takeOff();
		
		Flyer b3 = new Flyer() {
			@Override
			public void takeOff() {
				System.out.println("Airplane.takeOff");
			}
		};
		b3.takeOff();
	}//end main
}

---------
Bird.takeOff
SuperMan.takeOff
Airplane.takeOff

인터페이스는 객체생성이 불가능하지만 Flyer b로 다형성을 이용한 데이터 형으로 사용할 수 있다. 인터페이스를 구현한 Bird의 객체를 생성하고 메소드를 호출하는 것이 일반적인 방법이다. 익명클래스는 클래스 이름이 없으며 인터페이스를 객체생성하듯 작성하고 블록을 열어 직접 메소드를 구현하고 세미콜론으로 마무리한다. 

 

 

 

comparator 인터페이스를 활용한 배열 정렬

배열에 저장된 클래스의 특정 변수값으로 배열을 정렬하고 싶을 때 자바에서 제공하는 API인 java.util.Comparator 인터페이스를 사용할 수 있다.

import java.util.Arrays;
import java.util.Comparator;

class Person {
	String name;
	int age;
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return name + " " + age;
	}
}//end Person

class PersonComp implements Comparator<Person>{

	@Override
	public int compare(Person o1, Person o2) {
		
		int result = 1;
		if(o1.age >= o2.age) result = -1;
		return result;
	}
}

public class Ex07_8 {
	public static void main(String[] args) {
		Person p = new Person("홍길동", 20);
		Person p2 = new Person("이순신", 44);
		Person p3 = new Person("유관순", 18);
		Person p4 = new Person("강감찬", 66);
		Person [] ps = {p, p2, p3, p4};
		//age로 정렬
		Arrays.sort(ps, new PersonComp());
		for(Person person : ps) {
			System.out.println(person);
		}
	}
}

이름과 나이 정보를 저장한 Person 클래스를 배열에 넣고 나이를 기준으로 배열을 정렬한다. comparator인터페이스를 사용하기 위한 일반클래스 PersonComp를 만들고 compare 메소드를 오버라이딩한다. result가 음수값을 리턴하면 내림차순으로 정렬하며, 양수값이나 0을 리턴하면 오름차순으로 정렬한다.  메인함수 안에서 Arrays.sort()메소드를 실행해 배열을 정렬하고 반환할 수 있다. 

 

 

 

😜 NEXT : 자바 핵심클래스 공부하기