개요 상속 및 확장 클래스 인터페이스 및 다중 상속 , 추상 클래스 객체의 형 변환 종단 클래스 instanceof 연산자 접근 한정자와 변수의 유효

66 장장

한빛미디어 ( 주 )

ㅎㅎ

• 개요• 상속 및 확장 클래스 • 인터페이스 및 다중 상속 , 추상 클래스 • 객체의 형 변환 • 종단 클래스 • instanceof 연산자 • 접근 한정자와 변수의 유효 범위 • 내부 클래스와 외부 클래스 • 다형성 (Polymorphism)

상속 , 인터페이스 , 은닉 및 다형성

상속 , 인터페이스 , 은닉 및 다형성

2

학습목표

하나의 클래스에서 이를 확장하여 새로운 클래스를 만들어 가는 과정인 상속에 대해서 학습한다 .

클래스의 골격만 정의하는 인터페이스와 여러 부모를 갖는 다중 상속에 대해서 학습한다 .

객체의 형 변환 , 종단 클래스 , instanceof 연산자 등에 대해서 학습한다 .

접근 한정자와 변수의 유효 범위 , 내부 클래스와 외부 클래스 임의의 객체가 다른 객체를 참조할 수 있는 다형성 등에 대해서 학습한다 .

6 장 . 상속 , 인터페이스 , 은닉 및 다형성

3

상속상속의 개요멤버 변수의 상속예약어 super메소드의 상속과 오버라이딩 (overriding)상속과 생성자객체의 형변환추상 클래스와 추상 메소드예약어 final

4 4

상속의 개요

OOP[ o b je ct -o r ien t ed p r og r am m in g , oop ]의 주요 특성인 모듈의 재사용과 코드의 간결성 제공상속의 개념을 이용하여 클래스의 계층구조 구성JDK 에서 제공되는 클래스로부터 상속 받아 자바 프로그램 작성자바에서의 모든 클래스는 상위 클래스를 가진다자바 프로그램의 최상위 클래스는 java.lang.Object 클래스이다 . 상위 클래스를 지정하기 위해 “ extends” 키워드 사용

5 5

상속의 개요

• 상속이 포함된 클래스 선언 형식

[public/final/abstract] class 클래스이름 extends 상위클래스이름 {

.......... // 멤버변수선언 .......... // 생성자 .......... // 메소드선언}

6 6

멤버 변수의 상속

• 멤버 변수 상속의 예

class A { int aa = 1;}class B extends A { int bb = 2;}class C extends B { int cc = 3;}class Dabc { public static void main(String[] args) { C objc = new C(); System.out.println("objc 객체의 객체속성변수 aa 의 값은 " + objc.aa); System.out.println("objc 객체의 객체속성변수 bb 의 값은 " + objc.bb); System.out.println("objc 객체의 객체속성변수 cc 의 값은 " + objc.cc); }}

출력 결과objc 객체의 객체속성변수 aa 의 값은 1objc 객체의 객체속성변수 bb 의 값은 2objc 객체의 객체속성변수 cc 의 값은 3

7

Inheritence1.java

class A { int i; private int j; // private 타입으로 선언 void setij(int x, int y) { i = x; j = y; }}class B extends A { int total; void sum() { total = i + j; // 에러 발생 . private 타입의 변수 j 를 하위 클래스에서 사용못함 }}class Access { public static void main(String args[]) { B subOb = new B(); subOb.sum(); }}

8

Inheritence2.java

class B1 { int x;}

class B2 extends B1 { String x;}

class Inheritence2 { public static void main(String args[]) { B2 b2 = new B2(); b2.x = "알기쉽게 해설한 자바 "; // B1 클래스에서 선언된 int x는 가려짐 만일 b2.x=50을 넣으려 // 한다면 에러 발생

System.out.println("객체 b2에 들어있는 x 값 : " + b2.x); B1 b1 = new B1(); b1.x = 5000; System.out.println("객체 b1에 들어있는 x 값 : " + b1.x); }}

9

Inheritence3.java

/* 클래스 변수도 상속된다 . 하위 클래스에서 상위 클래스의 클래스 변수가정의되면 상위 클래스의 변수가 가려진다 */class C1 { static int x; static int y;}

class C2 extends C1 { static String x;}

class Inheritence3 { public static void main(String args[]) { C2.x = "알기쉽게 해설한 자바 "; // C1 클래스에서 선언된 int x는 가려짐 C2.y = 20000; C1.x = 30000; System.out.println("클래스 변수 C2.x 값 : " + C2.x); System.out.println("클래스 변수 C2.y 값 (C1으로부터 상속 ) : " + C2.y); System.out.println("클래스 변수 C1.x 값 : " + C1.x); }}

10

10

예약어 super

super 의 사용하위 클래스에 의해 가려진 상위 클래스의 멤버 변수나 메소드에 접근할 때

super. 객체변수 super. 메소드이름 ( 매개변수 )

상위 클래스의 생성자를 호출할 때

super( 매개변수 )

11

InheritenceSuper.java

class D1 {

int x = 1000;

void display() {

System.out.println("상위클래스 D1의 display() 메소드 입니다 ");

}

}

class D2 extends D1 {

int x = 2000;

void display() {

System.out.println("하위클래스 D2의 display() 메소드 입니다 ");

}

void write() {

this.display();

super.display();

System.out.println("D2 클래스 객체의 x 값은 : " + x); System.out.println("D1 클래스 객체의 x 값은 : " + super.x); }

}

class InheritenceSuper {

public static void main(String args[]) {

D2 d = new D2();

d.write();

}

}

12

12

메소드 상속과 오버라이딩

오버로딩 (overloading) 같은 클래스 내에 같은 이름의 생성자나 메소드를

사용하는 행위 매개변수의 개수와 타입이 달라야 한다

오버라이딩 (overriding) 상속관계에 있는 클래스들간에 같은 이름의 메소드를

정의하는 행위 기존 클래스의 메소드 구현 부분만 약간 변화시켜

새로운 클래스를 생성할 수 있다 매개변수의 개수와 타입이 같아야 한다

오버로딩과 오버라이딩은 객체지향 언어의 주요 개념인 다형성 (polymorphism) 을 구현한다

13

Inheritence4.java

class A {

int i;

int j;

void setij(int x, int y) {

i = x;

j = y;

}

}

class B extends A {

int total;

void sum() {

total = i + j;

}

}

class Inheritence4 {


B subOb = new B();

subOb.setij(10, 12); // 클래스 A 로부터 상속된 메소드 subOb.sum(); // 클래스 B 의 메소드 System.out.println("두수의 합계는 : " + subOb.total); }

}

14

OverrideExam1.java

class A { void show(String str) { System.out.println("상위클래스의 메소드 show(String str) 수행 " + str); }}

class B extends A { void show() { System.out.println("하위클래스의 메소드 show() 수행 "); }} class OverrideExam1 { public static void main(String args[]) { B over = new B(); over.show("알기쉽게 해설한 자바 "); over.show(); }}

15

OverrideExam2.java

class A {

void show() { System.out.println("상위클래스의 메소드 show(String str) 수행 "); }}

class B extends A {

void show() { System.out.println("하위클래스의 메소드 show() 수행 "); }} class OverrideExam2 { public static void main(String args[]) { B over = new B(); over.show(); }}

16

OverrideExam3.javaclass A { int i, j; A(int a, int b) { i = a; j = b; } void show() { System.out.println("상위클래스의 메소드 show() 수행 "); }}class B extends A { int k; B(int a, int b, int c ) { super(a,b); // 상위 클래스의 생성자를 호출 k = c; } void show() { System.out.println("하위 클래스의 메소드 show() 수행 "); System.out.println("===super를 이용한 상위 클래스 메소드 호출 ==="); super.show(); }} class OverrideExam3 { public static void main(String args[]) { B over1 = new B(10, 20, 30); System.out.println("i, j, k의 값 : " + over1.i + " " + over1.j + " " + over1.k); over1.show(); }}

17

17

상속과 생성자

상속된 클래스로부터 객체가 생성될 때 상위 클래스의 생성자가 하위 클래스의 생성자보다 먼저 수행

상위 클래스의 묵시적인 생성자 ( 매개변수가 없는 ) 가 수행묵시적인 생성자가 아닌 다른 생성자를 호출 ( 오버로딩의 경우 ) 하고자 한다면 예약어 super 를 사용하여 명시적으로 호출super 문장은 반드시 첫번째 라인에 와야 한다 .

18

Constructors1.javaclass A1 { double d1; A1() { // System.out.println("클래스 A1의 생성자 수행 "); d1 = 10*10; }}class A2 extends A1 { double d2; A2() { System.out.println("클래스 A2의 생성자 수행 "); d2 = 10*10*10; }}class A3 extends A2 { double d3; A3() { System.out.println("클래스 A3의 생성자 수행 "); d3 = 10*10*10*10; }}class Constructors1 { public static void main(String args[]) { A3 super1 = new A3(); System.out.println("10의 2 제곱 : " + super1.d1); System.out.println("10의 3 제곱 : " + super1.d2); System.out.println("10의 4 제곱 : " + super1.d3); }}

19

Constructors2.javaclass A1 {

int d1;

int s;

A1(int s1) {

System.out.println("클래스 A1의 생성자 수행 ");

s = s1;

d1 = s * s ;

}}

class A2 extends A1 {

int d2;

int t;

A2(int s1, int t1) {

super(s1); // 상위 클래스의 생성자를 명시적으로 호출 System.out.println("클래스 A2의 생성자 수행 ");

t = t1;

d2 = t * t ;

}}

class Constructors2 {


A2 super2 = new A2(10,20);

System.out.println("10의 제곱은 : " + super2.d1); System.out.println("20의 제곱은 : " + super2.d2); }}

20

20

객체의 형변환

상속 관계의 클래스에서 객체의 형변환 가능class Acast { int a=1; }class Bcast extends Acast { int b=2; }class Ccast extends Bcast { int c=3; }

class TestCasting { public static void main(String[] args) { Acast refA; // Acast 타입의 객체 refA 선언 refA = new Ccast(); /* Acast 타입의 객체 참조 변수 refA 에 Ccast 클래스의 객체를 생성하여 할당 */ System.out.println("refA.a 의 값은 "+refA.a); }}

출력결과refA.a 의 값은 1

21

21

객체의 형변환

앞의 프로그램을 다음과 같이 수정

class TestCasting { public static void main(String[] args) {

Acast refA; refA = new Ccast();

System.out.println("refA.a 의 값은 "+ refA.c ); // Ccast 클래스의 멤버인 c 에 접근 시도 . 에러 발생

} }

TestCasting.java:13: No variable c defined in class Acast. System.out.println("refA.a 의 값은 "+refA.c); ^ 1 error

22

22

객체의 형변환

앞의 프로그램을 반대로 다음과 같이 수정 class TestCasting {

public static void main(String[] args) { Ccast refC = new Acast(); // 에러 발생 System.out.println("refC.a 의 값은 "+refC.a); } }

TestCasting.java:12: Incompatible type for declaration. Explicit cast needed to convert Acast to Ccast. Ccast refC = new Acast(); ^1 error

23

OverridingCast.javaclass A { void callme() { System.out.println("클래스 A 의 callme() 메소드 실행 "); }}class B extends A { void callme() { //오버라이딩 된 메소드 System.out.println("클래스 B 의 callme() 메소드 실행 "); }}class C extends A { //오버라이딩 된 메소드 void callme() { System.out.println("클래스 C 의 callme() 메소드 실행 "); }}class OverridingCast { public static void main(String args[]) { A r = new A(); r.callme(); r = new B(); r.callme(); r = new C(); r.callme(); }}

24

24

추상 클래스와 추상 메소드

추상 클래스 하위 클래스에서 구현될 추상적인 기능만을 추상 메소드로 선언 추상 메소드는 기능이 무엇 (What) 인지만을 선언하고 구현부분이

없는 메소드이다 추상 메소드는 하위 클래스에서 오버라이딩되어 구현된다 추상 클래스는 추상 메소드 외에 일반적인 속성과 메소드를 가질 수

있다 .

abstract class 클래스이름 { ……..// 일반 속성과 메소드 기술 abstract void 추상메소드이름 (); // 추상 메소드 선언 ……..}

25

AbstractClass.java

abstract class Shape { // 추상클래스 선언 abstract void draw(); // 구현부분이 없는 추상 메소드 정의}

class Circle extends Shape {

void draw() {

System.out.println("원을 그리는 기능 ");

}}

class Rectangle extends Shape {

void draw() {

System.out.println("사각형을 그리는 기능 ");

}}

class Triangle extends Shape {

void draw() {

System.out.println("삼각형을 그리는 기능 ");

}}

class AbstractClass {


Circle c = new Circle(); c.draw();

Rectangle r = new Rectangle(); r.draw();

Triangle t = new Triangle(); t.draw();

System.out.println("====객체 형변환과 오버라이딩을 이용 ====");

Shape s = new Circle(); // 상위 클래스의 객체에 하위 클래스의 객체를 형변환 s.draw(); // draw() 메소드 호출 s = new Rectangle(); s.draw(); // draw() 메소드 호출 s = new Triangle(); s.draw(); // draw() 메소드 호출 }}

26

26

예약어 final

final 을 3 가지 용도로 사용 상수로 사용될 객체 속성 변수 메소드에 final 을 붙이면 하위 클래스에서

오버라이딩 할 수 없다 클래스에 final 을 붙여 하위 클래스를 가지지

못하게 한다

final 을 사용하는 이유 보안과 설계부분을 명확하게 하기 위해

27

인터페이스와 패키지

인터페이스 개요와 인터페이스 정의인터페이스의 사용인터페이스의 상속인터페이스 참조연산자 Instanceof패키지 개요와 JDK 패키지패키지의 사용사용자 패키지의 작성 및 사용

28

28

인터페이스의 개요와 인터페이스 정의

인터페이스 개요상수와 메소드 선언 (= 추상메소드 ) 만을 가진다다중 상속의 기능을 제공클래스가 다른 클래스로부터 상속을 받고 있는 상태에서 다른 요소들의 상속이 요구될 때 인터페이스를 사용

인터페이스 정의public interface 인터페이스이름 [extends 인터페이스이름 , .....] { ..... // 상수선언 ..... // 메소드 선언}

29

29

인터페이스 정의 - 예

public interface Sleeper { public long ONE_SECOND = 1000; public long ONE_MINUTE = 60000; public void wakeup();}

30

30

인터페이스의 사용

클래스 생성시 인터페이스를 사용하기 위해 “implements” 예약어 사용

인터페이스를 사용하여 생성된 클래스는 인터페이스에 선언된 모든 메소드를 오버라이딩하여 구현 하여야 한다

인터페이스를 사용하는 클래스의 구문 형태

[public/final/abstract] class 클래스이름 extends 상위클래스이름 implements 인터페이스이름 [, 인터페이스이름 , .....] { .... // 멤버변수선언 .... // 생성자 .... // 메소드선언 // 인터페이스에 선언된 모든 메소드를 오버라이딩하여 선언}

31

31

인터페이스의 사용 - 예

public interface Sleeper { public long ONE_SECOND = 1000; public long ONE_MINUTE = 60000; public void wakeup(); }public interface Worker { public long WORK_TIME = 8; public void sleep();}public class Man implements Sleeper, Worker { // Man 클래스는 두 개의 인터페이스를 포함하고 있다 public void wakeup() { // 인터페이스에서 선언된 모든 메소드를 오버라이딩 System.out.println(" 빨리 일어나 !!"); } public void sleep() { .......… }}

32

32

인터페이스의 상속

인터페이스도 클래스와 같이 상속될 수 있다인터페이스 상속시 예약어 extends 사용

public interface 인터페이스이름 extends 인터페이스이름 [, 인터페이스 이름 ,....] { 상수선언 메소드 선언}

33

33

인터페이스의 상속 - 예

public interface Sleeper { public long ONE_SECOND = 1000; public long ONE_MINUTE = 60000; public void wakeup(); }public interface Worker { public long WORK_TIME = 8; public void sleep();}public interface People extends Sleeper, Worker { public int MAX = 24; public int MIN = 0; public void work();}

Sleeper Worker

People

34

ITExtend.javainterface A {

void ameth1();

void ameth2();

}

interface B {

void bmeth1();

}

interface C extends A,B { // 두개의 인터페이스 상속 void cmeth1();}

class InterfaceClass implements C {

public void ameth1() {

System.out.println("ameth1() 메소드의 구현 ");

}

public void ameth2() {

System.out.println("ameth2() 메소드의 구현 ");

}

public void bmeth1() {

System.out.println("bmeth1() 메소드의 구현 ");

}

public void cmeth1() {

System.out.println("cmeth1() 메소드의 구현 ");

}

}

class ITExtend { public static void main(String arg[]) { InterfaceClass ic = new InterfaceClass();

ic.ameth1(); ic.ameth2(); ic.bmeth1(); ic.cmeth1(); }}

35

35

인터페이스 참조

인터페이스도 클래스처럼 형변환이 가능인터페이스 타입의 객체 참조 변수에 인터페이스를 포함하는 클래스의 객체를 할당클래스와 마찬가지로 인터페이스 타입의 객체 참조변수를 통하여는 인터페이스에 선언된 속성만 접근 가능

36

36

interface A { int CONS = 5; public void display(String s);}class A1 implements A { int a = 10; public void display(String s) System.out.println("display 메소드 구현 " + s);} }class InterTest { public static void main(String args[]) { A interfaceA; interfaceA = new A1(); // A 인터페이스 형의 변수에 A1 클래스의 객체를 할당 interfaceA.display(" 인터페이스 테스트 "); System.out.println("A 의 상 수 CONS 의 값 은 "+interfaceA.CONS); System.out.println("A1 의 a 값 출력 "+interfaceA.a); /* 에러 발생 . 즉 인터페이스 타입의 객체 참조 변수는 인터페이스에서 선언된 상수와 메소드에만 접근이 가능 */ }}

인터페이스 참조 - 예

InterTest.java:19: No variable a defined in interface A. System.out.println("A1 의 a 값 출력 "+interfaceA.a); ^1 error

37

InterfaceReference.javainterface A { void display(String s);} class C1 implements A { public void display(String s) { System.out.println("클래스 C1 객체 이용 : " + s); }}class C2 implements A { public void display(String s) { System.out.println("클래스 C2 객체 이용 : " + s); }}class C3 implements A { public void display(String s) { System.out.println("클래스 C3 객체 이용 : " + s); }}

class InterfaceReference { public static void main(String args[]) {

A memo; // A인터페이스형 참조 변수 memo 선언 memo = new C1(); // 클래스 C1의 객체를 생성하여 memo에 할당 memo.display("안녕하세요 ? "); memo = new C2(); memo.display("알기쉽게 해설한 자바 ."); memo = new C3(); memo.display("자바를 자바봅시다 ."); }}

38

38

연산자 instanceof

객체가 특정 클래스나 인터페이스로부터 생성된 객체인지를 판별해주는 관계 연산자 ( 표 4-4)

형식

객체참조변수 instanceof type

39

instanceof 연산자 instanceof 연산자란 하나의 어떤 객체가 특정한 어떤 클래스 또는 인터페이스에 의해서 생성된 객체인지 아닌지를 판단하기 위하여 사용하는 연산자이며 참인 경우에 true, 거짓인 경우에 false 를 반환한다 . instanceof 연산자의 일반 형식은 다음과 같다 .

Section 06 instanceof 연산자 (1/1)

객체명 instanceof 클래스명 또는

객체명 instanceof 인터페이스명

40

InstanceOf.javaclass A { int i, j;}class B extends A{ int k;}class C extends B { int l;}class InstanceOf { public static void main(String args[]) { A a = new A(); B b = new B(); C c = new C(); if(a instanceof A) System.out.println("a는 A 클래스의 객체 "); if(b instanceof B) System.out.println("b는 B 클래스의 객체 "); if(c instanceof C) System.out.println("c는 C 클래스의 객체 ");

if(c instanceof A) System.out.println("c는 A 클래스의 객체 : 형변환 "); // 객체 c 는 클래스 A 가 가지고 있는 모든 정보를 제공할 수 있다 // 형변환이 성공한다 if(a instanceof C) System.out.println("a는 C 클래스의 객체 : 형변환 "); else System.out.println("a는 C 클래스의 객체가 아님 : 형변환 불가 "); // 객체 a 는 클래스 C 가 가지고 있는 모든 정보를 제공할 수 없다 // 형변환이 실패 }}

41

41

패키지 개요와 SDK 패키지

패키지 : 비슷한 종류의 클래스나 인터페이스들을 묶어 패키지화 한다SDK 에서 많은 패키지 제공

java.lang : 자바 프로그램의 기본적인 기능을 제공 . 명시적으로 지정하지 않아도 모든 자바 프로그램에 포함되는 패키지java.util : 유용한 유틸리티 클래스를 제공java.io : 입출력 기능을 제공하는 패키지java.net : 네트워킹과 관련된 기능을 제공하는 패키지 . telnet, ftp, http와 같은 프로토콜을 사용할 수 있는 클래스를 제공java.awt : 그래피컬 사용자 인터페이스 (GUI) 를 구축하기 위한 다양한 컴포넌트를 제공하는 패키지java.awt.event : AWT 컴포넌트들의 이벤트를 제어하는 패키지java.applet : 애플릿 프로그램과 연관된 클래스를 제공하는 패키지

42

42

패키지의 사용

import 문을 사용하여 패키지 포함 import java.util.Date;

...… Date date = new Date(); // java.util.Date 클래스만을 사용...…

import java.util.*;....… Date date = new Date(); // java.util 패키지의 모든 클래스를 사용 Random random = new Random(); Stack stack = new Stack(); Hashtable hashtable = new Hashtable(); ........…............

43

43

사용자 패키지의 작성 및 사용

사용자가 작성한 클래스를 패키지로 만들어 사용할 수 있다작성된 클래스를 패키지로 지정하기 위해서는 프로그램의 첫 라인에 다음과 같이 지정하여야 한다

package package-name;

CLASSPATH 환경 변수를 설정

44

44

사용자 패키지의 작성 및 사용 - 예

package MyPackage; // 작성된 클래스를 public class Name { // MyPackage 패키지로 선언 public void print() { System.out.println("cskim"); }}

import MyPackage.*;class TestUserPackage { public static void main(String args[]) { Name a = new Name(); // MyPackage 의 클래스 사용 a.print(); }}

45

46

상속 (Inheritance) 자바에서의 상속은 하나의 클래스에서 이 클래스를 확장하여 새로운 클래스를 만들어 나가는 과정을 말한다 . 여러개의 클래스를 확장할 수 있는 것이 아니라 단일 상속으로 확장된다 . 예를 들면 , 자동차 클래스라는 상위 클래스를 정의 한 후에 하위 클래스인 버스나 트럭 클래스를 확장하거나 추가할 수 있다 .

인터페이스 (Interface) 인터페이스란 클래스의 골격만 정의한 것이다 . 종단 (final) 변수인 상수와 추상 메소드로 구성된 클래스이다 . 클래스 내의 인터페이스의 구현을 위하여 implement 문을 사용한다 . 인터페이스의 개념을 사용하면 자바에서 허용되지 않는 다중 상속이 가능하게 된다 . 즉 , 여러 개의 부모를 갖는 효과를 줄 수 있다 .

Section 01 개요 (1/2)

47

한정자 (Modifier)클래스 , 변수 , 메소드 앞에서 사용되며 , 종류에 따라 특정한 의미를 갖는다 . 종류에는 클래스 접근 한정자 , 필드 접근 한정자 , 생성자 접근 한정자 및 메소드 접근 한정자 등이 있다 . 각각에 공통적으로 많이 사용되는 것은 public, private, protected, package 등이다 .

Section 01 개요 (2/2)

은닉 (Encapsulation) 은닉은 외부 사용자로부터 내부의 데이터 등의 구조를 보호하기 위하 여 접근 금지 등을 하게하는 것을 말한다 . 예를 들면 private 한정자는 해당 멤버의 참조 범위를 자신의 클래스 내로 한정 시킨다 .

다형성 (Polymorphism) 임의의 객체가 다른 객체를 참조할 수 있는 것을 말한다 . 하나의 모습을 가지고 여러 형태로 보일 수 있는 특징이 있다 . 예를 들면 , “먹는다”라는 클래스에서 파생된 클래스로는 “사람이 먹는다 .”, “ 호랑이가 먹는다 .”, “양이 먹는다 .” 등이 있을 수 있다 . 여기서 파생된 클래스는 “먹는다”라는 상위 클래스를 가지는 특성을 지닌다 .

48

상속이란상속 (inheritance) 이란 새로 생성된 클래스와 또 다른 생성된 클래스가 존재할 때 하나의 클래스로부터 다른 클래스에 속성(attribute) 과 행위 (behavior) 를 상속 또는 계승 (inheritance) 하는 것을 의미한다 .즉 , 클래스의 확장 (extension), 파생 (derived) 이라는 용어로도 사용되며 기존의 클래스를 상위 클래스 (super class, base class, parent class), 상속된 클래스를 하위 클래스 (sub class, derived class, child class) 라고 한다 . 상위 클래스 내의 멤버 변수나 메소드가 private 접근 한정자를 사용할 때는 그 멤버는 상속시킬 수 없다 . 즉 , 하위 클래스에서 상위 클래스에 그 멤버에 접근할 수가 없다 . 또한 상위 클래스의 생성자도 하위 클래스에 상속되지 않는다 . 상속을 사용하면 소프트웨어의 재사용 측면에서 장점을 갖고 있다 . 확장된 클래스의 일반 형식

Section 02 상속 및 확장 클래스 (1/3)

[public/abstract/final] class 하위클래스명 extends 상위클래스명 { ......... }

49

다중 상속 자바에서의 상속은 하나의 클래스에서 이 클래스를 확장하여 새로운 클래스를 만들어 나가는 과정을 말한다 . 여러 개의 클래스를 확장할 수 있는 것이 아니라 단일 상속 (single inheritance) 으로 확장된다 . 단 , 인터페이스의 개념을 사용하면 자바에서 허용되지 않는 다중 상속이 가능하게 된다 .


this 예약어 어떤 클래스가 존재할 때 그 클래스 내에서 자기 자신을 가리키는 예약어이다 . 이것을 사용하면 멤버 변수나 메소드 명을 명확히 구분 할 수 있다 . this 를 사용하는 경우는 일반적으로 생성자나 메소드의 매개변수가 클래스 내의 객체 변수명과 동일한 이름을 사용하는 경우에 사용된다 . 만일 생성자나 메소드의 매개변수가 클래스 내의 객체 변수명과 동일한 이름이 아닌 경우에는 this 를 사용하지 않아도 된다

50

super 예약어 어떤 클래스가 존재할 때 그 상위 클래스를 가리키는 예약어이다 . 이것을 사용하면 멤버 변수나 메소드 명을 명확히 구분할 수 있다 . super 를 사용하는 경우는 일반적으로 생성자나 메소드의 매개변수가 상위 클래스 내의 객체 변수명과 동일한 이름을 사용하는 경우에 사용된다 .


메소드의 재정의 메소드의 재정의 (overriding) 란 상위 클래스와 하위 클래스가 생성되어 존재할 때그 각각 안에 동일한 이름의 메소드가 있을 때 상위 클래스로부터 하위 클래스로 상속되는 메소드는 무시되고 하위 클래스에 있는 메소드가 적용되는 것을 말한다 . private, final 메소드는 재정의가 불가능하다 .

51

[ 실습하기 6-1] 상속 (inheritance), this 예약어 , super 예약어 사용 (1/9)

52

01 class Sungjuk_6_1 { 02 String hakbun; 03 String name; 04 int jumsu; 05 public void set_hakbun(String hakbun) { 06 this.hakbun = hakbun; } 07 public void set_name(String name) { 08 this.name = name; } 09 public void set_jumsu(int jumsu) { 10 this.jumsu = jumsu; } 11 public void prt_data() { 12 System.out.println(hakbun + " " + name + " " + jumsu); } 13 void title() { 14 System.out.println("*** 상속 (inheritance) / this / super 사용 ***"); 15 System.out.println("*** 자바의 성적 출력 ***"); 16 System.out.println("** 학번 ** ** 성명 ** **점수 **"); 17 System.out.println("---------------------------"); } } 18 19 class Sungjuk_6_1_1 extends Sungjuk_6_1 { 20 void title() { 21 super.title(); 22 }}

Jv_6_1.java


53

23 24 class Jv_6_1 extends Sungjuk_6_1 { 25 public static void main(String[] args) { 26 Sungjuk_6_1 ken_sung = new Sungjuk_6_1(); 27 ken_sung.set_hakbun("2060001"); 28 ken_sung.set_name("Ko Eung-Nam"); 29 ken_sung.set_jumsu(60); 30 Sungjuk_6_1 wife_sung = new Sungjuk_6_1(); 31 wife_sung.set_hakbun("2060002"); 32 wife_sung.set_name("Boo Chang-Mi"); 33 wife_sung.set_jumsu(80); 34 Sungjuk_6_1 yoo_sung = new Sungjuk_6_1(); 35 yoo_sung.set_hakbun("2060003"); 36 yoo_sung.set_name("Ko Yoo-Jin"); 37 yoo_sung.set_jumsu(100); 38 Sungjuk_6_1 soo_sung = new Sungjuk_6_1(); 39 soo_sung.set_hakbun("2060004"); 40 soo_sung.set_name("Ko Su-Ji"); 41 soo_sung.set_jumsu(99); 42 Sungjuk_6_1_1 ttt = new Sungjuk_6_1_1(); 43 ttt.title(); 44 ken_sung.prt_data();

Jv_6_1.java


54

45 wife_sung.prt_data(); 46 yoo_sung.prt_data(); 47 soo_sung.prt_data(); 48 } 49 }

Jv_6_1.java


55

01 행 , 17 행 : 클래스 Sungjuk_6_1 를 의미한다 .

01 행 , 19 행 , 24 행 : 상속 (inheritance)

클래스는 Sungjuk_6_1, Sungjuk_6_1_1, Jv_6_1 3 개가 존재한다 .

class Sungjuk_6_1_1 extends Sungjuk_6_1 에서는 extends 예약어를 사용해 클래스 Sungjuk_6_1_1 은 클래스 Sungjuk_6_1 로부터 상속받는다 . class Jv_6_1 extends Sungjuk_6_1 에서는 extends 예약어를 사용해 클래스 Jv_6_1 은 클래스 Sungjuk_6_1로부터 상속받는다 . 즉 , 상위 클래스는 Sungjuk_6_1 이고 그 하위 클래스는 Sungjuk_6_1_1과 Jv_6_1 이다 .

25 행 : 애플리케이션 응용을 위한 메인 함수 호출

26 행 : Sungjuk_6_1 ken_sung = new Sungjuk_6_1(); 에서는 클래스

Sungjuk_6_1() 의 객체 ken_sung 을 생성한다 .

27~29 행 : 객체 ken_sung 의 메소드 set_hakbun(), set_name( ), set_jumsu() 를 호출한다 .

30 행 : Sungjuk_6_1 wife_sung = new Sungjuk_6_1(); 에서는 클래스 Sungjuk_6_1() 의 객체 wife_sung 을 생성한다 .

프로그램 구조 설명


56

29~33 행 : 객체 wife_sung 의 메소드 set_hakbun(), set_name( ), set_jumsu() 를 호출한다 .

34 행 : Sungjuk_6_1 yoo_sung = new Sungjuk_6_1(); 에서는 클래스 Sungjuk_6_1() 의 객체 yoo_sung 을 생성한다 .

35~37 행 : 객체 yoo_sung 의 메소드 set_hakbun(), set_name( ), set_jumsu() 를 호출한다 .

38 행 : Sungjuk_6_1 soo_sung = new Sungjuk_6_1(); 에서는 클래 Sungjuk_6_1() 의 객체 soo_sung 을 생성한다 .

39~41 행 : 객체 soo_sung 의 메소드 set_hakbun(), set_name( ), set_jumsu() 를 호출한다 .

42 행 : Sungjuk_6_1_1 ttt = new Sungjuk_6_1_1(); 에서는 클래 Sungjuk_6_1_1() 의 객체 ttt를 생성한다 .



57

02~04 행 : 멤버 변수

String hakbun; String name; int jumsu; 은 클래스 Sungjuk_6_1 의 멤버 변수 를 의미한다 .

05~12 행 : 메소드와 this 예약어

다음은 클래스 Sungjuk_6_1 의 멤버인 메소드를 의미한다 .

public void set_hakbun(String hakbun)

{ this.hakbun = hakbun; }

public void set_name(String name) {this.name = name; }

public void set_jumsu(int jumsu) {this.jumsu = jumsu; }

public void prt_data()

{System.out.println(hakbun + " " + name + " " + jumsu); this 예약어란 어떤 클래스가 존재할 때 그 클래스 내에서 자기 자신을 가리키는 예약어이다 . 이것을 사용하면 멤버 변수나 메소드 명을 명확히 구분할 수 있다 . this 를 사용하는 경우는 일반적으로 생성자나 메소드의 매개변수가 클래스 내의 객체 변수명과 동일한 이름을 사용하는 경우에 사용된다 . 만일 생성자나 메소드의 매개변수가 클래스 내의 객체 변수명과 동일한 이름이 아닌 경우에는 this 를 사용하지 않아도 된다 .



58

20~22 행 , 13~17 행 : super 예약어

super 예약어란 어떤 클래스가 존재할 때 그 상위 클래스를 가리키는 예약어이다 . 이것을 사용하면 멤버 변수나 메소드 명을 명확히 구분할 수 있다 . super 를 사용하는 경우는 일반적으로 생성자나 메소드의 매개 변수가 상위 클래스 내의 객체 변수명과 동일한 이름을 사용하는 경우에 사용 된다 . super.title(); 에서 super 예약어는 class Sungjuk_6_1_1 extends Sungjuk_6_1 에서 하위 클래스 Sungjuk_6_1_1 의 상위 클래스 Sungjuk_6_1 에 있는 메소드

void title() {

System.out.println("*** 상속 (inheritance) / this / super 사용 ***");

System.out.println("*** 자바의 성적 출력 ***");

System.out.println("** 학번 ** ** 성명 ** **점수 **");

System.out.println("---------------------------"); } 를 호 출하여 실행한다 .



59

43 행 : 객체 ttt 의 메소드 title() 를 호출한다 .

44~47 행 : 상속받은 메소드 호출

ken_sung.prt_data(); 에서는 클래스 Sungjuk_6_1() 의 객체 ken_sung 으로부터 상속받은 메소드 prt_data() 를 호출한다 .

wife_sung.prt_data(); 에서는 클래스 Sungjuk_6_1() 의 객체 wife_sung 으로부터 상속받은 메소드 prt_data() 를 호출한다 .

yoo_sung.prt_data(); 에서는 클래스 Sungjuk_6_1() 의 객체 yoo_sung 으로부터 상속받은 메소드 prt_data() 를 호출한다 .

soo_sung.prt_data(); 에서는 클래스 Sungjuk_6_1() 의 객체 soo_sung 으로부터 상속받은 메소드 prt_data() 를 호출한다 .



60

[ 실습하기 6-2] 상속 (inheritance), 메소드의 재정의 (overriding) 사용 (1/9)

61

01 class Sungjuk_6_2 { 02 String hakbun; 03 String name; 04 int jumsu; 05 public void set_hakbun(String hakbun) { 06 this.hakbun = hakbun; } 07 public void set_name(String name) { 08 this.name = name; } 09 public void set_jumsu(int jumsu) { 10 this.jumsu = jumsu; } 11 void prt_data() { 12 System.out.println(hakbun + " " + name + " " + jumsu);} 13 void title() { 14 System.out.println("*** 상속 (inheritance) / 오버라이딩 (overriding) 사용 ***"); 15 System.out.println("*** 자바의 성적 출력 ***"); 16 System.out.println("** 학번 ** ** 성명 ** **점수 **"); 17 System.out.println("---------------------------"); 18 } 19 } 20 class Sungjuk_6_2_1 extends Sungjuk_6_2 { 21 String grade;

Jv_6_2.java


62

22 public void set_grade(String grade) { 23 this.grade = grade; } 24 void prt_data() { 25 System.out.println(hakbun + " " + name + " " + grade); } 26 void title() { 27 super.title(); }} 28 29 class Jv_6_2 extends Sungjuk_6_2 { 30 public static void main(String[] args) { 31 Sungjuk_6_2 ken_sung = new Sungjuk_6_2(); 32 ken_sung.set_hakbun("2060001"); 33 ken_sung.set_name("Ko Eung-Nam"); 34 ken_sung.set_jumsu(60); 35 Sungjuk_6_2 wife_sung = new Sungjuk_6_2(); 36 wife_sung.set_hakbun("2060002"); 37 wife_sung.set_name("Boo Chang-Mi"); 38 wife_sung.set_jumsu(80); 39 Sungjuk_6_2 yoo_sung = new Sungjuk_6_2(); 40 yoo_sung.set_hakbun("2060003"); 41 yoo_sung.set_name("Ko Yoo-Jin"); 42 yoo_sung.set_jumsu(100);

Jv_6_2.java


63

43 Sungjuk_6_2 soo_sung = new Sungjuk_6_2(); 44 soo_sung.set_hakbun("2060004"); 45 soo_sung.set_name("Ko Su-Ji"); 46 soo_sung.set_jumsu(99); 47 48 Sungjuk_6_2 ttt = new Sungjuk_6_2(); 49 ttt.title(); 50 ken_sung.prt_data(); 51 wife_sung.prt_data(); 52 yoo_sung.prt_data(); 53 soo_sung.prt_data(); 54 Sungjuk_6_2_1 sub_ken_sung = new Sungjuk_6_2_1(); 55 sub_ken_sung.hakbun = ken_sung.hakbun; 56 sub_ken_sung.name = ken_sung.name; 57 sub_ken_sung.set_grade("D"); 58 Sungjuk_6_2_1 sub_wife_sung = new Sungjuk_6_2_1(); 59 sub_wife_sung.hakbun = wife_sung.hakbun; 60 sub_wife_sung.name = wife_sung.name; 61 sub_wife_sung.set_grade("B"); 62 Sungjuk_6_2_1 sub_yoo_sung = new Sungjuk_6_2_1(); 63 sub_yoo_sung.hakbun = yoo_sung.hakbun;

Jv_6_2.java


64

64 sub_yoo_sung.name = yoo_sung.name; 65 sub_yoo_sung.set_grade("A"); 66 Sungjuk_6_2_1 sub_soo_sung = new Sungjuk_6_2_1(); 67 sub_soo_sung.hakbun = soo_sung.hakbun ; 68 sub_soo_sung.name = soo_sung.name; 69 sub_soo_sung.set_grade("A"); 70 Sungjuk_6_2_1 kkk = new Sungjuk_6_2_1(); 71 kkk.title(); 72 sub_ken_sung.prt_data(); 73 sub_wife_sung.prt_data(); 74 sub_yoo_sung.prt_data(); 75 sub_soo_sung.prt_data(); 76 Sungjuk_6_2 mix_ken_sung = new Sungjuk_6_2_1(); 77 mix_ken_sung.hakbun = ken_sung.hakbun; 78 mix_ken_sung.name = ken_sung.name; 79 //mix_ken_sung.set_grade("D"); <--- error 80 Sungjuk_6_2 mix_wife_sung = new Sungjuk_6_2_1(); 81 mix_wife_sung.hakbun = wife_sung.hakbun; 82 mix_wife_sung.name = wife_sung.name; 83 //mix_wife_sung.set_grade("B"); <--- error 84 Sungjuk_6_2 mix_yoo_sung = new Sungjuk_6_2_1();

Jv_6_2.java


65

85 mix_yoo_sung.hakbun = yoo_sung.hakbun; 86 mix_yoo_sung.name = yoo_sung.name; 87 //mix_yoo_sung.set_grade("A"); <--- error 88 Sungjuk_6_2 mix_soo_sung = new Sungjuk_6_2_1(); 89 mix_soo_sung.hakbun = soo_sung.hakbun ; 90 mix_soo_sung.name = soo_sung.name; 91 //mix_soo_sung.set_grade("A"); <--- error 92 Sungjuk_6_2 mmm = new Sungjuk_6_2_1(); 93 mmm.title(); 94 mix_ken_sung.prt_data(); 95 mix_wife_sung.prt_data(); 96 mix_yoo_sung.prt_data(); 97 mix_soo_sung.prt_data(); } }

Jv_6_2.java


66

01, 20, 29 행 : 상속 (inheritance)

클래스는 Sungjuk_6_2, Sungjuk_6_2_1, Jv_6_2 3 개가 존재한다 .

class Sungjuk_6_2_1 extends Sungjuk_6_2 에서는 extends 예약어를 사용하 여 클래스 Sungjuk_6_2_1 은 클래스 Sungjuk_6_2 로부터 상속받는다 .

class Jv_6_2 extends Sungjuk_6_2 에서는 extends 예약어를 사용해 클래스 Jv_6_2 은 클래스 Sungjuk_6_2 로부터 상속받는다 . 즉 , 상위 클래스는 Sungjuk_6_2 이고 그 하위 클래스는 Sungjuk_6_2_1 과 Jv_6_2 이다 .

11, 12, 24, 25 행 : 메소드의 재정의 (overriding)

하위 클래스 Sungjuk_6_2_1 에서는 prt_data() 라는 메소드가 정의되어

있다 . 이 메소드는 상위 클래스인 Sungjuk_6_2 에서 정의한 prt_data() 라는

메소드와 동일한 이름을 가지고 있다 . 여기서 상위 클래스로부터 상속 받은

prt_data() 라는 메소드는 무시되고 하위 클래스 Sungjuk_6_2_1 에서 새로이

정의된 prt_data() 라는 메소드가 적용된다 .



67

31, 35, 39, 43 행 , 50~53 행 :

Sungjuk_6_2 ken_sung = new Sungjuk_6_2(); 에서는 클래스 Sungjuk_6_2() 의 객체 ken_sung 을 생성한다 .

ken_sung.prt_data(); 을 실행하면 객체 Sungjuk_6_2 는 클래스 Sungjuk_6_2 의 prt_data()가 실행된다 . 즉 , void prt_data() {

System.out.println(hakbun + " " + name + " " + jumsu);

} 이 실행된다 . wife_sung.prt_data(); yoo_sung.prt_data();

soo_sung.prt_data(); 등도 동일한 개념으로 적용된다 .

54, 58, 62, 66 행 , 72~75 행 : Sungjuk_6_2_1 sub_ken_sung = new Sungjuk_6_2_1();에서는 클래스 Sungjuk_6_2_1() 의 객체 sub_ken_sung 을 생성한다 . sub_ken_sung.prt_data(); 을 실행하면 객체 Sungjuk_6_2_1 는 클래스 Sungjuk_6_2_1 의 prt_data() 가 실행된다 . 즉 , 메소드의 재정의 (overriding) 이다 . 하위 클래스 Sungjuk_6_2_1 에서는 prt_data() 라는 메소드가 정의되어 있다 . 이 메소드는 상위 클래스인 Sungjuk_6_2 에서 정의한 prt_data() 라는 메소드와 동일한 이름을 가지고 있다 . 여기서 상위 클래스로부터 상속 받은 prt_data() 라는 메소드는 무시되고 하위 클래스 Sungjuk_6_2_1에서 새로이 정의된 prt_data() 라는 메소드가 적용된다 .



68

76~79 행 : 상위 클래스 Sungjuk_6_2 의 참조 변수로 객체 참조가 가능하다 . 즉 , 상위 클래스 Sungjuk_6_2 의 참조 변수 mix_ken_sung 으로 Sungjuk_6_2 객체와 관련된 부분을 참조 가능하며 하위 클래스인 Sungjuk_6_2_1 객체와 관련된 부분은 참조할 수 없다 .

예를 들면 ,

Sungjuk_6_2 mix_ken_sung = new Sungjuk_6_2_1();

mix_ken_sung.hakbun = ken_sung.hakbun;

mix_ken_sung.name = ken_sung.name; 에서 hakbun, name 은 상위 클래스 와 관련되므로 참조 가능하며 //mix_ken_sung.set_grade("D"); <--- error 에 서는 set_grade("D") 가 하위 클래스와 관련되므로 참조 할 수 없다 . // 를 없애 고 이 명령문을 실행하면 오류가 발생한다 .

80~83 행 . 84~87 행 , 88~91 행 : 위와 동일한 개념으로 적용된다 .



69

인터페이스의 개념 및 선언인터페이스 (Interface) 란 종단 (final) 변수인 상수와 추상 메소드로 구성된 클래스이다 . 인터페이스 접근한정자는 기본적으로 public 이다 그 이유는 인터페이스에서는 메소드 구현하지 않고 선언 부분만 정의되어 있기 때문에 그것을 상속받은 하위 클래스에서 사용하기 때문이다 . 인터페이스 내에 선언된 변수는 자바에 의해서 자동적으로 'public static final'로 선언되며 인터페이스 내에 선언된 메소드는 자바에 의해서 자동적으로 ‘ public abstract'로 선언된다 . 종단 (final) 변수는 상수 값을 정의하는 변수이며 한번 선언되어 초기화되면 그 값 을 변경할 수 없다 . 종단 변수 앞에는 final 이라는 한정자를 사용하며 통상적으로 대문자를 사용한다 . 인터페이스의 선언을 위한 일반 형식

Section 03 인터페이스 및 다중 상속 , 추상 클래스 (1/4)

[ 인터페이스 접근한정자 ] interface 인터페이스명 [extends 인터페이스명 , ... ] { [ 접근 한정자 ] 변수 선언 ; [ 접근 한정자 ] 메소드 선언 ; }

70

인터페이스의 구현클래스 내의 인터페이스의 구현을 위한 일반 형식은 implement문을 사용한다 . 접근 한정자로는 public, abstract, 또는 final 이 사용된다 . 인터페이스에 선언에서 정의된 메소드 구현은 메소드의 재정의 (overriding) 의 의미로 사용된다 . 클래스 내의 인터페이스의 구현을 위한 일반 형식


[ 접근 한정자 ] class 클래스명 [extends 상위클래스 ] implements 인터페이스명{ 멤버변수 ; 생성자 ; 메소드 선언 ; 인터페이스에 선언에서 정의된 메소드 구현 ;}

71

다중 상속과 인터페이스 자바에서의 상속은 단일 상속 (single inheritance) 이다 . 즉 , 하나의 클래스에서 이 클래스를 확장하여 새로운 클래스를 만들어 나가는 과정을 말한다 . 여러 개의 클래스를 확장할 수 있는 것이 아니라 단일 상속으로 확장된다 . 단 , 인터페이스의 개념을 사용하면 자바에서 허용되지 않는 다중 상속이 가능하게 된다 . 인터페이스의 확장은 클래스의 확장과 달리 한 개 이상의 인터페이스에 확장 가능하다 . extends 예약어를 사용한다는 것은 클래스의 확장과 같다


추상 클래스 추상 클래스 (abstract class) 란 실행문은 없고 선언은 되어 있는 한 개 이상의 추상 메소드로 구성된다 . 즉 , 클래스 내에 추상 메소드가 한 개라도 있으면 그 클래스는 추상 클래스로 선언되어야 한다 . 추상 메소드는 그 앞에 abstract 를 붙여야 하고 추상 클래스는 그 앞에 abstract class 를 붙여야 한다 . 여기서 생성자 , static 메소드와 private 메소드는 추상화될 수 없고 추상 클래스는 객체를 생성시킬 수 없지만 참조로 사용 가능하다 . 추상 클래스의 일반 형식 abstract class 추상클래스명 {

... abstract 반환데이터형 추상메소드명 ( 인수 1, ..., 인수 n) }

72

인터페이스와 추상 클래스의 차이점인터페이스는 인터페이스내의 모든 메소드가 추상적 메소드이며 차후에 구현되지만 , 추상 클래스는 일부 구현을 포함하고 있다 . 인터페이스는 설계만을 표현하지만 , 추상 클래스는 설계와 구현을 같이 표현한다 .


73

[ 실습하기 6-3] 인터페이스 (interface) (1/7)

74

01 interface Sungjuk_6_3_1_1 { 02 void set_hakbun(String hakbun); 03 void set_name(String name); 04 } 05 06 interface Sungjuk_6_3_1_2 { 07 void set_jumsu(int jumsu); 08 } 09 10 interface Sungjuk_6_3_1 extends Sungjuk_6_3_1_1, 11 Sungjuk_6_3_1_2 { 12 void title(); 13 void prt_data(); 14 } 15 16 class Sungjuk_6_3 implements Sungjuk_6_3_1 { 17 String hakbun = " "; 18 String name = " "; 19 int jumsu = 0; 20 public void title() { 21 System.out.println("*** 인터페이스 (interface) 사용 ***"); 22 System.out.println("*** 자바의 성적 출력 ***");

Jv_6_3.java


75

23 System.out.println("** 학번 ** ** 성명 ** **점수 **"); 24 System.out.println("---------------------------"); 25 } 26 public void set_hakbun(String hakbun) { 27 this.hakbun = hakbun; 28 } 29 public void set_name(String name) { 30 this.name = name; 31 } 32 public void set_jumsu(int jumsu) { 33 this.jumsu = jumsu; 34 } 35 public void prt_data() { 36 System.out.println(hakbun + " " + name + " " + jumsu); 37 } 38 } 39 40 class Jv_6_3 extends Sungjuk_6_3 { 41 public static void main(String[] args) { 42 Sungjuk_6_3 ken_sung = new Sungjuk_6_3(); 43 ken_sung.set_hakbun("2060001"); 44 ken_sung.set_name("Ko Eung-Nam");

Jv_6_3.java


76

45 ken_sung.set_jumsu(60); 46 Sungjuk_6_3 wife_sung = new Sungjuk_6_3(); 47 wife_sung.set_hakbun("2060002"); 48 wife_sung.set_name("Boo Chang-Mi"); 49 wife_sung.set_jumsu(80); 50 Sungjuk_6_3 yoo_sung = new Sungjuk_6_3(); 51 yoo_sung.set_hakbun("2060003"); 52 yoo_sung.set_name("Ko Yoo-Jin"); 53 yoo_sung.set_jumsu(100); 54 Sungjuk_6_3 soo_sung = new Sungjuk_6_3(); 55 soo_sung.set_hakbun("2060004"); 56 soo_sung.set_name("Ko Su-Ji"); 57 soo_sung.set_jumsu(99); 58 Sungjuk_6_3 ttt = new Sungjuk_6_3(); 59 ttt.title(); 60 ken_sung.prt_data(); 61 wife_sung.prt_data(); 62 yoo_sung.prt_data(); 63 soo_sung.prt_data(); 64 } 65 }

Jv_6_3.java


77

01~08 행 : 인터페이스의 선언

interface Sungjuk_6_3_1_1 {

void set_hakbun(String hakbun);

void set_name(String name);

} 에서 인터페이스명은 Sungjuk_6_3_1_1 이다 . void 형의 set_hakbun() 메소드 , void 형의 set_name() 메소드가 포함되어 있는 인터페이스이다 .

interface Sungjuk_6_3_1_2 {

void set_jumsu(int jumsu);

} 에서 인터페이스명은 Sungjuk_6_3_1_2 이다 . void 형의 set_jumsu() 메소드가 포함되어 있는 인터페이스이다 .



[ 인터페이스 접근한정자 ] interface 인터페이스명 [extends 인터페이스명 , ... ] { [ 접근 한정자 ] 변수 선언 ; [ 접근 한정자 ] 메소드 선언 ; }

78

10~14 행 : 인터페이스의 확장

인터페이스의 확장은 클래스의 확장과 달리 한 개 이상의 인터페이스에 확장 가능하다 . extends 예약어를 사용한다는 것은 클래스의 확장과 같다 .

interface Sungjuk_6_3_1 extends Sungjuk_6_3_1_1, Sungjuk_6_3_1_2 {

void title();

void prt_data();

}

16~38 행 : 인터페이스의 구현

클래스 내의 인터페이스의 구현을 위하여 사용형식은 다음과 같이 implement 문을 사용한다 . 접근 한정자로는 public, abstract, 또는 final 이 사용된다 . 인터페이스에 선언에서 정의된 메소드 구현은 메소드의 재정의 (overriding) 의 의미로 사용된다 .

.



[ 접근 한정자 ] class 클래스명 [extends 상위클래스 ] implements 인터페이스명 { 멤버변수 ; 생성자 ; 메소드 선언 ; 인터페이스에 선언에서 정의된 메소드 구현 ; }

79

40 행 : 하위 클래스 Jv_6_3 는 상위 클래스 Sungjuk_6_3 으로부터 상속 받는다 .

42~45 행 : 클래스 Sungjuk_6_3 에 대한 객체 ken_sung 을 생성하여

메소드 set_hakbun(), set_name(), set_jumsu() 를 참조한다 .

60~63 행 :

ken_sung.prt_data(); 에서는 객체 ken_sung 의 메소드 prt_data() 를 참조한다 .

wife_sung.prt_data(); 에서는 객체 wife_sung 의 메소드 prt_data() 를 참조한다 .

yoo_sung.prt_data(); 에서는 객체 yoo_sung 의 메소드 prt_data() 를 참조한다 .

soo_sung.prt_data(); 에서는 객체 soo_sung 의 메소드 prt_data() 를 참조한다 .



80

[ 실습하기 6-4] 추상 클래스 (1/7)

81

01 class Sungjuk_6_4_4 extends Sungjuk_6_4_3 { 02 String hakbun4 = "2060004"; 03 String name4 = "Ko Su-Ji"; 04 int jumsu4 = 99; 05 public void prt_data1() { 06 System.out.println(hakbun1 + " " + name1 + " " + jumsu1); 07 } 08 public void prt_data2() { 09 System.out.println(hakbun2 + " " + name2 + " " + jumsu2); 10 } 11 public void prt_data3() { 12 System.out.println(hakbun3 + " " + name3 + " " + jumsu3); 13 } 14 public void prt_data4() { 15 System.out.println(hakbun4 + " " + name4 + " " + jumsu4); 16 } 17 } 18 19 class Jv_6_4 extends Sungjuk_6_4_4 { 20 public static void main(String[] args) { 21 Sungjuk_6_4 ttt = new Sungjuk_6_4(); 22 ttt.title();

Jv_6_4.java

[ 실습하기 6-4] 추상 클래스 (2/7)

82

23 Sungjuk_6_4_4 ken_sung = new Sungjuk_6_4_4(); 24 Sungjuk_6_4_4 wife_sung = new Sungjuk_6_4_4(); 25 Sungjuk_6_4_4 yoo_sung = new Sungjuk_6_4_4(); 26 Sungjuk_6_4_4 soo_sung = new Sungjuk_6_4_4(); 27 ken_sung.prt_data1(); 28 wife_sung.prt_data2(); 29 yoo_sung.prt_data3(); 30 soo_sung.prt_data4(); 31 } 32 } 33 34 class Sungjuk_6_4 { 35 void title() { 36 System.out.println("*** 추상 클래스 (abstract class) ***"); 37 System.out.println("*** 자바의 성적 출력 ***"); 38 System.out.println("** 학번 ** ** 성명 ** **점수 **"); 39 System.out.println("---------------------------"); 40 } 41 } 42 43 abstract class Sungjuk_6_4_1 extends Sungjuk_6_4 { 44 String hakbun1 = "2060001";

Jv_6_4.java

[ 실습하기 6-4] 추상 클래스 (3/7)

83

45 String name1 = "Ko Eung-Nam"; 46 int jumsu1 = 60; 47 abstract void prt_data1(); 48 } 49 50 abstract class Sungjuk_6_4_2 extends Sungjuk_6_4_1 { 51 String hakbun2 = "2060002"; 52 String name2 = "Boo Chang-Mi"; 53 int jumsu2 = 80; 54 abstract void prt_data2(); 55 } 56 57 abstract class Sungjuk_6_4_3 extends Sungjuk_6_4_2 { 58 String hakbun3 = "2060003"; 59 String name3 = "Ko Yoo-Jin"; 60 int jumsu3 = 100; 61 abstract void prt_data3(); 62 }

Jv_6_4.java

[ 실습하기 6-4] 추상 클래스 (4/7)

84

34~35 행 : 클래스는 Sungjuk_6_4 이고 title() 은 메소드이며 추상 클래스가 아니므로

void title() {

System.out.println("*** 추상 클래스 (abstract class) ***");

System.out.println("*** 자바의 성적 출력 ***");

System.out.println("** 학번 ** ** 성명 ** **점수 **");

System.out.println("---------------------------");

} 처럼 구현 할 수 있다 .

43, 47, 50, 54, 57, 61 행 : 추상 클래스

추상 클래스 (abstract class) 란 실행문은 없고 선언은 되어 있는 한 개 이상의 추상 메소드로 구성된다 . 즉 , 클래스 내에 추상 메소드가 한 개라도 있으면 그 클래스는 추상 클래스로 선언되어야 한다 . 추상 메소드는 그 앞에 abstract 를 붙여야 하고 추상 클래스는 그 앞에 abstract class 를 붙여야 한다 . 여기서 생성자 , static 메소드와 private 메소드는 추상화 될 수 없고 추상 클래스는 객체를 생성시킬 수 없지만 참조로 사용 가능하다 .


[ 실습하기 6-4] 추상 클래스 (5/7)

85

05, 08, 11, 14 행 : 추상 메소드의 구현

public void prt_data1() {

System.out.println(hakbun1 + " " + name1 + " " + jumsu1);

}



}



}



} 들은 전부 상위 클래스에서 선언된 추상 메소드를 실제로 하위 클래스에서 구현한 메소드들이다 . 즉 , 메소드의 재정의 (overriding) 를 사용한 경우이다 .


[ 실습하기 6-4] 추상 클래스 (6/7)

86

01 행 : 상속 (inheritance)

클래스는 Sungjuk_6_4_4 extends Sungjuk_6_4_3 2 개가 존재한다 .

class Sungjuk_6_4_4 extends Sungjuk_6_4_3 에서는 extends 예약어를 사용해 클래스 Sungjuk_6_4_4 은 클래스 Sungjuk_6_4_3 로부터 상 속받는다 . 즉 , 상위 클래스는 Sungjuk_6_4_3 이고 그 하위 클래스는 Sungjuk_6_4_4 이다


[ 실습하기 6-4] 추상 클래스 (7/7)

87

객체의 형 변환 여러 클래스들 사이에 상속 관계가 있을 때 객체의 형 변환 가능한 경우는 하위 클래스에서 상위 클래스로의 형 변환은 가능하다 .그러나 상위 클래스에서 하위 클래스로의 형 변환은 불가능하며 오류가 발생된다 .

Section 04 객체의 형 변환 (1/1)

88

[ 실습하기 6-5] 객체의 형 변환 (1/6)

89

01 class Jv_6_5 extends Sungjuk_6_5_4 { 02 public static void main(String[] args) { 03 Sungjuk_6_5 ttt = new Sungjuk_6_5(); 04 ttt.title(); 05 Sungjuk_6_5_1 ken_sung = new Sungjuk_6_5_4(); 06 Sungjuk_6_5_2 wife_sung = new Sungjuk_6_5_4(); 07 Sungjuk_6_5_3 yoo_sung = new Sungjuk_6_5_4(); 08 Sungjuk_6_5_4 soo_sung = new Sungjuk_6_5_4(); 09 ken_sung.prt_data1(); 10 wife_sung.prt_data2(); 11 yoo_sung.prt_data3(); 12 soo_sung.prt_data4(); 13 } 14 } 15 16 class Sungjuk_6_5 { 17 void title() { 18 System.out.println("*** 객체의 형 변환 ***"); 19 System.out.println("*** 자바의 성적 출력 ***"); 20 System.out.println("** 학번 ** ** 성명 ** **점수 **"); 21 System.out.println("---------------------------"); 22 }

Jv_6_5.java

[ 실습하기 6-5] 객체의 형 변환 (2/6)

90

23 } 24 25 class Sungjuk_6_5_1 extends Sungjuk_6_5 { 26 String hakbun1 = "2060001"; 27 String name1 = "Ko Eung-Nam"; 28 int jumsu1 = 60; 29 public void prt_data1() { 30 System.out.println(hakbun1 + " " + name1 + " " + jumsu1); 31 } 32 } 33 34 class Sungjuk_6_5_2 extends Sungjuk_6_5_1 { 35 String hakbun2 = "2060002"; 36 String name2 = "Boo Chang-Mi"; 37 int jumsu2 = 80; 38 public void prt_data2() { 39 System.out.println(hakbun2 + " " + name2 + " " + jumsu2); 40 } 41 } 42 43 class Sungjuk_6_5_3 extends Sungjuk_6_5_2 { 44 String hakbun3 = "2060003";

Jv_6_5.java

[ 실습하기 6-5] 객체의 형 변환 (3/6)

91

45 String name3 = "Ko Yoo-Jin"; 46 int jumsu3 = 100; 47 public void prt_data3() { 48 System.out.println(hakbun3 + " " + name3 + " " + jumsu3); 49 } 50 } 51 52 class Sungjuk_6_5_4 extends Sungjuk_6_5_3 { 53 String hakbun4 = "2060004"; 54 String name4 = "Ko Su-Ji"; 55 int jumsu4 = 99; 56 public void prt_data4() { 57 System.out.println(hakbun4 + " " + name4 + " " + jumsu4); 58 } 59 }

Jv_6_5.java

[ 실습하기 6-5] 객체의 형 변환 (4/6)

92

05~12 행 , 30, 39, 48, 57 행 : 객체의 형 변환

05 행 : Sungjuk_6_5_1 ken_sung = new Sungjuk_6_5_4(); 에서 Sungjuk_6_5_1 형의 객체 참조 변수 ken_sung 에 클래스 Sungjuk_6_5_4 의 객체를 생성시켜 할당한 경우인데 , 즉 하위 클래스에서 상위 클래스로의 형 변환은 가능하다 .

class Jv_6_5 extends Sungjuk_6_5_4 {public static void main(String[] args) { Sungjuk_6_5 ttt = new Sungjuk_6_5(); ttt.title(); Sungjuk_6_5_1 ken_sung = new Sungjuk_6_5_4(); Sungjuk_6_5_2 wife_sung = new Sungjuk_6_5_4(); Sungjuk_6_5_3 yoo_sung = new Sungjuk_6_5_4(); Sungjuk_6_5_4 soo_sung = new Sungjuk_6_5_4(); ken_sung.prt_data1(); wife_sung.prt_data2(); yoo_sung.prt_data3(); soo_sung.prt_data4();}} [1] [2] [3] [4] [5] [6] [7] [8] 그러나 Sungjuk_6_5_4 ken_sung = new Sungjuk_6_5_1(); 처럼 상위 클래스에서 하위 클래스로의 형변환은 불가능하며 오류가 발생된다 .

06 행 : Sungjuk_6_5_2 wife_sung = new Sungjuk_6_5_4(); 에서 Sungjuk_6_5_2 형의 객 체 참조변수 wife_sung 에 클래스 Sungjuk_6_5_4 의 객체를 생성시켜 할당한 경우 인데 , 즉 하위 클래스에서 상위 클래스로의 형 변환은 가능하다 .

그러나 Sungjuk_6_5_4 wife_sung = new Sungjuk_6_5_2(); 처럼 상위 클래스에서 하위 클래스로의 형변환은 불가능하며 오류가 발생된다 .


[ 실습하기 6-5] 객체의 형 변환 (5/6)

93

07 행 : Sungjuk_6_5_3 yoo_sung = new Sungjuk_6_5_4(); 에서 Sungjuk_6_5_3 형의 객체 참조 변수 yoo_sung 에 클래스 Sungjuk_6_5_4 의 객체를 생성시켜 할당한 경우인 데 , 즉 하위 클래스에서 상위 클래스로의 형 변환은 가능하다 .

그러나 Sungjuk_6_5_4 yoo_sung = new Sungjuk_6_5_3(); 처럼 상위 클래스에서 하위 클래스로의 형변환은 불가능하며 오류가 발생된다 .

09, 30 행 : 클래스 객체 Sungjuk_6_5_1 은 메소드 prt_data1() 에만 접근이 가능하다 .

10, 39 행 : 클래스 객체 Sungjuk_6_5_2 은 메소드 prt_data1(), prt_data2() 에만 접근이 가능하다 .

11, 48 행 : 클래스 객체 Sungjuk_6_5_3 은 메소드 prt_data1(), prt_data2(), prt_data3() 에만 접근이 가능하다 .

12, 57 행 : 클래스 객체 Sungjuk_6_5_4 은 메소드 prt_data1(), prt_data2(), prt_data3(), prt_data4() 에 접근이 가능하다 .


[ 실습하기 6-5] 객체의 형 변환 (6/6)

94

종단 클래스 종단 클래스 (final class) 란 더 이상의 상속을 하지 않기 위하여 사용하는 클래스이다 . 메소드에 종단 (final) 이 선언되면 재정의가 불가능하고 변수에 종단 (final) 이 선언되면 수정이 불가능하게 된다 . 종단 클래스내에 있는 종단 메소드는 final 명시를 하지 않아도 묵시적으로 종단 메소드로 여긴다 . 종단 클래스의 일반 형식

Section 05 종단 클래스 (1/1)

final class 클래스명 { ... }

95

[ 실습하기 6-6] 종단 클래스 (1/5)

96

01 class Sungjuk_6_6 { 02 void title() { 03 System.out.println("*** 종단 클래스 (final class) ***"); 04 System.out.println("*** 자바의 성적 출력 ***"); 05 System.out.println("** 학번 ** ** 성명 ** **점수 **"); 06 System.out.println("---------------------------"); 07 } 08 } 09 abstract class Sungjuk_6_6_1 extends Sungjuk_6_6 { 10 String hakbun1 = "2060001"; 11 String name1 = "Ko Eung-Nam"; 12 int jumsu1 = 60; 13 abstract void prt_data1(); 14 } 15 abstract class Sungjuk_6_6_2 extends Sungjuk_6_6_1 { 16 String hakbun2 = "2060002"; 17 String name2 = "Boo Chang-Mi"; 18 int jumsu2 = 80; 19 abstract void prt_data2(); 20 } 21 abstract class Sungjuk_6_6_3 extends Sungjuk_6_6_2 { 22 String hakbun3 = "2060003";

Jv_6_6.java

[ 실습하기 6-6] 종단 클래스 (2/5)

97

23 String name3 = "Ko Yoo-Jin"; 24 int jumsu3 = 100; 25 abstract void prt_data3(); 26 } 27 class Sungjuk_6_6_4 extends Sungjuk_6_6_3 { 28 String hakbun4 = "2060004"; 29 String name4 = "Ko Su-Ji"; 30 int jumsu4 = 99; 31 public void prt_data1() { 32 System.out.println(hakbun1 + " " + name1 + " " + jumsu1); 33 } 34 public void prt_data2() { 35 System.out.println(hakbun2 + " " + name2 + " " + jumsu2); 36 } 37 public void prt_data3() { 38 System.out.println(hakbun3 + " " + name3 + " " + jumsu3); 39 } 40 public void prt_data4() { 41 System.out.println(hakbun4 + " " + name4 + " " + jumsu4); 42 } 43 } 44

Jv_6_6.java

[ 실습하기 6-6] 종단 클래스 (3/5)

98

45 final class Jv_6_6 extends Sungjuk_6_6_4 { 46 public static void main(String[] args) { 47 Sungjuk_6_6 ttt = new Sungjuk_6_6(); 48 ttt.title(); 49 Sungjuk_6_6_4 ken_sung = new Sungjuk_6_6_4(); 50 Sungjuk_6_6_4 wife_sung = new Sungjuk_6_6_4(); 51 Sungjuk_6_6_4 yoo_sung = new Sungjuk_6_6_4(); 52 Sungjuk_6_6_4 soo_sung = new Sungjuk_6_6_4(); 53 ken_sung.prt_data1(); 54 wife_sung.prt_data2(); 55 yoo_sung.prt_data3(); 56 soo_sung.prt_data4(); 57 } 58 }

Jv_6_6.java

[ 실습하기 6-6] 종단 클래스 (4/5)

99

45 행 : Jv_6_6 는 종단 클래스이며 클래스 Sungjuk_6_6_4 로부터 상속을 받은 클래스 이다 .


[ 실습하기 6-6] 종단 클래스 (5/5)

100

instanceof 연산자 instanceof 연산자란 하나의 어떤 객체가 특정한 어떤 클래스 또는 인터페이스에 의해서 생성된 객체인지 아닌지를 판단하기 위하여 사용하는 연산자이며 참인 경우에 true, 거짓인 경우에 false 를 반환한다 . instanceof 연산자의 일반 형식은 다음과 같다 .

Section 06 instanceof 연산자 (1/1)

객체명 instanceof 클래스명 또는

객체명 instanceof 인터페이스명

101

[ 실습하기 6-7] instanceof 연산자 (1/4)

102

01 class Sungjuk_6_7 { 02 void title() { 03 System.out.println("*** instanceof 연산자 ***"); 04 System.out.println("---------------------------"); 05 } 06 } 07 08 class Sungjuk_6_7_1 { 09 String hakbun; 10 String name; 11 } 12 13 class Sungjuk_6_7_2 { 14 int jumsu; 15 } 16 17 class Jv_6_7 { 18 public static void main(String[] args) { 19 Sungjuk_6_7 ttt = new Sungjuk_6_7(); 20 ttt.title(); 21 Sungjuk_6_7_1 ken = new Sungjuk_6_7_1(); 22 Sungjuk_6_7_2 boo = new Sungjuk_6_7_2();

Jv_6_7.java


103

23 if (ken instanceof Sungjuk_6_7_1) 24 System.out.println("ken 은 클래스 Sungjuk_6_7_1 의 객체임 "); 25 else 26 System.out.println("ken 은 클래스 Sungjuk_6_7_1 의 객체아님 "); 27 if (boo instanceof Sungjuk_6_7_2) 28 System.out.println("boo 는 클래스 Sungjuk_6_7_2 의 객체임 "); else 29 System.out.println("boo 는 클래스 Sungjuk_6_7_2 의 객체아님 "); 30 } 31 }

Jv_6_7.java


104

21, 23 행 : instanceof 연산자

instanceof 연산자란 하나의 어떤 객체가 특정한 어떤 클래스 또는 인터페이스에 의해서 생성된 객체인지 아닌지를 판단하기 위하여 사용하는 연산자이며 참인 경 우에 true, 거짓인 경우에 false 를 반환한다 .

ken instanceof Sungjuk_6_7_1 에서 ken 은 객체명이고 , Sungjuk_6_7_1 은 클래스명 이다 . 그러므로 참이므로 true 가 반환된다 . 그 이유는 Sungjuk_6_7_1 ken = new Sungjuk_6_7_1(); 에서 클래스 Sungjuk_6_7_1 에 의해서 객체 ken 이 생성된다 .

22, 27 행 : instanceof 연산자

boo instanceof Sungjuk_6_7_2 에서 boo 는 객체명이고 , Sungjuk_6_7_2 는 클래스명 이다 . 그러므로 참이므로 true 가 반환된다 . 그 이유는 Sungjuk_6_7_2 boo = new Sungjuk_6_7_2(); 에서 클래스 Sungjuk_6_7_2 에 의해서 객체 boo 가 생성된다 .



105

변수의 유효 범위와 형식 정의된 변수가 프로그램 내에서 참조 가능한 범위를 변수의 유효 범위 (scope rule) 라고 한다 . 그러나 접근 한정자에 의해서 범위가 바뀔 수 있다 . 멤버 변수 : 클래스 내에 메소드 밖에 선언된 변수를 가리키며 모든 멤버 변수들은 그 클래스 전체에서 유효한 범위를 갖음 메소드 지역 변수와 매개변수 : 메소드 내에서만 사용 가능한 변수 예외처리기 매개 변수 (exception handler parameter): 예외 처리 기능을 하는 catch 절 내에서 사용 가능한 변수클래스의 정의는 클래스의 선언을 이용해 표현한다 .접근 한정자는 클래스 , 멤버 변수 , 메소드에 접근을 제한할 수 있는 것으로 다른 클래스로부터 정보를 보호 , 은폐 , 캡슐화 등이 가능하다 .

Section 07 접근 한정자와 변수의 유효 범위 (1/4)

[ 클래스 접근한정자 ] class 클래스명 [extends 슈퍼클래스명 ] [implements 인터페이스명 ] { ... [ 필드 접근한정자 ] 멤버 변수 ; [ 생성자 접근한정자 ][ 생성자 ]; [ 메소드 접근한정자 ] 메소드 ; ... }

106

은닉 (Encapsulation) 은닉은 외부 사용자로부터 내부의 데이터 등의 구조를 보호하기 위하여 접근 금지 등을 하게하는 것을 말한다 . 예를 들면 private 한정자는 해당 멤버의 참조 범위를 자신의 클래스 내로 한정시킨다 .


public class Date { public int day; public int month; public int year;}public class ProcDate {....Date kkk = new Date(); kkk.day = 25;....}

public class Date { private int day; private int month;private int year; public void setDay(int d) { day = d;}}public class ProcDate {....Date kkk = new Date(); kkk.setDay(25);....}

public 접근 한정자 사용 private 접근 한정자 사용

107

접근한정자의 종류접근한정자의 종류에는 클래스 접근 한정자 , 필드 접근 한정자 , 생성자 접근 한정자 및 메소드 접근 한정자 등이 있다 .클래스 접근 한정자 (class modifier) : 클래스 접근 한정자는 클래스에 대한 정보를 제공하는 예약어이다 . 클래스 접근 한정자의 종류에는 public, abstract, final 이 있으며 public 은 abstract, final 과 같 이 사용 가능하지만 abstract 과 final 은 같이 사용될 수 없다 . 필드 접근한정자 (field modifier) : 필드 접근한정자는 멤버 변수에 관하여 정보를 제공하는 예약어이다 . 필드 접근 한정자의 종류에는 public, private, protected, static, final, transient, volatile 이있다 .생성자 접근 한정자 (constructor modifier) : 생성자 접근 한정자는 다른 클래스로부터 정보를 보호 , 은폐 , 캡슐화를 제공하는 예약어이다 . 생성자 접근 한정자의 종류에는 public, private, protected, default 가 있다 .메소드 접근한정자 (method modifier) : 메소드 접근한정자는 메소드에 관하여 정보를 제공하는 예약어이다 . 메소드 접 근 한정자의 종류에는 public, private, protected, static, final, abstract, synchronized 가 있다 .


108

클래스에서의 멤버변수 , 멤버 메소드 간의 접근 한정 관계

은닉은 외부 사용자로부터 내부의 데이터 등의 구조를 보호하기 위하여 접근 금지 등을 하게하는 것을 말한다 . 예를 들면 private 한정자는 해당 멤버의 참조 범위를 자신의 클래스 내로 한정시킨다 . 클래스에서의 멤버변수 , 멤버 메소드 간의 접근 한정 관계는 다음과 같다 .


접근 한정자 클래스 내부 같은 패키지내의 클래스 서브 클래스 다른 모든클래스

public ○ ○ ○ ○

private ○ × × ×

protected ○ ○ ○ ×

default( 공백 )또는package

○ ○ × ×

( ○: 접근가능 ×: 접근 불가능 )

109

[ 실습하기 6-8] 접근 한정자 (1/6)

110

01 class Sungjuk_6_8_1 { public String hakbun; 02 public String name; 03 public int jumsu;} 04 class Sungjuk_6_8_2 { 05 private String hakbun; 06 private String name; 07 private int jumsu; 08 public void set_hakbun(String h) { hakbun = h; } 09 public void set_name(String n) { name = n; } 10 public void set_jumsu(int j) { jumsu = j; } 11 public void dsp_all() { System.out.println(hakbun + " " + name + " " + jumsu); } } 12 class Sungjuk_6_8_3 { 13 protected String hakbun; 14 protected String name; 15 protected int jumsu; } 16 class Sungjuk_6_8_4 { 17 String hakbun; 18 String name; 19 int jumsu; } 20 class Jv_6_8 extends Sungjuk_6_8_3 { 21 public static void main(String[] args) { 22 Sungjuk_6_8_1 ken_sung = new Sungjuk_6_8_1();

Jv_6_8.java

[ 실습하기 6-8] 접근 한정자 (2/6)

111

23 ken_sung.hakbun = "2060001"; 24 ken_sung.name = "Ko Eung-Nam"; 25 ken_sung.jumsu = 60; 26 Sungjuk_6_8_2 wife_sung = new Sungjuk_6_8_2(); 27 wife_sung.set_hakbun("2060002"); 28 wife_sung.set_name("Boo Chag-Mi"); 29 wife_sung.set_jumsu(80); 30 Sungjuk_6_8_3 yoo_sung = new Sungjuk_6_8_3(); 31 yoo_sung.hakbun = "2060003"; 32 yoo_sung.name = "Ko Yoo-Jin"; 33 yoo_sung.jumsu = 100; 34 Sungjuk_6_8_4 soo_sung = new Sungjuk_6_8_4(); 35 soo_sung.hakbun = "2060004"; 36 soo_sung.name = "Ko Su-Ji"; 37 soo_sung.jumsu = 99; 38 System.out.println("****** 접근한정자 및 변수의 유효 범위 *****"); 39 System.out.println("*** 자바의 성적 출력 ***"); 40 System.out.println("** 학번 ** ** 성명 ** **점수 **"); 41 System.out.println("---------------------------------"); 42 System.out.println(ken_sung.hakbun + " " + ken_sung.name + " " + ken_sung.jumsu); 43 wife_sung.dsp_all();

Jv_6_8.java

[ 실습하기 6-8] 접근 한정자 (3/6)

112

44 System.out.println(yoo_sung.hakbun + " " + yoo_sung.name + " " + yoo_sung.jumsu); 45 System.out.println(soo_sung.hakbun + " " + soo_sung.name + " " + soo_sung.jumsu); 46 System.out.println("---------------------------------"); 47 } 48 }

Jv_6_8.java

[ 실습하기 6-8] 접근 한정자 (4/6)

113

01~03, 22, 42 행 : public

public 으로 선언된 클래스 , 변수 , 메소드는 접근을 원하는 모든 곳에서 상속 및 참조가 가능하며 가장 일반적인 접근 한정자이다 .

05~11 행 , 26~29 행 , 43 행 : private

private 으로 선언된 변수 , 메소드는 클래스 내부에서만 접근이 가능하며 , 같은 패키지 내의 클래스 , 서브 클래스 , 다른 모든 클래스에서는 접근이 허용되지 않는다 . 그러므로 접근하려면 다음과 같이 public 으로 선언된 메소드를 통하여 접근한다 .

public void set_hakbun(String h) { hakbun = h; }

public void set_name(String n) { name = n; }

public void set_jumsu(int j) { jumsu = j; }

public void dsp_all() { System.out.println(hakbun + " " + name + " " + jumsu); } }


[ 실습하기 6-8] 접근 한정자 (5/6)

114

12~15 행 , 20, 30, 44 행 : protected

protected 으로 선언된 변수 , 메소드는 클래스 내부 , 서브 클래스 , 같은 패키지 내의 클래스에서 접근이 가능하며 , 다른 모든 클래스에서는 접근이 허용되지 않는다 . class Jv_6_8 extends Sungjuk_6_8_3 에서 extends 를 이용해 Sungjuk_6_8_3 클래스의 하위 클래스로 class Jv_6_8 를 사용하므로 protected 으로 선언된 변수 , 메소드는 클래스 내부 , 서브 클래스 , 같은 패키지 내의 클래스에서 접근이 가능하다 .

17~19 행 , 34, 45 행 : default( 공백 ) 또는 package

멤버 정의시에 접근 한정자를 선언하지 않으면 자동적으로 package 로 선언된다 . package으로 선언된 변수 , 메소드는 클래스 내부 , 같은 패키지 내의 클래스에서 접근이 가능하며 , 서브 클래스 , 다른 모든 클래스에서는 접근이 허용되지 않는다 .


[ 실습하기 6-8] 접근 한정자 (6/6)

115

내부 클래스와 외부 클래스의 정의 내부 클래스 (inner class) 란 어떤 클래스 내부에 다른 클래스가 포함되어 있을 때 그 안에 포함된 클래스를 내부 클래스라하고 밖에 포함한 클래스를 외부 클래스라고 한다 . .

Section 08 내부 클래스와 외부 클래스 (1/2)

내부 클래스의 특징 내부 클래스에서 내부 클래스 밖에 있는 외부 클래스에 있는 멤버 등을 참조할 때는 내부 클래스 내에 있는 것처럼 사용하면 된다 . 외부 클래스에서 내부 클래스 안에 있는 멤버 등을 참조할 때는 단독으로 접근할 수 없고 반드시 객체를 생성시킨 후에 인스턴스를 통하여 접근 가능하다 . 내부 클래스는 정적 멤버 변수나 정적 멤버 메소드 (static 접근 한정자 ) 를 가질 수 없다 .

116

내부 클래스와 외부 클래스의 일반 형식 컴파일 시키면 외부 클래스 내에 내부 클래스가 포함되어 있을 때의 내부 클래스의 파일 명은 다음과 같은 형식으로 생성된다

Section 08 내부 클래스와 외부 클래스 (2/2)

외부클래스명 $ 내부클래스명 .class

117

[ 실습하기 6-9] 외부 클래스와 내부 클래스 (1/6)

118

01 class Sungjuk_6_9_outer { 02 String hakbun; 03 String name; int jumsu; 04 public Sungjuk_6_9_inner in; 05 public Sungjuk_6_9_outer() { 06 in = new Sungjuk_6_9_inner(); 07 } 08 public void prt_outer() { 09 System.out.println("****** 외부 클래스의 출력 *****"); 10 } 11 class Sungjuk_6_9_inner { 12 public void prt_inner() { 13 prt_outer(); 14 System.out.println("****** 내부 클래스의 출력 *****"); 15 System.out.println("*** 자바의 성적 출력 ***"); 16 System.out.println("** 학번 ** ** 성명 ** **점수 **"); 17 System.out.println("---------------------------"); 18 } } 19 } 20 21 class Jv_6_9 { 22 public static void main(String[] args) {

Jv_6_9.java


119

23 Sungjuk_6_9_outer ttt = new Sungjuk_6_9_outer(); 24 Sungjuk_6_9_outer.Sungjuk_6_9_inner kkk = ttt.in; 25 kkk.prt_inner(); 26 Sungjuk_6_9_outer ken_sung = new Sungjuk_6_9_outer(); 27 ken_sung.hakbun = "2060001"; 28 ken_sung.name = "Ko Eung-Nam"; 29 ken_sung.jumsu = 60; 30 Sungjuk_6_9_outer wife_sung = new Sungjuk_6_9_outer(); 31 wife_sung.hakbun = "2060002"; 32 wife_sung.name = "Boo Chag-Mi"; 33 wife_sung.jumsu = 80; 34 Sungjuk_6_9_outer yoo_sung = new Sungjuk_6_9_outer(); 35 yoo_sung.hakbun = "2060003"; 36 yoo_sung.name = "Ko Yoo-Jin"; 37 yoo_sung.jumsu = 100; 38 Sungjuk_6_9_outer soo_sung = new Sungjuk_6_9_outer(); 39 soo_sung.hakbun = "2060004"; 40 soo_sung.name = "Ko Su-Ji"; 41 soo_sung.jumsu = 99; 42 System.out.println(ken_sung.hakbun + " " + ken_sung.name + " " + ken_sung.jumsu);

Jv_6_9.java


120

43 System.out.println(wife_sung.hakbun + " " + wife_sung.name + " " + wife_sung.jumsu); 44 System.out.println(yoo_sung.hakbun + " " + yoo_sung.name + " " + yoo_sung.jumsu); 45 System.out.println(soo_sung.hakbun + " " + soo_sung.name + " " + soo_sung.jumsu); 46 } 47 }

Jv_6_9.java


121

01 행 : 외부 클래스 Sungjuk_6_9_outer 선언한다 .

02~03 행 : 멤버 변수 선언한다 .

04 행 : 내부 클래스 Sungjuk_6_9_inner 의 참조 변수 in 선언한다 .

05~07 행 : 내부 클래스 Sungjuk_6_9_inner 를 사용하기 위하여 객체를 생성한다 .

08~10 행 : 외부 클래스에서의 메소드 prt_outer() 를 선언한다 .

11 행 : 내부 클래스 Sungjuk_6_9_inner 를 선언한다 .

12 행 : 내부 클래스에서의 메소드 prt_inner() 선언한다 .



122

13 행 : 내부 클래스에서 외부 클래스의 메소드 prt_outer() 를 호출할 때는 prt_outer() 를 그대로 사용하면 된다 .

21 행 : 메인 클래스 Jv_6_9 를 선언한다 .

23~25 행 : 다른 클래스인 메인 클래스에서 내부 클래스 Sungjuk_6_9_inner 의 메소드 prt_inner() 를 사용하기 위해서는 외부 클래스 Sungjuk_6_9_outer 의 도움을 받고 접근 가능하다 . 여기서 컴파일 시키면 클래스가 3 개 (Jv_6_9.class, Sungjuk_6_9_outer.class, Sungjuk_6_9_outer$Sungjuk_6_9_inner.class) 가 생성된다 . 외부 클래스 내에 내부 클래스가 포함되어 있을 때의 내부 클래스의 파일명은 다음과 같은 형식으로 생성된다 .



외부클래스명 $ 내부클래스명 .class

123

다형성임의의 객체가 다른 객체를 참조할 수 있는 것을 말한다. 하나의 모습을 가지고 여러 형태로 보일 수 있는 특징이 있다. 예를 들면, “먹는다”라는 클래스에서 파생된 클래스로는 “사람이 먹는다.”, “호랑이가 먹는다.”, “양이 먹는다.” 등이 있을 수 있다. 여기서 파생된 클래스는 “먹는다”라는 상위 클래스를 가지는 특성을 지닌다. 프로그램 사용 예:

Poly_Jv_6_10 p1 = new Jv_6_10();에서는 new 키워드를 이용하여 Jv_6_10() 객체를 생성하여 객체 변수 p1에 할당한다. 이 때 객체 변수 p1은 다시 Poly_Jv_6_10이라는 특성을 가진다. 즉, 객체 변수 p1은 Jv_6_10() 객체와 Poly_Jv_6_10 객체의 2가지 특성 모두를 가질 수 있다. 그러므로 하나의 객체가 여러 형태의 특징들을 가질 수 있다.

Section 09 다형성 (Polymorphism) (1/1)

124


125

// Poly_Jv_6_10.java

01 public class Poly_Jv_6_10 {

02 String str;

03

04 public Poly_Jv_6_10() {

05 str = "== Polymorphism 1 ==";

06 }

07

08 public void print_out() {

09 System.out.println(" 다형성 1: " + str);

10 }

11 }

Jv_6_10.java


126

//Jv_6_10.java 12 public class Jv_6_10 extends Poly_Jv_6_10 { 13 public Jv_6_10() { 14 str = "Polymorphism 2"; 15 } 16 17 public void print_out() { 18 System.out.println(" 다형성 2: " + str); 19 } 20 21 22 public static void main(String[] args) { 23 Jv_6_10 p = new Jv_6_10(); 24 p.print_out(); 25 System.out.println(); 26 27 Poly_Jv_6_10 p1 = new Jv_6_10(); 28 p1.print_out(); 29 } 30 }

Jv_6_10.java


127

01~06 행 : Poly_Jv_6_10 이라는 이름을 가진 클래스이며 클래스명 앞에 한정자 public 이 있으므로 어느 클래스에서나 사용 가능하다 .

08~10 행 : Poly_Jv_6_10 이라는 이름을 가진 클래스 내에 있는 print_out 이라는 이름을 가진 메소드이다 .

23 행 : Jv_6_10 p = new Jv_6_10(); 에서는 new 키워드를 이용해 클래스 Jv_6_10() 의 객체 p 를 생성한다 .

24 행 : 객체 변수 p 에서 가지는 print_out() 메소드를 실행한다 .

27 행 : 다형성 (Polymorphism)

Poly_Jv_6_10 p1 = new Jv_6_10(); 에서는 new 키워드를 이용해 Jv_6_10() 객체를 생성하여 객체 변수 p1 에 할당한다 . 이 때 객체 변수 p1 은 다시 Poly_Jv_6_10 이라는 특성을 가진다 .

28 행 : print_out() 메소드는 Poly_Jv_6_10 클래스와 Jv_6_10 클래스 양쪽에 있지만 여기서는 Jv_6_10() 클래스의 메소드가 실행된다 .



128

멤버 변수의 상속을 나타내는 콘솔 프로그램을 작성하라

처리조건클래스 4 개를 만든다 .4 개의 클래스는 모두 상속 관계이다 . 각 클래스에 변수를 하나씩 선언하고 초기화한다 . 메인 클래스에서 나머지 클래스 3 개의 멤버변수를 상속받는다 .메인 클래스에서 마지막으로 상속받는 아들 클래스의 객체 (new) 를 생성하고 아래와 같은 결과를 보여주는 프로그램을 완성하여 보자 . 이 조건을 만족하는 프로그램을 완성하여 아래와 같은 결과를 보여라 .

129

메소드의 상속을 나타내는 콜솔 프로그램을 작성하라 .

상위 클래스를 선언하고 메소드를 정의한다 . 메소드 1

• System.out.println(" 상위클래스의 메소드 ken:" + i + " ");메소드 2

• System.out.println(" 상위클래스의 메소드 boo:" + j + " ");하위 클래스를 선언하고 메소드를 재정의 , 중복정의 , 정의한다 .

• System.out.println(" 하위클래스의 메소드 ken:" + i + "( 메소드의 재정의 :오버라이딩 )");

• System.out.println(" 하위클래스의 메소드 boo:" + j + "," + k + "( 메소드의 중복정의 : 오버로딩 )");

• System.out.println(" 하위클래스의 메소드 yoo:" + k +"( 상위클래스 없음 : 하위 클래스 존재 )");

• System.out.println(" 하위클래스의 메소드 soo:" + "( 상위클래스 없음 : 하위 클래스 존재 )")

다음을 메인 클래스에서 객체를 호출한다 . obj.ken(50); , obj.boo(3.1415f);, obj.boo(10, 20); , obj.yoo(50); , obj.soo();

130

인터페이스 및 다중 상속을 사용하는 콘솔 프로그램을 완성하라

인터페이스를 하나 만든다 . 아래와 같이 메소드를 선언한다 .public void HW(); // 핸드폰 HW, PDA HWpublic void SW(); // 핸드폰 SW, PDA SW

클래스 2 개를 만들어서 각각 인터페이스를 implements 한다 . 핸드폰 , PDA 관련 클래스

메인 클래스 선언된 2 개의 클래스를 다중 상속받는다 . 각각의 클래스로 new 를 이용하여 객체를 2 개 생성하고 아래와 같은 결과를 출력

// 인터페이스는 인터페이스내의 모든 메소드가 추상적 메소드이며 차후에 구현된다 .

131

인터페이스와 추상 클래스를 이용하여 출력하는 프로그램

Thank you

133

멤버 변수의 상속을 나타내는 콘솔 프로그램을 작성하라

처리조건클래스 ken_6_x1 에서 멤버 변수 ken 을 선언하고 10 을 초기화한다 .

• Class ken_6_x1{Int ken = 10; }

클래스 boo_6_x1 는 클래스 Ken_6_x1 로부터 상속받는다 . 여기서 멤버변수 boo 를 선언하고 20 을 초기화한다 .

• Class boo_6_x1 extends ken_6_x1{Int boo = 20; }

클래스 yoo_6_x1 는 클래스 boo_6_x1 로부터 상속받는다 . 여기서 멤버변수 yoo 를 선언하고 20 을 초기화한다 .

• Class yoo_6_x1 extends boo_6_x1{Int yoo = 20; }

클래스 soo_6_x1 는 클래스 yoo_6_x1 로부터 상속받는다 . 여기서 멤버변수 soo 를 선언하고 30 을 초기화한다 .

• Class boo_6_x1 extends ken_6_x1{Int soo = 20; }

클래스 soo_6_x1 클래스는 Ken_6_x1, boo_6_x1 , yoo_6_x1 로부터 멤버변수 ken, boo, yoo 를 상속받는다 .

Documents

개요 상속 및 확장 클래스 인터페이스 및 다중 상속 , 추상 클래스 객체의 형 변환 종단 클래스 instanceof 연산자 접근 한정자와 변수의 유효