내부 클래스와 내부 인터페이스에 대하여 내부 클래스의 선언 방법과 이용 방법 내부 인터페이스의 선언 방법과 이용 방법

Slides:



Advertisements
Similar presentations
Transaction ㅇ Transaction 을 직접 구현하려면, 까다로운 설계와 복잡한 코드를 필요로 하고 수정에 공수가 많이 들게 된다. ㅇ 스프링에서 제공하는 Transaction Manager 를 사용하여 쉽고 간편하게 어려운 트랜잭션을 해결할 수 있다. xml.
Advertisements

어서와 Java는 처음이지! 제3장선택과 반복.
10. 예외 처리.
컴퓨터 응용 및 실습 Part1. OOP&Java Programming data type Review
객체지향 프로그래밍.
7장 배열 ②.
Java Seminar Chapter3.
Java Presentation 중간 시험2 풀이
자바란 무엇인가? JDK의 다운로드 및 설치 방법 Hello, Java 프로그램의 작성 자바 프로그램의 작동 원리
5 익셉션 처리.
16강. 자바 빈 빈 이란? 빈 만들기 빈 관련 액션 태그(useBean, getProperty, setProperty)
2주 실습강의 Java의 기본문법(1) 인공지능연구실.
Chapter 02 자바 기본구조 자바 프로그래밍의 기초적인 문법을 소개
명품 JAVA Programming 제 7 장 제네릭과 컬렉션.
명품 JAVA Essential.
직렬화와 역직렬화에 대하여 직렬화 가능 클래스의 선언 방법
[ 단원 08 ] 예외처리와 스레드.
명품 JAVA Programming.
Java RMI (Remote Method Invocation)
Java RMI (Remote Method Invocation)
명품 JAVA Essential.
명품 JAVA Programming 제 4 장 클래스와 객체.
Power Java 제4장 자바 프로그래밍 기초.
[INA470] Java Programming Youn-Hee Han
10장 객체-지향 프로그래밍 II ©창병모.
JAVA 프로그래밍 6장 객체지향프로그래밍의 핵심.
객체지향 언어와 클래스, 객체 ㅎㅎ 개요 클래스의 선언, 객체의 생성 및 속성 참조 방식 멤버 변수 메소드 한빛미디어(주)
자바 5.0 프로그래밍.
01. 직렬화와 역직렬화에 대하여 객체의 직렬화 직렬화와 역직렬화
명품 JAVA Essential.
명품 Java Programming.
10장 다중 스레드 10.1 스레드 개요 10.2 Thread 클래스 10.3 스레드 생성
2장 자바환경과 자바 프로그램 2.1 자바 개발 환경 2.2 자바 통합환경 2.3 자바 응용 프로그램과 애플릿 프로그램
2010학년도 2학기 객체지향의 이해.
김 정 석 Web Programming 김 정 석
패키지와 접근 제어 패키지에 대하여 접근 제어에 대하여.
7장 배열 ①.
상속과 인터페이스 클래스의 상속에 대하여 인터페이스에 대하여.
12 검색.
2009학년도 1학기 상지대학교 컴퓨터정보공학부 고 광 만
Chapter6 : JVM과 메모리 6.1 JVM의 구조와 메모리 모델 6.2 프로그램 실행과 메모리 6.3 객체생성과 메모리
제2장 데이터 및 수식.
어서와 Java는 처음이지! 제9장 인터페이스, 패키지.
03. 안드로이드를 위한 Java 문법 제목. 03. 안드로이드를 위한 Java 문법 제목.
WAP Java Seminar
Ch.1 Iterator Pattern <<interface>> Aggregate +iterator
C# 09장. 상속성.
제 2장 어휘구조와 자료형 토 큰 리 터 럴 주 석 자 료 형 배 열 형.
[CPA340] Algorithms and Practice Youn-Hee Han
SpringFramework 중간고사 요약 REST by SpringFramework.
Java Chapter 4 ~ 주차.
컴퓨터공학실습(I) 3주 인공지능연구실.
Java IT응용시스템공학과 김형진 교수 5장. 객체지향 개념 public class SumTest {
Chapter3 : 객체지향의 개념 3.1 객체지향(object-oriented)과
Chap02 객체 지향 개념 2.1 객체지향(object-oriented)과 절차지향(procedural-oriented)
JA A V W. 04.
자바 5.0 프로그래밍.
Chapter 02. 소프트웨어와 자료구조.
Java 3장. 자바의 기본 구조 I : 변수, 자료형, 연산자 public class SumTest {
[ 단원 06 ] 상속과 다형성.
JVM의 구조와 메모리 모델 JVM의 내부 구조 클래스 파일 클래스 로더 메소드(method) 영역 힙(heap) 영역
Java RMI (Remote Method Invocation)
6장 클래스(상속).
컴퓨터 프로그래밍: 실습 1 제 1장 . 서론.
Java 5장. 객체지향 개념 public class SumTest {
캡슐화 (Encapsulation) 두원공과대학 소프트웨어개발과 이 원 주.
C# 09장. 클래스와 객체.
Java의 정석 제 7 장 객체지향개념 II-3 Java 정석 남궁성 강의
1. 객체-지향 프로그래밍.
Chapter8 : 인터페이스와 패키지 8.1 인터페이스 개요와 인터페이스 정의 8.2 인터페이스의 사용
Presentation transcript:

내부 클래스와 내부 인터페이스에 대하여 내부 클래스의 선언 방법과 이용 방법 내부 인터페이스의 선언 방법과 이용 방법 내부 클래스와 내부 인터페이스 내부 클래스와 내부 인터페이스에 대하여 내부 클래스의 선언 방법과 이용 방법 내부 인터페이스의 선언 방법과 이용 방법

01. 내부 클래스 내부 클래스와 내부 인터페이스 내부 클래스 (nested class, 중첩 클래스) • 내부 클래스의 예 - 다음 성적표를 클래스로 표현하는 경우를 가정합시다 이렇게 표현할 수 있습니다. 하지만 이 클래스의 존재 이유가 오로지 ExamResult 클래스를 위한 것이라면?

01. 내부 클래스와 내부 인터페이스 내부 클래스와 내부 인터페이스 내부 클래스란? • 내부 클래스의 예 내부 클래스(nested class)로 선언하는 것이 좋습니다.

ExamResultTest.java 내부 클래스와 내부 인터페이스 내부 클래스 class ExamResult { String name; ItemResult[] result; class ItemResult { String subject; int points; public ItemResult(String sub, int pts) { subject = sub; points = pts; } public ExamResult() result = new ItemResult[10]; 내부 클래스

내부 클래스와 내부 인터페이스 class ExamResultTest { public static void main( String[] args ) ExamResult student1 = new ExamResult(); student1.name = "Kim"; student1.result[0] = student1.new ItemResult("Enligsh", 70); student1.result[1] = student1.new ItemResult("Math", 50); printStudent( student1 ); } public static void printStudent( ExamResult student ) ExamResult.ItemResult item; System.out.printf("----- Name: %s\n", student.name ); item = student.result[0]; System.out.printf("%s: %d\n", item.subject, item.points); item = student.result[1]; System.out.println("-------------" );

01. 내부 클래스와 내부 인터페이스 내부 클래스와 내부 인터페이스 내부 vs. 외부 • 외부 클래스(enclosing class, 둘러싼 클래스) • 내부 클래스(nested class)

내부 클래스(nested class)의 종류 내부 클래스와 내부 인터페이스 내부 클래스(nested class)의 종류 정적 내부 클래스 (static nested class) 비정적 내부 클래스 (non-static nested class = inner class) 로컬 이너 클래스 (local inner class) 익명 클래스 (anonymous inner class)

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 내부 클래스의 종류 • 정적 내부 클래스 (static nested class)

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 내부 클래스의 종류 • 이너 클래스 (inner class = non-static nested class)

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 내부 클래스의 종류 • 로컬 이너 클래스 (local inner class)

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 이너 클래스 • 다음과 같은 장바구니 데이터를 클래스로 표현하는 경우를 가정해 봅시다. 이런 데이터들은 이너 클래스로 선언하는 것이 좋습니다.

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 이너 클래스 [예제] 장바구니 클래스와 상품 항목 클래스(이너 클래스) import java.util.ArrayList; class Cart { ArrayList<Item> list = new ArrayList<Item>(); void addItem( String name, int num, int unitPrice ) list.add( new Item(name, num, unitPrice) ); } void removeItem( int index ) list.remove( index ); 이너 클래스의 생성자 호출

내부 클래스와 내부 인터페이스 이너 클래스 타입의 변수 선언 이너 클래스의 메소드 호출 이너 클래스의 필드 사용 int getNumOfItems() { return list.size(); } Item getItem( int index ) return list.get( index ); int getTotalPrice() int total = 0; for( Item item : list ) total += item.getPrice(); return total; void changeItemNumber( int index, int num ) Item item = list.get( index ); item.num = num; 이너 클래스 타입의 변수 선언 이너 클래스의 메소드 호출 이너 클래스의 필드 사용

내부 클래스와 내부 인터페이스 $ javac Cart.java $ ls class Item { String name; int num; int unitPrice; Item( String name, int num, int unitPrice ) this.name = name; this.num = num; this.unitPrice = unitPrice; } int getPrice() return num * unitPrice; 이너 클래스 $ javac Cart.java $ ls Cart$Item.class Cart.class Cart.java

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 이너 클래스의 사용 class InnerClassExample1 { public static void main( String[] args ) Cart cart = new Cart(); cart.addItem( "chocolate", 3, 1000 ); cart.addItem( "cake", 1, 25000 ); cart.addItem( "champagne", 1, 7000 ); printCart( cart ); }

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 이너 클래스의 사용 static void printCart( Cart cart ) { int numOfItems = cart.getNumOfItems(); System.out.println( "Name Num unitPrice amount" ); System.out.println( "-------------------------------------" ); for( int i = 0; i < numOfItems; i++) Cart.Item item = cart.getItem( i ); System.out.printf( "%-9s %3d %9d %6d\n", item.name, item.num, item.unitPrice, item.getPrice() ); } System.out.printf( "Total%32d\n", cart.getTotalPrice() );

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 실행결과 $ java InnerClassExample1 Name Num unitPrice amount ------------------------------------- chocolate 3 1000 3000 cake 1 25000 25000 champagne 1 7000 7000 Total 35000 $

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 이너 클래스 • 이너 클래스의 사용 방법 1) 이너 클래스 이름 앞에 인클로징 클래스 이름을 붙여야 합니다.

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 이너 클래스 • 이너 클래스의 사용 방법 2) 필드, 메소드의 사용 방법은 일반 클래스와 마찬가지입니다.

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 이너 클래스 • 인클로징 클래스의 외부에서 이너 클래스 객체를 생성하는 방법 * 인클로징 객체가 있어야 이너 클래스 객체를 만들 수 있음 인클로징 객체 이너 클래스 객체

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 main 메쏘드 수정 class InnerClassExample1 { public static void main( String[] args ) Cart cart = new Cart(); cart.addItem( "chocolate", 3, 1000 ); cart.addItem( "cake", 1, 25000 ); cart.addItem( "champagne", 1, 7000 ); Cart.Item item = cart.new Item( "flower", 1, 5000 ); cart.list.add( item); printCart( cart ); } static void printCart( Cart cart ) ···· addItem() 메쏘드를 호출하는 대신에 이너 클래스 객체를 직접 생성하여 ArrayList에 추가

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 실행결과 $ java InnerClassExample1 Name Num unitPrice amount ------------------------------------- chocolate 3 1000 3000 cake 1 25000 25000 champagne 1 7000 7000 flower 1 5000 5000 Total 40000 $

내부 클래스와 내부 인터페이스 이너 클래스 안에서 인클로징 클래스의 구성요소 사용하기 PiggyBank.java class PiggyBank { // 돼지 저금통 클래스 private int total; Slot slot; PiggyBank() { total = 0; slot = new Slot(); } int getTotal() { return total; class Slot { // 투입구 클래스 void put(int amount) { total += amount; 인클로징 클래스의 필드를 직접 사용합니다. private 멤버도 사용할 수 있음

내부 클래스와 내부 인터페이스 이너 클래스 안에서 인클로징 클래스의 구성요소 사용하기 PiggyBankTest.java class PiggyBankTest { public static void main( String[] args ) PiggyBank bank = new PiggyBank(); bank.slot.put(100); bank.slot.put(1000); System.out.println( "amount: " + bank.getTotal() ); } $ java PiggyBankTest amount: 1100

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 정적 내부 클래스 • 정적 내부 클래스(static nested class) - 필드, 메소드와 동일 수준으로 선언된 static 키워드가 붙은 내부 클래스

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 정적 내부 클래스 [예제] 직선 클래스와 점 클래스(정적 내부 클래스) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Line { // 직선 클래스 Point point1, point2; Line(int x1, int y1, int x2, int y2) { point1 = new Point(x1, y1); point2 = new Point(x2, y2); } void move(int offsetX, int offsetY) { point1.x += offsetX; point1.y += offsetY; point2.x += offsetX; point2.y += offsetY; static class Point { // 점 클래스 int x, y; Point(int x, int y) { this.x = x; this.y = y; 정적 내부 클래스의 생성자 호출 정적 내부 클래스의 필드 사용 정적 내부 클래스

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 정적 내부 클래스 • 인클로징 클래스 외부에서 정적 내부 클래스를 사용하는 방법

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 정적 내부 클래스 [예제] 직선 클래스와 점 클래스를 사용하는 프로그램 1 2 3 4 5 6 7 8 9 10 11 class LineTest { public static void main(String args[]) { Line line = new Line(0, 0, 100, 100); line.move(10, 20); printPoint(line.point1); printPoint(line.point2); } static void printPoint(Line.Point point) { System.out.printf("(%d, %d) %n", point.x, point.y); $ java LineTest (10, 20) (110, 120)

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 정적 내부 클래스 • 인클로징 클래스 외부에서 정적 내부 클래스의 객체를 생성하는 방법

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 정적 내부 클래스 [예제] 정적 내부 클래스의 객체를 생성하는 프로그램 1 2 3 4 5 6 class LineTest2 { public static void main(String args[]) { Line.Point point = new Line.Point(100, 200); System.out.printf("(%d, %d)", point.x, point.y); } 정적 내부 클래스의 객체 생성 $ java LineTest2 (100, 200)

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 정적 내부 클래스 인클로징 클래스 객체 없이 정적 내부 클래스의 객체를 생성할 수 있다. 인클로징 클래스의 private static 멤버를 사용할 수 있다.

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 인터페이스의 정적 내부 클래스 [예제] 평면 도형 인터페이스와 위치 클래스(정적 내부 클래스) 1 2 3 4 5 6 7 8 9 10 11 interface PlaneObject { // 평면 도형 인터페이스 Location getLocation(); void setLocation(int x, int y); static class Location { // 위치 클래스 int x, y; Location(int x, int y) { this.x = x; this.y = y; } 정적 내부 클래스

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 인터페이스의 정적 내부 클래스 [예제] 평면 도형 인터페이스를 구현하는 사각형 클래스 1 2 3 4 5 6 7 8 class Rectangle implements PlaneObject { // 사각형 클래스 Location location; int width, height; Rectangle(int x, int y, int width, int height) { this.location = new Location(x, y); this.width = width; this.height = height; } PlaneObject 인터페이스로부터 상속받은 정적 내부 클래스의 생성자 호출

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 인터페이스의 정적 내부 클래스 [예제] 평면 도형 인터페이스를 구현하는 사각형 클래스 9 10 11 12 13 14 15 16 public Location getLocation() { return location; } public void setLocation(int x, int y) { location.x = x; location.y = y; 정적 내부 클래스의 필드 사용

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 인터페이스의 정적 내부 클래스 [예제] 평면 도형 인터페이스를 구현하는 사각형 클래스 1 2 3 4 5 6 7 8 9 10 11 class RectangleTest { public static void main( String[] args ) Rectangle rect = new Rectangle( 0, 0, 100, 200 ); rect.setLocation( 50, 50 ); Rectangle.Location loc = rect.getLocation(); System.out.printf( "(%d, %d)\n", loc.x, loc.y ); }

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 로컬 이너 클래스 • 로컬 이너 클래스(local inner class) 메소드 본체 안에 선언된 내부 클래스 메소드 내에서 임시로 사용하는 클래스

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 로컬 이너 클래스 [예제] 연락처 프로그램과 연락처 클래스 class ContactInfo { String name; String phone; ContactInfo( String name, String phone ) { this.name = name; this.phone = phone; } 이런 클래스들이 있다고 가정합시다. import java.util.HashMap; class ContactInfoTest { public static void main( String[] args ) { HashMap< String, ContactInfo > table = new HashMap< String, ContactInfo >(); table.put( "Kim", new ContactInfo("Kim", "02-547-0000") ); table.put( "Han", new ContactInfo("Han", "010-9574-0280") ); ContactInfo obj = table.get( "Kim" ); System.out.printf( "%s: %s\n", obj.name, obj.phone ); } 이 클래스가 오로지 왼쪽 클래스의 main 메소드 내에서만 필요하다면?

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 로컬 이너 클래스 import java.util.HashMap; class LocalClassExample { public static void main( String[] args ) { class ContactInfo { String name; String phone; ContactInfo( String name, String phone ) { this.name = name; this.phone = phone; } HashMap< String, ContactInfo > table = new HashMap< String, ContactInfo >(); table.put( "Kim", new ContactInfo("Kim", "02-547-0000") ); table.put( "Han", new ContactInfo("Han", "010-9574-0280") ); ContactInfo obj = table.get( "Kim" ); System.out.printf( "%s: %s\n", obj.name, obj.phone ); 로컬 이너 클래스

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 로컬 이너 클래스 [예제] 메시지 송신 클래스와 서브클래스들 abstract class MessageSender { String sender, receiver; MessageSender( String sender, String receiver ) { this.sender = sender; this.receiver = receiver; } abstract void send( String message );

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 로컬 이너 클래스 [예제] 메시지 송신 클래스와 서브클래스들 class EMailSender extends MessageSender { EMailSender( String sender, String receiver ) { super( sender, receiver ); } void send( String message ) { System.out.println( “Sender:" + sender ); System.out.println( “Receiver:" + receiver ); System.out.println( “Contents:" + message ); System.out.println();

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 로컬 이너 클래스 [예제] 메시지 송신 클래스와 서브클래스들 class SMSSender extends MessageSender { SMSSender( String callbackNo, String phoneNo ) { super( callbackNo, phoneNo ); } void send( String message ) { System.out.println( "Phone Number: " + receiver ); System.out.println( "Contents: " + message ); System.out.println( "callback Number: " + sender ); System.out.println();

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 로컬 이너 클래스 [예제] 메시지 송신 클래스와 서브클래스들 class SenderTest { public static void main( String[] args ) { EMailSender email = new EMailSender( "schan@naver.com", "mkpark@naver.com" ); email.send( "Hi, this is an email" ); SMSSender sms = new SMSSender( "010-000-0000", "010-111-1111" ); sms.send( "Hi, this is a SMS" ); } $ java SenderTest Sender: schan@naver.com Receiver: mkpark@naver.com Contents: Hi, this is an email Phone Number: 010-000-0000 Contents: Hi, this is a SMS callback Number: 010-111-1111

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 로컬 이너 클래스 • 다음과 같은 클래스가 추가로 필요하다면? class KatokSender extends MessageSender { KatokSender( String senderID, String receiverID ) { super( senderID, receiverID ); } void send( String message ) { System.out.println( "Sender ID: " + sender ); System.out.println( "Receiver ID: " + receiver ); System.out.println( "Contents: " + message ); System.out.println(); 그리고 이 클래스가 특정 프로그램의 특정 메소드 내에서만 필요하다면?

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 [예제] 다른 클래스를 상속 받는 로컬 이너 클래스의 예 class UsingLocalClass { public static void main( String[] args ) { class KatokSender extends MessageSender { KatokSender( String senderID, String receiverID ) { super( senderID, receiverID ); } void send( String message ) { System.out.println( "Sender ID: " + sender ); System.out.println( "Receiver ID: " + receiver ); System.out.println( "Contents: " + message ); System.out.println(); KatokSender talk = new KatokSender( "S.Han", "M.Park" ); talk.send( "This message is sent using local inner class" );

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 • 앞 프로그램은 다음과 같은 방법으로 더 간단하게 만들 수 있습니다. public static void main( String[] args ) { class KatokSender extends MessageSender { MessageSender talk = new MessageSender( “S.Han”, “M.Park” ) { void send( String message ) { System.out.println( "Sender ID: " + sender ); System.out.println( "Receiver ID: " + receiver ); System.out.println( "Contents: " + message ); System.out.println(); } }; KatokSender talk = new KatokSender( "S.Han", "M.Park" ); talk.send( "This message is sent using local inner class" ); 상위클래스 생성자 호출 상위클래스 변수 선언 클래스 본체는 그대로 이런 이너 클래스를 익명 클래스(anonymous inner class)라고 부릅니다.

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 익명 클래스 (anonymous inner class) class UsingAnonymousClass { public static void main( String[] args ) { MessageSender talk = new MessageSender( "S.Han", "M.Park" ) { void send( String message ) { System.out.println( "Sender ID: " + sender ); System.out.println( "Receiver ID: " + receiver ); System.out.println( "Contents: " + message ); System.out.println(); } }; talk.send( "This message is sent using anonymous class" ); 익명 클래스의 선언 및 객체 생성 익명 클래스 객체의 메소드 호출

02. 내부 클래스의 선언과 이용 내부 클래스와 내부 인터페이스 익명 클래스(인터페이스를 구현한 클래스) interface Player { void play(String source); void stop(); } class UsingAnonymousClass2 { public static void main(String args[]) { Player obj = new Player() { public void play(String source) { System.out.println(“Start playing: ” + source); } public void stop() { System.out.println(“Stop playing”); }; obj.play(“What_is_love.mp3"); obj.stop(); Player 인터페이스를 구현하는 익명 클래스 선언 및 객체생성 익명 클래스 객체의 메소드 호출

내부 클래스와 내부 인터페이스 03. 내부 인터페이스의 선언과 이용 내부 인터페이스의 종류 • 정적 내부 인터페이스 (1)

02. 내부 인터페이스의 선언과 이용 내부 클래스와 내부 인터페이스 내부 인터페이스의 종류 • 정적 내부 인터페이스 (2) 내부 인터페이스는 정적 내부 인터페이스 한 종류만 있습니다.

상속받은 내부 인터페이스를 구현하는 내부 클래스 내부 클래스와 내부 인터페이스 03. 내부 인터페이스의 선언과 이용 내부 인터페이스 abstract class PlayerFactory { abstract Player createPlayer(); interface Player { void play(String source); void stop(); } 내부 인터페이스 class MP3PlayerFactory extends PlayerFactory { public Player createPlayer() { return new MP3Player(); } class MP3Player implements Player { public void play(String source) { System.out.println(“Start playing: " + source); public void stop() { System.out.println(“Stop playing"); 상속받은 내부 인터페이스를 구현하는 내부 클래스

03. 내부 인터페이스의 선언과 이용 내부 클래스와 내부 인터페이스 내부 인터페이스 [예제] MP3PlayerFactory 클래스를 사용하는 프로그램 class MP3PlayerFactoryTest { public static void main( String args[] ) { MP3PlayerFactory factory = new MP3PlayerFactory(); PlayerFactory.Player player = factory.createPlayer(); player.play( “What_is_love.mp3“ ); player.stop(); }