[java] 인터페이스 상속, 중첩 클래스, 중첩 인터페이스
이전 내용
[java] instanceof, 인터페이스, 구현 클래스
이전 내용 [java] 추상 클래스, 추상 메소드이전 내용 [java] 클래스의 타입 변환, 다형성이전 내용 [java] 접근 제한자, 클래스 상속이전 내용 [java] 정적 멤버와 Static, 싱글톤이전 내용 [java] java
puppy-foot-it.tistory.com
인터페이스 상속
인터페이스도 다른 인터페이스를 상속할 수 있으며, 클래스와는 달리 다중 상속을 허용한다. 다중 인터페이스 상속은 자바에서 여러 개의 인터페이스를 동시에 상속받는 것을 의미하며, 이는 클래스가 다중 상속을 지원하지 않는 자바에서 인터페이스를 활용하여 유사한 효과를 내는 방법이다.
다중 인터페이스 상속을 통해 하나의 인터페이스가 여러 가지 서로 다른 기능을 결합할 수 있다.
public interface 하위인터페이스 extends 상위인터페이스1, 상위인터페이스2 {...}
하위 인터페이스를 구현하는 클래스는 하위 인터페이스의 메소드 뿐만 아니라 상위 인터페이스의 모든 추상 메소드에 대한 실체 메소드를 가지고 있어야 한다. 그렇기 때문에 구현 클래스로부터 객체를 생성한 후에 하위 및 상위 인터페이스 타입으로 변환이 가능하다.
하위인터페이스 변수 = new 구현클래스(...);
상위인터페이스1 변수 = new 구현클래스(...);
상위인터페이스2 변수 = new 구현클래스(...);인터페이스 상속 예시
[두 개의 인터페이스 정의]
// 기본 인터페이스 1
interface Animal {
void sound();
}
// 기본 인터페이스 2
interface Pet {
void play();
}
[다중 인터페이스를 상속받는 인터페이스]
// 다중 인터페이스 상속
interface Dog extends Animal, Pet {
void fetch(); // 새로운 메서드 추가
}
[인터페이스 구현]
다중 인터페이스를 상속받는 인터페이스를 구현하는 클래스는 모든 인터페이스의 메서드를 구현해야 한다.
class MyDog implements Dog {
public void sound() {
System.out.println("멍멍!");
}
public void play() {
System.out.println("강아지와 함께 놀기!");
}
public void fetch() {
System.out.println("공을 물어오기!");
}
}
[인터페이스 기능 사용]
public class Main {
public static void main(String[] args) {
MyDog dog = new MyDog();
dog.sound(); // "멍멍!"
dog.play(); // "강아지와 함께 놀기!"
dog.fetch(); // "공을 물어오기!"
}
}중첩 클래스,
중첩 인터페이스
◆ 중첩 클래스(nested class): 클래스 내부에 선언한 클래스.
중첩 클래스 사용 시 두 클래스의 멤버들을 서로 쉽게 접근할 수 있고, 외부에는 불필요한 관계 클래스를 감춤으로써 코드의 복잡성을 줄일 수 있다는 장점이 있다.
class ClassName {
class NestedClassName {
}
}
◆ 중첩 인터페이스(nested interface): 클래스 내부에 선언된 인터페이스.
인터페이스를 클래스 내부에 선언하는 이유는 해당 클래스와 긴밀한 관계를 맺는 구현 클래스를 만들기 위함이다.
class ClassName {
interface NestedInterfaceName {
}
}중첩 클래스 분류
중첩 클래스는 클래스 내부에 선언되는 위치에 따라 두 가지로 분류된다.
◆ 멤버 클래스: 클래스의 멤버로서 선언되는 중첩 클래스
클래스나 객체가 사용 중이라면 언제든지 재사용 가능 ▶ 인스턴스 멤버 클래스, 정적 멤버 클래스
◆ 로컬 클래스: 생성자 또는 메소드 내부에서 선언되는 중첩 클래스
메소드를 실행할 때만 사용되고 메소드가 종료되면 없어짐 ▶ 로컬 클래스는 접근 제한자(public, private) 및 static을 붙일 수 없음.
| 선언 위치에 따른 분류 | 선언 위치 | 설명 | |
| 멤버 클래스 | 인스턴스 멤버 클래스 |
class A { class B {...} } |
A 객체를 생성해야만 사용할 수 있는 B 클래스 |
| 정적 멤버 클래스 |
class A { static class B {...} } |
A 클래스로 바로 접근할 수 있는 B 클래스 | |
| 로컬 클래스 | class A { void method() { class B {...} } } |
method()가 실행할 때만 사용할 수 있는 B 클래스 | |
[멤버 클래스]
◆ 인스턴스 멤버 클래스: static 키워드 없이 중첩 선언된 클래스
인스턴스 필드와 메소드만 선언이 가능하고 정적 필드와 메소드는 선언할 수 없다.
◆ 정적 멤버 클래스: static 키워드로 선언된 클래스
모든 종류의 필드와 메소드 선언 가능
[로컬 클래스]
로컬 클래스 내부에는 인스턴스 필드와 메소드만 선언할 수 있고 정적 필드와 메소드는 선언할 수 없다.
중첩 클래스의 접근 제한
멤버 클래스 내부에서 바깥 클래스의 필드와 메소드에 접근할 때는 제한이 따른다. 또한 메소드의 매개 변수나 로컬 변수를 로컬 클래스에서 사용할 때도 제한이 따른다.
- 인스턴스 멤버 클래스: 외부 클래스의 모든 멤버에 접근 가능.
- 정적 멤버 클래스: 외부 클래스의 정적 멤버에만 접근 가능.
- 로컬 클래스: 메서드의 지역 변수와 외부 클래스의 인스턴스 변수에 접근 가능.
◆ 중첩 클래스에서 바깥 클래스 참조 얻기
클래스 내부에서 this는 객체 자신의 참조인데, 중첩 클래스에서 this 키워드를 사용하면 바깥 클래스의 객체 참조가 아니라, 중첩 클래스의 객체 참조가 된다. 따라서 중첩 클래스 내부에서 'this.필드, this.메소드()'로 호출하면 중첩 클래스의 필드와 메소드가 사용된다.
바깥클래스.this.필드
바깥클래스.this.메소드();
// 바깥 클래스
public class A {
A() {
System.out.println("A 객체가 생성됨");}
// 인스턴스 멤버 클래스
class B {
B() {System.out.println("B 객체가 생성됨");}
int field1;
// static int field2;
void method1() {}
// static void method2() {}
}
// 정적 멤버 클래스
static class C {
C() {System.out.println("C 객체가 생성됨");}
int field1;
static int field2;
void method1() {}
static void method2() {
}
}
void method() {
// 로컬 클래스
class D {
D() {System.out.println("D 객체가 생성됨");}
int field1;
// static int field2;
void method1() {}
// static void method2() {}
}
D d = new D();
d.field1 = 3;
d.method1();
}
}1. 바깥 클래스 - A: A는 바깥 클래스(외부 클래스)다. 이 클래스가 객체로 생성될 때, 생성자에서 "A 객체가 생성됨"이라는 메시지를 출력한다.
2. 인스턴스 멤버 클래스 - B: 클래스 A 내부에 정의된 클래스 B.
B의 객체를 생성하려면 먼저 A의 객체를 생성해야 한다.
인스턴스 멤버 클래스인 B는 외부 클래스인 A의 멤버(변수, 메서드)에 접근할 수 있다.
3. 정적 멤버 클래스 - C: 클래스 A 내에 정의된 정적 클래스 C.
C의 객체는 외부 클래스인 A의 객체 없이 생성할 수 있다.
정적 멤버 클래스인 C는 외부 클래스의 인스턴스 변수에는 접근할 수 없지만, 정적 멤버(변수, 메서드)에는 접근할 수 있다.
4. 로컬 클래스 - D: 클래스 A의 메서드 method 내부에 정의된 클래스 D.
로컬 클래스 D는 method 메서드가 호출될 때만 존재한다. 메서드가 실행될 때마다 새로운 D 객체가 생성된다.
D는 메서드의 지역 변수에 접근할 수 있지만, 정적 멤버에는 접근할 수 없다.
public class Main {
public static void main(String[] args) {
A a = new A();
// 인스턴스 멤버 클래스 객체 생성
A.B b = a.new B();
b.field1 = 3;
b.method1();
// 정적 멤버 클래스 객체 생성
A.C c = new A.C();
c.field1 = 3;
c.method1();
A.C.field2 = 3;
A.C.method2();
// 로컬 클래스 객체 생성을 위한 메소드 호출
a.method();
}
}
중첩 인터페이스
중첩 인터페이스는 인스턴스 멤버 인터페이스와 정적 멤버 인터페이스 모두 가능하다. 인스턴스 멤버 인터페이스는 바깥 클래스의 객체가 있어야 사용 가능하며, 정적 멤버 인터페이스는 바깥 클래스의 객체 없이 바깥 클래스만으로 바로 접근할 수 있다.
중첩 인터페이스는 UI 프로그래밍에서 이벤트를 처리할 목적으로 많이 활용된다.
만약, Button을 클릭했을 때 이벤트를 처리하는 객체를 받고 싶은데, 아무 객체나 받는 게 아닌 Button 내부에 선언된 중첩 인터페이스를 구현한 객체만 받아야 한다고 가정하면 아래와 같이 사용할 수 있다.
[Button 클래스 선언]
중첩 인터페이스(OnClickListener) 타입으로 필드(listener)를 선언하고, Setter 메소드(setOnClickListener())로 구현 객체를 받아 필드를 대입한다. 버튼 이벤트가 발생했을 때 즉, touch() 메소드가 실행되면 인터페이스를 통해 구현 객체의 메소드를 호출(listener.onClick()) 한다.
public class Button {
OnClickListener listener; // 인터페이스 타입 필드
void setOnClickListener(OnClickListener listener) {
this.listener = listener;
}
void touch() {
listener.onClick(); // 구현 객체의 onClick() 메소드 호출
}
static interface OnClickListener {
void onClick(); // 중첩 인터페이스
}
}
[중첩 인터페이스인 OnClickListener를 구현한 2개의 클래스]
public class CallListener implements Button.OnClickListener {
@Override
public void onClick() {
System.out.println("전화를 겁니다.");
}
}public class MessageListener implements Button.OnClickListener {
@Override
public void onClick() {
System.out.println("메시지를 보냅니다.");
}
}
[버튼을 클릭했을 때 이벤트 처리 클래스]
어떤 구현 객체를 생성해서 Button 객체의 setOnClickListener() 메소드로 세팅하느냐에 따라 Button의 touch() 메소드의 실행결과가 달라진다.
public class ButtonExample {
public static void main(String[] args) {
Button btn = new Button();
btn.setOnClickListener(new CallListener());
btn.touch();
btn.setOnClickListener(new MessageListener());
btn.touch();
}
}
예제1
Q. 동물 소리 내기 시스템
1. 인터페이스: AnimalSound
- 메서드: makeSound() ▶ 동물이 소리를 내는 동작 정의 (반환값 없음)
2. 클래스: Animal
- 속성: name(문자열, private), age(정수, private)
- 생성자: 이름과 나이를 초기화
- getter/setter: 캡슐화를 위해 속성에 접근 및 수정 가능
- 기본 makeSound() 메서드 구현 (예: "동물이 소리를 냅니다.")
3. 클래스: Dog와 Cat
- Animal을 상속받고, AnimalSound 인터페이스 구현
- makeSound() 메서드를 오버라이딩하여 각각 "멍멍"과 "야옹" 출력
4. 메인 클래스: AnimalTest
- main 메서드에서
▶ Dog와 Cat 객체를 생성
▶ 각 동물의 이름, 나이, 소리를 출력 (getter 사용)
[AnimalSound 인터페이스]
public interface AnimalSound {
void makeSound();
}
[Animal 클래스]
public class Animal {
// 필드
private String name;
private int age;
AnimalSound makeSound;
// 생성자
Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
void setOnAnimalSound(AnimalSound makeSound) {
this.makeSound = makeSound;
System.out.println("동물이 소리를 냅니다.");
}
}
[Dog 클래스] - AnimalSound 인터페이스 구현, Animal 클래스 상속
public class Dog extends Animal implements AnimalSound {
public Dog(String name, int age) {
super(name, age);
}
@Override
public void makeSound() {
System.out.println("멍멍");
}
}
[Cat 클래스] - AnimalSound 인터페이스 구현, Animal 클래스 상속
public class Cat extends Animal implements AnimalSound {
public Cat(String name, int age) {
super(name, age);
}
@Override
public void makeSound() {
System.out.println("야옹");
}
}
[AnimalTest 클래스]
public class AnimalTest {
public static void main(String[] args) {
Dog dog = new Dog("강아지", 3);
Cat cat = new Cat("고양이", 2);
String dogName = dog.getName();
String catName = cat.getName();
System.out.println("이름: " + dogName + ", 나이: " + dog.getAge());
System.out.print(dogName + "가 소리를 냅니다.");
dog.makeSound();
System.out.println();
System.out.println("이름: " + catName + ", 나이: " + cat.getAge());
System.out.print(catName + "가 소리를 냅니다.");
cat.makeSound();
}
}
예제2
Q. 내부 클래스 활용
다음과 같은 테스트 프로그램과 실행 결과가 있다. 호텔의 객실 예약과 예약 현황을 나타낼 수 있도록 Hotel 클래스를 작성하라.
호텔에는 10개의 객실이 있으며, 객실 번호는 1~10번까지 이다.
객실 번호와 이름으로 객실을 예약하는 add() 메서드,
현재 예약된 객실 번호와 고객 이름을 보여 주는 show() 메서드가 필요하다.
[조건] 호텔에는 다수의 객실이 있지만, 객실은 호텔 내부에서만 사용한다.
따라서 객실을 위한 Room 클래스는 Hotel 클래스의 중첩 클래스로 작성하면 편리하다.
[매인 클래스: HotelTest]
public class HotelTest {
public static void main(String[] args) {
Hotel hotel = new Hotel();
hotel.add(5, "호돌이");
hotel.add(7, "길동이");
hotel.show();
}
}[출력의 예]
5번 방을 호돌이가 예약했습니다.
7번 방을 길동이가 예약했습니다.
[Hotel 클래스와 중첩 클래스 Room]
public class Hotel {
public class Room {
private int roomNums;
private String guestName;
// 생성자
Room(int roomNums) {
this.roomNums = roomNums; // 객실 번호 저장
this.guestName = null; // 예약된 고객 이름 저장 (미예약 시 null)
}
boolean isBooked() { // 객실 예약 여부 확인
return guestName != null; // guestName이 null이 아닐 경우 예약된 것으로 판단
}
}
// Hotel 필드
private Room[] rooms; // 객실을 배열 형태로 관리
// 생성자
public Hotel() {
rooms = new Room[10]; // 10개의 객실을 생성하여 초기화
for (int i = 0; i < rooms.length; i++) {
rooms[i] = new Room(i + 1);
}
}
public void add(int roomNums, String name) {
if (roomNums < 1 || roomNums > 10) { // 객실 번호가 1과 10 사이인지 확인
System.out.println("존재하지 않는 객실입니다.");
}
Room room = rooms[roomNums - 1];
if (room.isBooked()) { // 이미 에약된 객실인지 확인
System.out.println("이미 예약된 객실입니다.");
} else {
room.guestName = name; // 예약이 가능할 경우 고객 이름 저장
}
}
public void show() {
for (Room room : rooms) {
if (room.isBooked()) { // 예약된 객실인 경우에만 출력
System.out.println(room.roomNums + "번 방을 " + room.guestName + "가 예약했습니다.");
}
}
}
}
[참고]
혼자 공부하는 자바
다음 내용
[java] 예외 (클래스, 처리), 다중 catch, 예외 떠넘기기, String args[]
이전 내용 [java] 인터페이스 상속, 중첩 클래스, 중첩 인터페이스이전 내용 [java] instanceof, 인터페이스, 구현 클래스이전 내용 [java] 추상 클래스, 추상 메소드이전 내용 [java] 클래스의 타입 변
puppy-foot-it.tistory.com