상속(Inheritance)

부모 클래스가 가지고 있는 멤버(필드or메소드)를 자식 클래스에게 넘겨주는 것

자식은 부모를 확장한 것

다른 클래스가 가지고 있는 멤버(필드, 메소드)들을 새로 작성할 클래스에서 직접 만들지 않고 상속을 받음으로써, 새 클래스가 자신의 멤버처럼 사용할 수 있는 기능

명령어 : extends

[접근제한자] class 클래스명 extends 클래스명{}

상속 명칭

부모클래스 = 조상클래스 = 상위클래스(super class)

자식클래스 = 자손클래스 = 하위클래스(sub class)

상속 목적

1.클래스의 재사용 가능

2.공통적인 규약 정의

상속 장점

1.코드량 감소

직접 만들지않고 부모클래스를 가져다 쓰기 때문

적은 양의 코드로 클래스 작성 가능

2.코드 추가,삭제,변경 용이

부모클래스의 데이터가 공통분모가 되서 일괄변환됨

코드를 공통적으로 관리하기 때문에 코드 추가/변경 용이

3.중복 제거 → 생산성,유지보수up

상속 특징

1.모든 클래스는 Object클래스의 후손(=Object는 최상위 클래스)

    Object클래스가 제공하는 메소드를 오버라이딩하여 메소드 재구현 가능

         ex) java.lang.String 클래스의 equals()와 toString()

부모클래스로부터 멤버(필드,메소드) 받아오는 것

2.부모 클래스의 생성자, 초기화 블록은 상속 안됨

자식 클래스 생성 시, 부모 클래스 생성자가 먼저 실행

자식 클래스 생성자 안에 부모 클래스 생성자를 호출하고 싶으면 super() 활용

    - 부모클래스에 접근하는 방법 : super()

3.부모의 private멤버는 상속은 되지만 직접 접근 불가

자식 객체 생성 시에 부모의 필드 값도 전달 받은 경우, 자식 생성자 안에서 부모의 private 필드에 직접 접근하여 대입 불가

(private 접근 범위, 해당 클래스 안이기에 직접적으로는 접근 불가)

접근 하는 방법

1. super() 이용하여 전달받은 부모 필드 값을 부모 생성자 쪽으로 넘겨 생성
2. setter, getter 메소드를 이용하여 접근

*부모클래스와 자식클래스의 주소값은 다르다

(=참조하고 있지 않다는 의미. 주소값이 다르기에 )

부모클래스의 객체 주소값은 고정되어있지 않다

자식 클래스라고 해서 부모클래스가 그대로 들어가지 않는다

자바의 단일상속, 다중 상속

※ 다중 상속

C++에서 사용 가능한 기능

여러 클래스로부터 상속이 가능하며 복합적인 기능을 가진 클래스를 쉽게 생성 가능

    - 서로 다른 클래스로부터 상속받은 멤버 간의 이름이 같은 경우 문제 발생

자바에서 다중상속 불가

단일 상속만 가능. 만약 다중상속이 필요하면 단일 상속을 여러번 사용해서 구현 가능

하나의 자식에 여러 부모 불가

하나의 부모에 여러 자식 가능

화살표 : 아래에서 위로

자식이 부모를 가리키는 것

고로, 자식 클래스에서 부모클래스를 화살표가 가리켜야 한다

상속에서 쓰이는 화살표는 머리가 빈 화살표시

상속 시 딱 하나만 상속 받아오는 것

자바에서는 다중상속하지 않고 단일 상속을 지원함

why?

어느 클래스에서 받아왔는지 알기가 어려워지기 때문 단일 상속만 지원

클래스간의 관계가 다중 상속보다 명확하고 신뢰성 있는 코드 작성가능

자바에서 다중상속이 필요한 경우,

단일 상속을 여러번해서 다중상속을 표현할 수 있다

※ 해당 필드나 getter,setter가 어느 클래스에 속한지 알아볼 때 유용한 팁

대쉬 안에 있는건 어디 안에 있는 메소드인지 보여주는것

상속의 예시

Object에 있는 메소드들

어떻게 들어가 있을 수 있을까?

모든클래스는 object클래스 후손이기 때문

내가 만든 클래스(사용자 정의 클래스)도 object의 후손이기 때문에 object 안에 있는 클래스들을 다 상속 받은거고 사용할 수 있는 것

.

java.lang.Object

모든 클래스의 부모클래스

최상위 클래스라고 부른다

아래 이미지는 1번 파일을 0번 파일이 상속했다

자식 클래스 부모 클래스의 이름을 눌러보면 부모클래스와 연결되어있는 코드들의 색깔이 진해진다

이 코드들은 중복이기에 삭제하여도 부모와 자식 클래스의 정보가 연동된다

삭제 전

삭제 후

0번 parent 

1번 child1

2번 child2

상속관계가 0 -> 1 -> 2

1번이 0번을 상속하고 2번이 1번을 상속한 것

1번 child1에서 parent에 받았던 a,b부분들을 주석 처리해서 2번 child2에서 보면 정보가 그대로인 걸 알 수 있다

public class practice_everyday04 {
	public static void main(String[] args) {
		
		// run
		practice_everyday04_0 pe1 = new practice_everyday04_0();
		pe1.println();
		
		practice_everyday04_1 pe2 = new practice_everyday04_1();
		pe2.println();
		
		practice_everyday04_2 pe3 = new practice_everyday04_2();
		pe3.println();
		
	}	
}

public class practice_everyday04_0 {
	
	// Parent
	private int a;
	private int b;
	
	public practice_everyday04_0() {}
	public practice_everyday04_0(int a, int b) {
		this.a = a;
		this.b = b;
	}
	//getter & setter
	public int getA() {
		return a;
	}
	public void setA(int a) {
		this.a = a;	
	}
	public int getB() {
		return b;
	}
	public void setB(int b) {
		this.b = b;
	}
	
	
	public void println() {
		System.out.println("parent");
	}
	
}

public class practice_everyday04_1 extends practice_everyday04_0 {
		
	// child1
//	private int a;
//	private int b;
	private int c;
	
	public practice_everyday04_1() {}
	public practice_everyday04_1(int a, int b, int c) {
//		this.a = a;
//		this.b = b;
		this.c = c;
	}
	
	// getter & setter
	// setter : 데이터를 변수에 저장하는 메소드
	// getter : 저장된 데이터를 불러오는 메소드
//		public int getA() {
//			return a;
//		}
//		public void setA(int a) {
//			this.a = a;	
//		}
//		public int getB() {
//			return b;
//		}
//		public void setB(int b) {
//			this.b = b;
//		}
		public int getC() {
			return c;
		}
		public void setC(int c) {
			this.c = c;
		}
		
	@Override	
	public void println() {
		System.out.println("child1");
	}
	
}

// 상속 & overriding
public class practice_everyday04_2 extends practice_everyday04_1{
	
	// child2
	private int a;
	private int b;
	private int c;
	private int d;
	
	public practice_everyday04_2() {}
	public practice_everyday04_2(int a, int b, int c, int d) {
		this.a = a;
		this.b = b;
		this.c = c;
		this.d = d;
	}
	
	// getter & setter
		public int getA() {
			return a;
		}
		public void setA(int a) {
			this.a = a;	
		}
		public int getB() {
			return b;
		}
		public void setB(int b) {
			this.b = b;
		}
		public int getC() {
			return c;
		}
		public void setC(int c) {
			this.c = c;
		}
		public int getD() {
			return d;
		}
		public void setD(int d) {
			this.d = d;
		}
	@Override
	public void println() {
		System.out.println("child2");
	}
		

	
	
		
}

// 상속 & overriding
class Parents {
	public String doo() {
		return "parents doo";
	}
}
class children extends Parents {
	public String dont() {
		return "children dont";
	}
	//Overriding
	public String doo() {
		System.out.println(super.doo());	// super.
		return "children doo";
	}
}
public class practice_everyday04 {
	public static void main(String[] args) {
		
	Parents one = new Parents();
	one.doo();
	
	children two = new children();
	two.dont();
	two.doo();
//	System.out.println(one);		// 인스턴스one 바로 호출하면 메모리 주소값 출력
									// 객체를 호출하면 디폴트값으로 객체명과 메모리주소를 반환
	System.out.println(one.doo());  // 인스턴스.메소드() 호출해야 return값 반환
	System.out.println(two.dont());
	System.out.println(two.doo());
	}
}

상속(Inheritance)의 생성자(Contructor)

Cal 클래스가 생성자가 있다고하면 어떻게 될지 보자

class Cal1111 {
	int v1,v2;				  	      // 정수 데이터타입 세팅
	Cal1111(int v1, int v2) { 	// 생성자 
		this.v1 = v1; this.v2 = v2;
		//매개변수에 들어온 값
	}
}
class Cal3333 extends Cal1111{    // error 발생
}
public class Inheritance05 {
	public static void main(String[] args) {
		
		Cal1111 c1 = new Cal1111(2,1); // new cal() 안에 입력값 2,1입력
		Cal3333 c3 = new Cal3333();
	}
}

위와 같이 코드를 작성하니 아래와 같이 에러가 발생했다

오리지널 클래스(cal)을 제대로 계승했다면, Cal이 인스턴스로 만들어질 때 반드시 해야되는 일들이 생성자에 들어있다. 때문에 이 생성자를 Cal3도 실행시켜야만 제대로 작동한다

자식 클래스에서 부모클래스를 계승 받아 실행하게 될 때, 반드시 부모클래스의 생성자를 실행하도록 규칙을 만들어 놓은 것.

아래의 코드를 실행할 경우

부모클래스인 cal1에서 println() 한번 : Cal init!!!

자식클래스인 cal3에서 println() 두번 : Cal init!!! & Cal3 init!!!

자식클래스인 cal3에서 super(v1, v2);가 부모클래스 생성자를 실행키는데 이 코드가 부모코드의 println()을 한번 더 실행켜서 cal 한번 cal3 자체에서 한번 더 실행되서 총 두번이 출력되는 것

class Cal1111 {
	int v1,v2;				  	// 정수 데이터타입 세팅
	Cal1111(int v1, int v2) { 	// 생성자 
		this.v1 = v1; this.v2 = v2;
		//매개변수에 들어온 값
		System.out.println("Cal init!!!");
	}
}
class Cal3333 extends Cal1111{  // extends : Cal1을 상속
	Cal3333(int v1, int v2) {
		**super**(v1, v2);	// **super**=부모클래스. 즉,부모클래스의 생성자를 실행시킴. 
						// 부모클래스의 생성자는 아래와 같다
						// Cal1111(int v1, int v2) {
						// 		this.v1 = v1; this.v2 = v2;
	System.out.println("Cal3 init!!!");
	}
}
public class Inheritance05 {
	public static void main(String[] args) {
		// new cal() 안에 입력값 2,1 새로 입력
		Cal1111 c1 = new Cal1111(2,1); // 출력 : 클래스cal1에서 println() 한번만 출력 
		Cal3333 c3 = new Cal3333(2,1); // 출력 : super(v1, v2); 이 문구가 
									   // 클래스cal1에서 println() 한번 출력시키고
									   // 클래스cal3에서 println() 한번 출력시켜 두번출력
	}
}

전체코드

상속과 관련된 중요 키워드

this는 자기 자신

super는 자신의 부모

cal3클래스의 sum메소드는 부모클래스인 cal의 sum메소드를 오버라이딩하고 있음

이 코드가 엄청나게 복잡한 코드였다면 같은 기능의 코드를 중복해서 쓰는 낭비가 많았을 것

class Cal111 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	public int sum(int v1, int v2, int v3) { // 같은 이름 메소드 // int v3 추가
		return v1+v2+v3;
	}
}
class Cal333 extends Cal11{		// extends : Cal1을 상속
	public int minus(int v1, int v2) {
		return v1-v2;			// Cal3는 이제 부모 클래스가 없는 마이너스 기능도 탑재
	}
	public int sum(int v1, int v2) {
		System.out.println("Cal3!!");
		return v1+v2;
	}
}

이럴 때 계승 발전 시키면 매우 유리할 것

자식 클래스의 메소드(sum)가 부모 클래스의 메소드(sum)를 호출하고 그 결과를 이용할 수 있다면 편리할 것. 이때 쓰는 것이 super

super.

자식 클래스의 메소드가 부모 클래스의 메소드를 호출하고 그 결과를 이용하는 것

super.부모클래스의 메소드명;

public int sum(int v1, int v2){
		return super.sum(v1,v2);
}

super가 잘 작동하는지 체크해보고 싶다면?

브레이크포인트 걸고 디버깅 해볼 것

this.

class Cal111 {
	// this
	// 자기 자신을 뜻함
	public int sum(int v1, int v2, int v3) { 
		return this.sum(v1,v2)+v3;	    // .sum() 자기자신
	}
}

전체코드

// Java 상속 - 4. this & super

class Cal111 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	// this
	// 자기 자신을 뜻함
	public int sum(int v1, int v2, int v3) { // 같은 이름 메소드 // int v3 추가
		return this.sum(v1,v2)+v3;	// .sum() 자기자신
	}
}
class Cal333 extends Cal11{		// extends : Cal1을 상속
	public int minus(int v1, int v2) {
		return v1-v2;			// Cal3는 이제 부모 클래스가 없는 마이너스 기능도 탑재
	}
	
	// super
	// 부모를 뜻함
	public int sum(int v1, int v2) {
		System.out.println("Cal3!!");
		return super.sum(v1,v2);	// .sum()은 부모클래스 sum()
	}
}

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

		Cal111 c1 = new Cal111();
		System.out.println(c1.sum(2,1));
		System.out.println(c1.sum(2,1,1));
		
		Cal333 c3 = new Cal333();
		System.out.println(c3.sum(2,1));
		System.out.println(c3.minus(2,1));	// 자식클래스에 추가된 minus기능
		
	}
class Cal222 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	public int minus(int v1, int v2) {
		return v1-v2;
	}
}
}

오버라이딩(Overriding)

부모가 가진 기능을 재정의(수정, 추가 등)하는 것을 오버라이딩(Overriding)

오버로딩(Overloading)

과적하다 의미. 상속과 관련x

부모클래스도 자식클래스도 오버로딩 가능. 자식 클래스는 부모 클래스를 오버라이딩, 오버로딩 둘 다 가능

자바는 형태만 다르면 같은 이름의 메소드를 같은 클래스 내에서도 여러개 사용 가능

ex)

class Cal11 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	public int sum(int v1, int v2, int v3) { // 같은 이름 메소드 // int v3 추가
		return v1+v2+v3;
	}
}

전체코드

// Java 상속 - 2. 기능의 개선과 발전

class Cal11 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	public int sum(int v1, int v2, int v3) { // 같은 이름 메소드 // int v3 추가
		return v1+v2+v3;
	}
}
class Cal33 extends Cal11{		// extends : Cal1을 상속
	public int minus(int v1, int v2) {
		return v1-v2;			// Cal3는 이제 부모 클래스가 없는 마이너스 기능도 탑재
	}
	public int sum(int v1, int v2) {
		System.out.println("Cal3!!");
		return v1+v2;
	}
}
public class Inheritance02 {

	public static void main(String[] args) {

		Cal11 c1 = new Cal11();
		System.out.println(c1.sum(2,1));
		System.out.println(c1.sum(2,1,1));
		
		Cal33 c3 = new Cal33();
		System.out.println(c3.sum(2,1));
		System.out.println(c3.minus(2,1));	// 자식클래스에 추가된 minus기능
		
		
	}
class Cal22 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	public int minus(int v1, int v2) {
		return v1-v2;
	}
}
}

우리의 관심사

어떻게하면 자식 클래스가 부모 클래스가 가지고 있지 않은 새로운 기능을 추가할 것인가?

또 부모 클래스가 가지고 있는 기능을 덮어쓰기(수정) 할 것인가?

기능 추가

오리지널 Cal의 sum기능을 복사해서 Cal3에 넣고 minus로 변경

Cal3는 이제 부모 클래스가 없는 마이너스 기능도 탑재

 class Cal33 extends Cal11{		// extends : Cal1을 상속
	public int minus(int v1, int v2) {
		return v1-v2;			// Cal3는 이제 부모 클래스가 없는 마이너스 기능도 탑재
	}
}

Cal33 c3 = new Cal33();
System.out.println(c3.sum(2,1));
System.out.println(c3.minus(2,1));	// 자식클래스에 추가된 minus기능

오리지널의 기능 수정 가능?

가능

오리지널의 sum에 프린트기능 추가 수정해서 cal3에서 써보자

class Cal33 extends Cal11{		// extends : Cal1을 상속
	public int minus(int v1, int v2) {
		return v1-v2;			// Cal3는 이제 부모 클래스가 없는 마이너스 기능도 탑재
	}
	public int sum(int v1, int v2) {
		System.out.println("Cal3!!");
		return v1+v2;    // 부모가 가진 기능을 재정의(수정)
	}
}

오버라이딩(Overriding)

부모가 가진 기능을 재정의하는 것을 오버라이딩(Overriding)

전체코드

// Java 상속 - 2. 기능의 개선과 발전

class Cal11 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
}
class Cal33 extends Cal11{		// extends : Cal1을 상속
	public int minus(int v1, int v2) {
		return v1-v2;			// Cal3는 이제 부모 클래스가 없는 마이너스 기능도 탑재
	}
	public int sum(int v1, int v2) {
		System.out.println("Cal3!!");
		return v1+v2;
	}
}
public class Inheritance02 {

	public static void main(String[] args) {

		Cal11 c1 = new Cal11();
		System.out.println(c1.sum(2,1));
		
		Cal33 c3 = new Cal33();
		System.out.println(c3.sum(2,1));
		System.out.println(c3.minus(2,1));	// 자식클래스에 추가된 minus기능
		
		
	}
class Cal22 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	public int minus(int v1, int v2) {
		return v1-v2;
	}
}
}

상속을 배우기 위해 계산기 클래스가 필요

class Cal {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
}
public class Inheritance01 {

	public static void main(String[] args) {

		Cal c = new Cal();
		System.out.println(c.sum(2,1));		
	}

}

추가로 마이너스 기능을 넣고 싶다면?

일 잘하는 사람은 sum()메소드를 복사해서 새 클래스를 생성

class Cal1 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
}
class Cal2 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	public int minus(int v1, int v2) {
		return v1-v2;
	}
}
public class Inheritance01 {

	public static void main(String[] args) {

		Cal1 c = new Cal1();
		System.out.println(c.sum(2,1));
		
		
		
	}

}

오리지널인 클래스 Cal1의 버그나 업데이트 했다고하면 오리지널과 같은 기능을 가지고 있는 Cal2 및 다른 여러 클래스들은 똑같이 반영이 안되기 때문에 일일히 수많은 코드를 수정해야한다

또한 같은 내용의 코드도 굉장히 많아질 것

코드가 1억줄이라면 각기 다른 클래스의 같은 내용의 메소드를 쉽게 알아보기가 매우 어려울 것

 -이때 우리가 유용하게 쓸 수 있는 것이 상속(Inheritance)

상속(Inheritance)이란?

어떤 클래스가 가지고 있는 변수와 메소드를 확장해서 상속해서 다른 클래스가 갖도록 하는 것

상속의 장점

1. 코드의 재사용성up
2. 유지보수 편의성 up
3. 가독성 up
4. 코드의 양 down

부모클래스(=superClass)

자식클래스(=subClass)

전체코드

// Java 상속 - 1. 수업소개 : 상속의 정의 & 장점

class Cal1 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
}
class Cal3 extends Cal1{		// extends : Cal1을 상속
	
}
public class Inheritance01 {
	public static void main(String[] args) {

		Cal1 c1 = new Cal1();
		System.out.println(c1.sum(2,1));
		
		Cal3 c3 = new Cal3();
		System.out.println(c3.sum(2,1));
		
		
	}
class Cal2 {
	public int sum(int v1, int v2) {
		return v1+v2;
	}
	public int minus(int v1, int v2) {
		return v1-v2;
	}
}
}

<클래스와 인스턴스 & 객체지향 이후 공부할 것>

1. 상속(inheritance)
2. 인터페이스(Interface)
3. 패키지(package)

1.상속inheritance

class Parent{
		public void method1() {
			// ...
		}
}

Q.위에서 저 클래스를 직접 수정할 수 없거나 변경하지 말아야하는 상황에서 method2()를 추가하고 싶다면?

A.저 클래스 전체를 카피해서 이름 다른 클래스로 해서 method2()를 추가

이 방법은 class parent의 method1의 코드 개선, 버그 해결 등을 하게 되면 이 method1을 카피한 수많은 모든 코드를 다 수정해야함. 일 산더미...?

이 문제 개선을 위해 자바에서 제공하는 기능이 상속

extends를 붙여서 상속표시

class Child extends Parent{
		public void method2() {
				// ... 
		}
}

Child라는 클래스에는 실제로는 method1이 구현되어 있지 않지만, 상속 받았기에 class Parent에 있기에 class Child에서도 사용 가능해짐

 - class parent 코드가 수정되면, 동시에 다른 자식 클래스에도 다 같이 수정된다

2.인터페이스(Interface)

interface contract {
		public String method1(String param);
		public int method2(int param);
}

원래 인터페이스에는 메소드의 이름, 파라미터와 리턴값의 형식은 적으나 실제 내용은 적지 않는다

class Concreate1 implements Contract {

}

위 코드 의미

Concreate1 이라는 클래스는 Contract 라는 인터페이스에 적혀있는 메소드들의 형식을 구현했다 or 구현해야한다는 의미

이 상태로 Concreate1 클래스를 컴파일하면 컴파일조차 안된다

 - 규칙위반 때문

 - Contract에 적혀 있는 메소드들을 정의해야한다는 규칙을 어겼기 때문

implements에 contract를 적어놓게 되면 class Concreate1은 interface의 contract에 적혀있는 형태의 메소드를 구체적으로 구현해야하는 책임을 갖는다

class Concreate1 implements Contract{
		public String method1(String param) {
				return "foo";
		}
		public int method2(int param) {
				return 1;
		}
}
// 클래스 콘크리트1 안에 내용이 메소드1의 내용으로 채워짐

마찬가지로 class Concreate2

Concreate1과 Concreate2는 서로 다른 클래스이지만 확신할 수 있는 것은,

이 클래스들은 반드시 contract에 약속되어 있는 정의되어있는 형태의 멤버들을 구현하고 있을 것이라는 것. 일종의 무언의 약속

3.패키지(package)

클래스 이름은 같지만 기능이 다른 두 클래스가 존재할 수 있다

ex)서로 다른 디렉토리에 있는 경우, 한 컴퓨터 안에 같은 이름의 파일이 여러개 존재할 수 있는 것

클래스도 서로 다른 패키지에 묶여있으면 같은 이름의 클래스가 공존 가능

많아진 클래스를 정리정돈의 도구로써 사용되는 것이 패키지

패키지보다 더 큰 정리정돈의 도구는 자바에서는 없다

JAVA1 - 13.5. 자바 문서 보는 법 - 상속(inheritance)

JAVA API 문서

PrintWriter클래스를 만든 사람은 처음부터 다 만들고 싶지 않아서 Writer클래스에서 상속받아 PrintWriter클래스를 만들었고 Writer클래스를 만든 사람은 마찬가지로 Object클래스를 상속받아 더 쉽게 Writer클래스를 만든 것

*자바에서는 변수를 필드라고 함 (Field = variable)

※ 이클립스에서 상속관계(hierarchy) 보는 방법

[보기 원하는 클래스 위에 우클릭] - [Open tpye Hierarchy 클릭(F4) ]

Object 아래 toString도 있고 Writer도 있음

Object 아래 상속 Writer 아래 상속 PrintWriter가 상속

PrintWriter클래스를 쓰면 같은 부모 Object 아래 상속 되었기에, Object 아래있는 다른 클래스인 toString도 같이 사용가능

자바의 모든 클래스는 Object클래스를 반드시 상속받음

누군가가 Writer라고 하는 어떤 취지를 가진 클래스를 만드는데 필수이기도 하고

Object기능을 사용하기도해서 Object를 상속 받는데 이때 사용하는 키워드가 extends

즉, Object를 확장(extends)해서 Writer 클래스를 만들었다는 뜻

마찬가지로, PrintWriter클래스도 Writer 클래스를 확장(extends)해서 만든 것

PrintWriter p1 = new PrintWriter("result 1");
p1.toString()

PrintWriter의 인스턴스(P1)을 만들고 이 인스턴스에 .toString()이라고 하게되면

이 상태에서 toString()이 오브젝트에 있다고 하면, 자바가 어떻게 동작하는가?

 - PrintWriter클래스에 toString이 있는지 보고 없으면 extends가 가리키는 Writer를 찾아보고 없으면 extends가 가리키는 Object를 찾아본다. 없으면 에러가 나고 있으면, toString() 메소드를 실행

Writer클래스는 String을 받는 write클래스( write(String) : void  )가 정의되어 있다

PrintWriter클래스에서도 String을 받는 write클래스( write(String) : void  )가 정의되어 있다

 - 즉, Writer클래스에도 write메소드가 있는데 Writer클래스를 상속 받는 PrintWriter클래스에도 write메소드가 있는 것. 다시말해, 덮어쓰기(overriding) 한 것

위의 상태에서 write()메소드는 누구의 write 메소드일까?

 - PrintWriter클래스의 write(String) : void를 사용하는 것

덮어쓰기(Override)란?

PrintWriter클래스를 만든 사람이 Writer클래스의 write()메소드가 마음에 들지 않거나 취지에 맞지 않는다면 부모클래스의 메소드를 사용하지않고 자식클래스(자신)의 write()메소드를 사용하는데, 이를 덮어쓰기(overriding) 한다고한다

<JAVA API 보는법>

Tree 탭

클래스 간 상속관계(Hierarchy)를 볼 수 있는 탭

자바가 기본적으로 제공하는 표준 라이브러리들이 서로 간에 어떤 상속관계를 가지고 있는지 보여준다.

정점에는 역시 Object. 페이지 상단에 위치

자바에서 변수를 필드라 부름

필드=변수

※ 위의 Fields Summary 의미 ※

위의 lock이라고 하는 변수(필드)가 Writer()클래스에 정의되어있고 상속받아서 PrintWriter()도 lock이라는 필드(변수)를 사용할 수 있다는 의미

Object클래스로부터 상속받았기 때문에 위의 메소드들은 다 사용할 수 있다는 의미