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

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

2. 6장. 상속, 인터페이스, 은닉 및 다형성 • 학습목표 • 하나의 클래스에서 이를 확장하여 새로운 클래스를 만들어 가는 과정인 상속에 대해서 학습한다. • 클래스의 골격만 정의하는 인터페이스와 여러 부모를 갖는 다중 상속에 대해서 학습한다. • 객체의 형 변환, 종단 클래스, instanceof 연산자 등에 대해서 학습한다. • 접근 한정자와 변수의 유효 범위, 내부 클래스와 외부 클래스 임의의 객체가 다른 객체를 참조할 수 있는 다형성 등에 대해서 학습한다.

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

4. 상속의 개요 • OOP[object-oriented programming, oop]의 주요 특성인 모듈의 재사용과 코드의 간결성 제공 • 상속의 개념을 이용하여 클래스의 계층구조 구성 • JDK에서 제공되는 클래스로부터 상속 받아 자바 프로그램 작성 • 자바에서의 모든 클래스는 상위 클래스를 가진다 • 자바 프로그램의 최상위 클래스는 java.lang.Object 클래스이다. • 상위 클래스를 지정하기 위해 “extends” 키워드 사용

5. 상속의 개요 • 상속이 포함된 클래스 선언 형식 [public/final/abstract] class 클래스이름 extends상위클래스이름 { .......... // 멤버변수선언 .......... // 생성자 .......... // 메소드선언 }

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의 값은 1 objc객체의 객체속성변수 bb의 값은 2 objc객체의 객체속성변수 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. 예약어 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. 메소드 상속과 오버라이딩 • 오버로딩(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 { • public static void main(String args[]) { • 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.java • class 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. 상속과 생성자 • 상속된 클래스로부터 객체가 생성될 때 상위 클래스의 생성자가 하위 클래스의 생성자보다 먼저 수행 • 상위 클래스의 묵시적인 생성자(매개변수가 없는)가 수행 • 묵시적인 생성자가 아닌 다른 생성자를 호출(오버로딩의 경우)하고자 한다면 예약어 super를 사용하여 명시적으로 호출 • super 문장은 반드시 첫번째 라인에 와야 한다.

18. Constructors1.java • class 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.java • class 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 { • public static void main(String args[]) { • A2 super2 = new A2(10,20); • System.out.println("10의 제곱은 : " + super2.d1); • System.out.println("20의 제곱은 : " + super2.d2); • }}

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. 객체의 형변환 • 앞의 프로그램을 다음과 같이 수정 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. 객체의 형변환 • 앞의 프로그램을 반대로 다음과 같이 수정 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.java • class 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. 추상 클래스와 추상 메소드 • 추상 클래스 • 하위 클래스에서 구현될 추상적인 기능만을 추상 메소드로 선언 • 추상 메소드는 기능이 무엇(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 { • public static void main(String args[]) { • 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. 예약어 final • final을 3가지 용도로 사용 • 상수로 사용될 객체 속성 변수 • 메소드에 final을 붙이면 하위 클래스에서 오버라이딩 할 수 없다 • 클래스에 final을 붙여 하위 클래스를 가지지 못하게 한다 • final을 사용하는 이유 • 보안과 설계부분을 명확하게 하기 위해

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

28. 인터페이스의 개요와 인터페이스 정의 • 인터페이스 개요 • 상수와 메소드 선언(=추상메소드)만을 가진다 • 다중 상속의 기능을 제공 • 클래스가 다른 클래스로부터 상속을 받고 있는 상태에서 다른 요소들의 상속이 요구될 때 인터페이스를 사용 • 인터페이스 정의 public interface 인터페이스이름 [extends 인터페이스이름, .....] { ..... // 상수선언 ..... // 메소드 선언 }

29. 인터페이스 정의 - 예 public interface Sleeper { public long ONE_SECOND = 1000; public long ONE_MINUTE = 60000; public void wakeup(); }

30. 인터페이스의 사용 • 클래스 생성시 인터페이스를 사용하기 위해 “implements”예약어 사용 • 인터페이스를 사용하여 생성된 클래스는 인터페이스에 선언된 모든 메소드를 오버라이딩하여 구현 하여야 한다 • 인터페이스를 사용하는 클래스의 구문 형태 [public/final/abstract] class 클래스이름 extends 상위클래스이름 implements 인터페이스이름[, 인터페이스이름, .....] { .... // 멤버변수선언 .... // 생성자 .... // 메소드선언 // 인터페이스에 선언된 모든 메소드를 오버라이딩하여 선언 }

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. 인터페이스의 상속 • 인터페이스도 클래스와 같이 상속될 수 있다 • 인터페이스 상속시 예약어 extends사용 public interface 인터페이스이름 extends 인터페이스이름[, 인터페이스 이름,....] { 상수선언 메소드 선언 }

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.java interface 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. 인터페이스 참조 • 인터페이스도 클래스처럼 형변환이 가능 • 인터페이스 타입의 객체 참조 변수에 인터페이스를 포함하는 클래스의 객체를 할당 • 클래스와 마찬가지로 인터페이스 타입의 객체 참조변수를 통하여는 인터페이스에 선언된 속성만 접근 가능

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.java interface 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. 연산자 instanceof • 객체가 특정 클래스나 인터페이스로부터 생성된 객체인지를 판별해주는 관계 연산자(표4-4) • 형식 객체참조변수 instanceof type

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

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

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. 사용자 패키지의 작성 및 사용 • 사용자가 작성한 클래스를 패키지로 만들어 사용할 수 있다 • 작성된 클래스를 패키지로 지정하기 위해서는 프로그램의 첫 라인에 다음과 같이 지정하여야 한다 package package-name; • CLASSPATH 환경 변수를 설정

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

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)

49. 다중 상속 자바에서의 상속은 하나의 클래스에서 이 클래스를 확장하여 새로운 클래스를 만들어 나가는 과정을 말한다. 여러 개의 클래스를 확장할 수 있는 것이 아니라 단일 상속(single inheritance) 으로 확장된다. 단, 인터페이스의 개념을 사용하면 자바에서 허용되지 않는 다중 상속이 가능하게 된다. Section 02상속 및 확장 클래스(2/3) • this 예약어 • 어떤 클래스가 존재할 때 그 클래스 내에서 자기 자신을 가리키는 예약어이다. 이것을 사용하면 멤버 변수나 메소드 명을 명확히 구분   할 수 있다.  • this를 사용하는 경우는 일반적으로 생성자나 메소드의 매개변수가 클래스 내의 객체 변수명과 동일한 이름을 사용하는 경우에 사용된다. 만일 생성자나 메소드의 매개변수가 클래스 내의 객체 변수명과   동일한 이름이 아닌 경우에는 this를 사용하지 않아도 된다

50. super 예약어 어떤 클래스가 존재할 때 그 상위 클래스를 가리키는 예약어이다. 이것을 사용하면 멤버 변수나 메소드 명을 명확히 구분할 수 있다. super를 사용하는 경우는 일반적으로 생성자나 메소드의 매개변수가 상위 클래스 내의 객체 변수명과 동일한 이름을 사용하는 경우에 사용된다. Section 02상속 및 확장 클래스(3/3) • 메소드의 재정의 • 메소드의 재정의(overriding)란 상위 클래스와 하위 클래스가 생성되어 존재할 때그 각각 안에 동일한 이름의 메소드가 있을 때 상위 클래스로부터 하위 클래스로 상속되는 메소드는 무시되고 하위 클래스에 있는 메소드가 적용되는 것을 말한다. private, final 메소드는 재정의가 불가능하다.