[Java]객체지향 (2) - 상속,참조변수, 오버라이딩, 패키지

상속

상속 ( Inheritance )

- 기존의 클래스로 새로운 클래스를 작성하는 것. ( 코드의 재사용 )

- 두 클래스를 부모와 자식으로 관계를 맺어주는 것.

class 자식클래스 extends 부모클래스 {
	// ...
}

이렇게 자식 클래스 옆에 extends를 사용해 부모 클래스를 입력해주면 상속관계가 된다.

- 자손은 조상의 모든 멤버를 상속받는다. ( 생성자, 초기화 블록 제외 )

자손과 조상를 사용하는 이유는 부모의 부모 것도 상속을 받기 때문이다.

- 자손의 멤버 개수는 조상보다 적을 수 없다. ( 같거나 많다. )

class Parent {
	int age;
}

class Child extends Parent { }

Child 클래스는 멤버가 0개처럼 보이지만 사실 멤버가 1개이다.

부모의 age 변수를 상속받고 있기 때문에 부모의 멤버 또한 자식의 멤버이기 때문이다.

- 자손의 변경은 조상에 영향을 미치지 않는다.

자식의 멤버가 추가되어도 부모의 멤버는 변함이 없다.

 

포함 ( composite ) 이란?

- 클래스의 멤버로 참조 변수를 선언하는 것

class Circle {
	int x; // 원점의 x좌표
    int y; // 원점의 y좌표
    int r; // 반지름 (radius)

위 코드를 포함관계의 코드로 변환하면 다음과 같다.

class Point {
	int x;
    int y;
}

class Circle {
	Point c = new Point(); // 원점
    int r; // 반지름 (radius)
}

- 작은 단위의 클래스를 만들고, 이 들을 조합해서 클래스를 만든다.

 

상속관계	'~은 ~이다. (is - a)'
포함관계	'~은 ~을 가지고 있다. (has-a)'

상속과 포함 무엇을 사용해야 할지 헷갈린다면 내용을 해석해보면 된다.

원 (Circle)은 점(Point)이다. - Circle is a Point
원 (Circle)은 점(Point)을 가지고 있다. - Circle has a Point

원은 점을 가지고 있다 라는 말이 더 적합한 말이므로 포함관계를 사용해주는 게 적합하다.

포함으로 x값을 접근하려면 P가 가리키는 객체를 통해 접근을 하기 때문에 c.p.x를 통해 참조가 가능하다.

 

단일 상속 ( Single Inheritance )

- Java는 단일 상속만을 허용한다. ( C++은 다중 상속 허용 )

class TvDVD extends Tv,DVD {  →  Error 조상은 하나만 허용된다.
	// ,,,
}

 

 

인터페이스(interface)를 사용하지않고도 다중 상속처럼 편리하게 작성하는 방법도 있다.

- 비중이 높은 클래스 하나만 상속관계로, 나머지는 포함관계로 한다.

 

Object클래스 - 모든 클래스의 조상

- 부모가 없는 클래스는 자동적으로 Object클래스를 상속받게 된다.

- 모든 클래스는 Object클래스에 정의된 11개의 메서드를 상속받는다.

toString(), equals(Object obj), hashCode(), ...

 

오버라이딩 ( overriding )

- 상속받은 조상의 메서드를 자신에 맞게 변경하는 것

class Point {
	int x;
    int y;
    
    String getLocation() {
    	return "x : " + x + ", y: " + y;
    }
}

class Point3D extends Point {
	int z;
    
    String getLocation() {  →  오버라이딩
    	return "x : " + x + ", y: " + y + ", z : " + z;
    }
}

부모 클래스의 메서드인 getLocation메서드를 자식 클래스인 Point 3D에서 오버라이딩하여 내용을 변경하였다.

오버라이딩은 선언부는 변경이 불가능하고 내용만 변경이 가능하다.

오버라이딩의 조건
1. 선언부가 조상 클래스의 메서드와 일치해야 한다. ( 반환 타입 , 메서드 이름 , 매개변수 목록 )
2. 접근 제어자를 조상 클래스의 메서드보다 좁은 범위로 변경할 수 없다.
3. 예외는 조상 클래스의 메서드보다 많이 선언할 수 없다.

 

오버로딩 vs 오버라이딩
오버로딩 ( overloading ) → 기존에 없는 새로운 메서드를 정의하는 것 ( new )
오버라이딩 ( overriding ) → 상속받은 메서드의 내용을 변경하는 것 ( change , modify )

오버로딩과 오버라이딩은 이름만 비슷하지 많이 다르다.

오버로딩은 기존에 없는 이름이 같은 새로운 메서드를 정의하는 것이고 ,

오버라이딩은 상속받은 메서드의 기존의 것을 변경하는 것이다.

class Parent {
	void parentMethod() {}
}

class Child extends Parent {
	void parentMethod() {} → 1.오버라이딩
    void parentMethod(int i) {} → 2.오버로딩
    
    void childMethod() {} → 3.메서드 정의
    void childMethod(int i) {} → 오버로딩
    void childMethod() {} → 중복정의 (Error)

---

참조변수

참조변수 super 

- 객체 자신을 가리키는 참조변수. 인스턴스 메서드(생성자) 내에만 존재

- 조상의 멤버를 자신의 멤버와 구별할 때 사용

class Test {
	public static void main(String args[]) {
		Child c = new Child();
		c.method();
	}
}

class Parent { int x=10; }

class Child extends Parent {
	int x=20;

	void method() {
		System.out.println("x=" + x); → 20
		System.out.println("this.x=" + this.x); → 20
		System.out.println("super.x="+ super.x); → 10
	}
}

이렇게 같은 이름의 변수 x가 부모와 자식의 클래스 모두 있다면 super와 this로 구별이 가능하다.

class Test2 {
	public static void main(String args[]) {
		Child2 c = new Child2();
		c.method();
	}
}

class Parent2 { int x=10; }

class Child2 extends Parent2 {
	void method() {
		System.out.println("x=" + x); → 10
		System.out.println("this.x=" + this.x); → 10 
		System.out.println("super.x="+ super.x); → 10
	}
}

만약 부모에게만 변수 x가 존재한다면 x , this.x , super.x 모두 10을 호출한다.

 

super() - 조상의 생성자

- 조상의 생성자를 호출할 때 사용

- 조상의 멤버는 조상의 생성자를 호출해서 초기화

class Point {
	int x,y;
    
    Point(int x , int y) {
    	this.x = x;
    	this.y = y;
    }
}    

class Point3D extends Point {
	int z;
    
    Point3D(int x, int y, int z) {
    	super(x,y);  →  조상클래스의 생성자 Point(int x,int y)를 호출
        this.z = z;  →  자신의 멤버를 초기화
    }
}

위 예제를 확인하면 자식 클래스인 Point3D의 생성자가 부모의 생성자를 호출해서 초기화하였다.

결론적으로 자식의 생성자에서 조상의 생성자를 초기화할때 super()을 사용한다.

 

- 생성자의 첫 줄에 반드시 생성자를 호출해야 한다.
  그렇지 않으면 컴파일러가 생성자의 첫 줄에 super();를 삽입

---

패키지

패키지 ( package )

- 서로 관련된 클래스의 묶음

- 클래스는 클래스 파일(*.class), 패키지는 폴더. 하위 패키지는 하위 폴더

- 클래스의 실제 이름(full name)은 패키지를 포함. (java.lang.String)

  rt.jar는 클래스들을 압축한 파일(JDK설치경로 \jre\lib에 위치)

 

패키지의 선언

- 패키지는 소스파일의 첫 번째 문장으로 단 한번 선언

- 같은 소스 파일의 클래스들은 모두 같은 패키지에 속하게 된다.

- 패키지 선언이 없으면 이름없는(unnamed = default package) 패키지에 속하게 된다.

 

클래스 패스 ( classpath )

- 클래스 파일(*,class)의 위치를 알려주는 경로(path)

- 환경변수 classpath로 관리하며, 경로간의 구분자는 ';'를 사용

  classpath(환경변수)에 패키지의 루트를 등록해줘야 함.

 

import문

- 클래스를 사용할 때 패키지이름을 생략할 수 있다.

class ImportTest {
	java.util.Date today = new java.util.Date();
    // ...
}

원래는 이렇게 클래스이름에 패키지이름을 같이 적어주어야 한다.

import java.util.Date;

class ImportTest {
	Date today = new Date();
}

하지만 이렇게 import문을 사용해주면 생략이 가능하다.

 

- 컴파일러에게 클래스가 속한 패키지를 알려준다.

[ 이클립스 단축키 ctrl + shift + o ]

 

- java.lang 패키지( 기본 패키지 ) 의 클래스는 import하지 않고도 사용할 수 있다.

 

import문의 선언

- import문을 선언하는 방법은 다음과 같다.

import 패키지명.클래스명; ← ctrl + shift + o
	or
import 패키지명.*; ← 모든 클래스

- import문은 패키지문과 클래스선언의 사이에 선언한다.

① 패키지 선언
② import문
③ 클래스 정의

- import문은 컴파일 시에 처리되므로 프로그램의 성능에 영향이 없다.

import java.util.Calendar;
import java.util.Date;
import java.util.ArrayList;

↑
↓

import java.util.*; → java.util패키지의 모든 클래스

- 이름이 같은 클래스가 속한 두 패키지를 import할 때는 클래스 앞에 패키지명을 붙여줘야 한다.

import java.sql.*; → java.sql.Date;
import java.util.*; → java.util.Date;

public class ImportTest {
	public static void main(String[] args) {
    java.util.Date today = new java.util.Date();
    }
}

 

 

static import문

- static멤버를 사용할 때 클래스 이름을 생략할 수 있게 해준다.

import static java.lang.Integer.*;  →  Integer클래스의 모든 static메서드
import static java.lang.Math.random;  →  Math.random()만. 괄호 안붙임.
import static java.lang.System.out;  →  System.out을 out만으로 참조가능

위와 같이 선언을 하면

out.println(random());

으로도 호출이 가능하다.

import static java.lang.System.out;
import static java.lang.Math.*;

class Test {
	public static void main(String[] args) {	
		// System.out.println(Math.random());
		out.println(random());

		// System.out.println("Math.PI :"+Math.PI);
		out.println("Math.PI :" + PI);
	}
}