자바의 정석 6장: 객체지향 개념 1

Back-End/Java

자바의 정석 6장: 객체지향 개념 1

챔🐻 2024. 1. 23. 18:20

[ 출처 ]
자바의 정석:
https://product.kyobobook.co.kr/detail/S000001550352
자바의 정석 유튜브:
https://www.youtube.com/playlist?list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp

1. 객체지향 언어

<객체지향 언어의 주요 특징>

1) 코드의 재사용성이 높다.

2) 코드의 관리(유지보수)가 용이하다.

3) 신뢰성이 높은 프로그래밍을 가능하게 한다.

→ 재사용성, 유지보수, 중복된 코드의 제거

2. 클래스와 객체

클래스의 정의 : 객체를 정의해 놓은 것, 객체의 설계도

클래스의 용도 : 객체를 생성하는데 사용

객체의 정의 : 실제로 존재하는 것. 사물 또는 개념

유형의 객체 : 책상, 의자, 자동차, TV와 같은 사물

무형의 객체 : 수학공식, 프로그램 에러와 같은 논리나 개념

<클래스와 객체의 관계>

클래스와 객체는 제품 설계도와 제품과의 관계라고 비유할 수 있다.

클래스	객체
제품 설계도	제품
붕어빵 기계	붕어빵
TV 설계도	TV

TV설계도는 TV라는 제품을 정의한 것이며 TV를 만드는데 사용된다.

우리가 TV를 보기 위해서는, TV(객체)가 필요한 것이지 TV설계도(클래스)가 필요한 것은 아니다.

TV설계도는 단지 TV라는 제품(객체)을 만드는 데만 사용될 뿐이다.

그리고 TV설계도를 통해 TV가 만들어진 후에야 사용할 수 있다.

3. 객체의 구성요소 - 속성과 기능

객체는 속성과 기능의 집합이다. 객체가 가지고 있는 속성과 기능을 그 객체의 멤버(구성원, member)라 한다.

속성	크기, 길이, 높이, 색상, 볼륨, 채널 등	→ 변수
기능	켜기, 끄기, 볼륨 높이기, 볼륨 낮추기, 채널 변경하기 등	→ 메서드

객체지향 프로그래밍에서는 속성과 기능을 각각 변수와 메서드로 표현한다.

class Tv {
	// [속성] -> [변수]
	String color; // 색깔
	boolean power; // 전원상태
	int channel; // 채널

	// [기능] -> [메서드]
	void power() {
		power = !power;
	}

	void channelUp() {
		channel++;
	}

	void channelDown() {
		channel--;
	}

}

4. 객체와 인스턴스

인스턴스화(instantiate) : 클래스로부터 객체를 만드는 과정

인스턴스(instance) : 어떤 클래스로부터 만들어진 객체

Tv클래스로부터 만들어진 객체를 Tv클래스의 인스턴스라고 한다. 결국 인스턴스와 객체는 같은 의미지만,

객체는 모든 인스턴스를 대표하는 포괄적인 의미를 갖고 있으며, 인스턴스는 어떤 클래스로부터 만들어진 것인지를 보다 강조하는 의미를 갖고 있다.

예를 들면 ‘책상은 인스턴스다.’라고 하기 보다는 ‘책상은 객체다’라는 쪽이,

‘책상은 책상 클래스의 객체이다’라고 하기 보다는 ‘책상은 책상 클래스의 인스턴스다’라고 하는 것이 더 자연스럽다.

5. 한 파일에 여러 클래스 작성하기

하나의 소스파일에 하나의 클래스만을 정의하는 것이 보통이지만, 하나의 소스파일에 둘 이상의 클래스를 정의하는 것도 가능하다.

<주의해야할 점>

소스파일의 이름은 public class의 이름과 일치해야 한다. 만일 소스파일 내에 public class가 없다면, 소스파일의 이름은 소스파일 내의 어떤 클래스의 이름으로 해도 상관없다.

소스파일(*.java)과 달리 클래스파일(*.class)은 클래스마다 하나씩 만들어지므로 하나의 java파일에 두 개의 클래스가 정의되어 있다면 두 개의 클래스파일이 생성된다.

6. 객체의 생성과 사용

Tv클래스를 선언한 것은 Tv설계도를 작성한 것에 불과하므로, Tv인스턴스를 생성해야 제품(Tv)을 사용할 수 있다.

→ 인스턴스는 참조변수를 통해서만 다룰 수 있다.

클래스명 변수명;         // 클래스에 객체를 참조하기 위한 참조변수를 선언
변수명 = new 클래스명(); // 클래스의 객체를 생성 후, 객체의 주소를 참조변수에 저장

Tv t;                // Tv클래스의 참조변수 t를 선언
t = new Tv();        // Tv인스턴스를 생성 후, 생성된 Tv인스턴스의 주소를 t에 저장
t.channel = 7;       // Tv인스턴스의 멤버변수 channel의 값을 7로한다.

7. 객체의 생성과 사용 예제

같은 클래스로부터 생성되었을지라도 각 인스턴스의 속성(멤버변수)은 서로 다른 값을 유지할 수 있으며, 메서드의 내용은 모든 인스턴스에 대해 동일하다.

8. 객체배열

객체도 배열로 다루는 것이 가능하다. 이를 ‘객체 배열'이라고 한다.

그렇다고 객체 배열 안에 객체가 저장되는 것이 아니고, 객체의 주소가 저장된다. 사실 객체 배열은 참조변수들을 하나로 묵은 참조변수 배열인 것이다.

Tv tv1, tv2, tv3;

→

Tv[] tvArr = new Tv[3];

길이가 3인 객체 배열 tvArr을 아래와 같이 생성하면, 각 요소는 참조변수의 기본값인 null로 자동 초기화된다. 그리고 이 객체 배열은 3개의 객체, 정확히는 객체의 주소를 저장할 수 있다.

그림에서 알 수 있듯이 객체 배열을 생성하는 것은 그저 객체를 다루기 위한 참조변수들이 만들어진 것일 뿐, 아직 객체가 저장되지 않았다. 객체를 생성해서 객체 배열의 각 요소에 저장하는 것을 잊으면 안 된다.

Tv tvArr = new Tv[3];

tvArr[0] = new Tv();
tvArr[1] = new Tv();
tvArr[2] = new Tv();

----------------------------------------------

Tv[] tvArr = { new Tv(), new Tv(), new Tv() };

9. 클래스의 정의(1) - 데이터와 함수의 결합

<프로그래밍적인 관점에서 클래스의 정의와 의미>

❕

1. 변수 : 하나의 데이터를 저장할 수 있는 공간

2. 배열 : 같은 종류의 여러 데이터를 하나의 집합으로 저장할 수 있는 공간

3. 구조체 : 서로 관련된 여러 데이터를 종류에 관계없이 하나의 집합으로 저장할 수 있는 공간

4. 클래스 : 데이터와 함수의 결합(구조체 + 함수)

그동안 데이터와 함수가 서로 관계가 없는 것처럼 데이터는 데이터끼리, 함수는 함수끼리 따로 다루어져왔지만, 사실 함수는 주로 데이터를 가지고 작업을 하기 때문에 많은 경우에 있어서 데이터와 함수는 관계가 깊다.

그래서 자바와 같은 객체지향언어에서는 변수(데이터)와 함수를 하나의 클래스에 정의하여 서로 관계가 깊은 변수들을 정의하고 함수들을 함게 다룰 수 있게 했다.

서로 관련된 변수들을 정의하고 이들에 대한 작업을 수행하는 함수들을 함께 정의한 것이 바로 클래스이다. C언어에서는 문자열을 문자의 배열로 다루지만, 자바에서는 String이라는 클래스로 문자열을 다룬다. 문자열을 단순히 문자의 배열로 정의하지 않고 클래스로 정의한 이유는 문자열과 문자열을 다루는데 필요한 함수들을 묶기 위해서이다.

10. 클래스의 정의(2) - 사용자 정의 타입

사용자 정의 타입(user-defined type) : 프로그래밍 언어에서 제공하는 기본 자료형(primitive type)외에 프로그래머가 서로 관련된 변수들을 묶어서 하나의 타입으로 새로 추가하는 것

자바와 같은 객체지향 언어에서는 클래스가 곧 사용자 정의 타입이다. 기본형의 개수는 8개로 정해져있지만 참조형의 개수가 정해져 있지 않은 이유는 이처럼 프로그래머가 새로운 타입을 추가할 수 있기 때문이다.

11. 선언위치에 따른 변수의 종류

변수의 종류	선언위치	생성시기
클래스 변수 (class variable)	클래스 영역	클래스가 메모리에 로드될 때
인스턴스 변수 (instance variable)	클래스 영역	인스턴스가 생성되었을 때
지역변수 (local variable)	클래스 영역 이외의 영역 (메서드, 생성자, 초기화 블럭 내부)	변수 선언문이 수행되었을 때

인스턴스 변수(instance variable) - 클래스 영역에 선언되며, 인스턴스를 생성할 때 만들어진다. 그래서 인스턴스 변수(iv)의 값을 읽어 오거나 저장하려면 먼저 인스턴스를 생성해야한다. 인스턴스마다 별도의 저장공간을 가지므로 서로 다른 값을 가질 수 있다. 인스턴스마다 고유한 상태를 유지해야하는 속성의 경우, 인스턴스 변수로 선언한다.

클래스 변수(class variable) - 클래스 변수를 선언하는 방법은 인스턴스 변수(iv) 앞에 static을 붙이기만 하면 된다. 인스턴스마다 독립적인 저장공간을 갖는 인스턴스 변수와는 달리 클래스 변수는 모든 인스턴스가 공통된 저장공간(변수)을 공유하게 된다. 한 클래스의 모든 인스턴스들이 공통적인 값을 유지해야하는 속성의 경우, 클래스 변수로 선언해야 한다.
+) 클래스 변수를 사용할 때는 Card.width와 같이 ‘클래스이름.클래스변수’의 형태로 하는 것이 좋다. 참조변수 c1, c2를 통해서도 클래스 변수를 사용할 수 있지만 이렇게 하면 클래스 변수를 인스턴스 변수로 오해하기 쉽기 때문이다.

지역변수(local variable) - 메서드 내에 선언되어 메서드 내에서만 사용 가능하며, 메서드가 종료되면 소멸되어 사용할 수 없게된다. for문 또는 while문의 블럭 내에 선언된 지역변수는, 지역변수가 선언된 블럭 { } 내에서만 사용 가능하며, 블럭 { }을 벗어나면 소멸되어 사용할 수 없게 된다.

+) iv는 인스턴스가 생성될 때마다 생성되므로 인스턴스마다 각기 다른 값을 유지하지만 cv는 모든 인스턴스가 하나의 저장공간을 공유하므로, 항상 공통된 값을 갖는다.

14. 메서드란?

메서드(method) : 특정 작업을 수행하는 일련의 문장들을 하나로 묶은 것. → 명령문 묶은 것

수학의 함수와 유사

어떤 값을 입력하면 이 값으로 작업을 수행해서 결과 반환

블랙박스(black box)
- 내부적으로 어떤 과정을 거쳐 결과를 만들어내는지 전혀 몰라도됨. 입력과 출력만 알면 된다.
- println()이나 random()과 같은 메서드들 역시 내부적으로 어떻게 동작하는지 몰라도 사용하는데 아무런 어려움이 없었다.

메서드는 ‘선언부(header, 머리)’와 ‘구현부(body, 몸통)’로 이루어져있다.

반환타입 메서드이름(타입 변수명, 타입 변수명, ...) { // 선언부
	// 메서드 호출 시 수행될 코드                  // 구현부 
}

int add(int a, int b) { // 선언부
	int result = a + b;   // 구현부
	retrun result;
}

15. 메서드의 선언부

메서드의 선언부는 후에 변경사항이 발생하지 않도록 신중이 작성해야한다. 메서드의 선언부를 변경하게 되면, 그 메서드가 호출되는 모든 곳이 함께 변경되어야 하기 때문이다.

22. 호출스택(call stack)

<호출스택의 특징>

메서드가 호출되면 수행에 필요한 만큼의 메모리를 스택에 할당받는다.

메서드가 수행을 마치고나면 사용했던 메모리를 반환하고 스택에서 제거된다.

호출스택의 제일 위에 있는 메서드가 현재 실행 중인 메서드이다.

아래에 있는 메서드가 바로 위의 메서드를 호출한 메서드이다.

23, 24. 기본형 매개변수, 참조형 매개변수

기본형 매개변수 : 변수의 값을 읽기만 할 수 있다.(read only)

참조형 매개변수 : 변수의 값을 읽고 변경할 수 있다.(read & write)

25. 참조형 반환타입

모든 참조형 타입의 값은 ‘객체의 주소'이므로 그저 정수값이 반환되는 것일 뿐 특별할 것이 없다.

class Data3 { int x; }

class Ex6_8 {
	public static void main(String[] args) {
		Data3 d = new Data3();
		d.x = 10;

		Data3 d2 = copy(d);
		System.out.println("d.x = " + d.x);
		System.out.println("d2.x = " + d2.x);
	}

	static Data3 copy(Data3 d) {
		Data3 tmp = new Data3();
		tmp.x = d.x;

		return tmp;
	}
}

26. static 메서드와 인스턴스 메서드

어느 경우에 static을 사용해서 클래스 메서드로 정의해야하는 것일까?

iv를 사용하지 않을 경우 메서드에 static을 붙이는 것을 고려해 볼 수 있다.

28. static을 언제 붙어야 할까?

클래스를 설계할 때, 멤버변수 중 모든 인스턴스에 공통으로 사용하는 것에 static을 붙인다.
- 생성된 각 인스턴스는 서로 독립적이기 때문에 각 인스턴스 변수(iv)는 서로 다른 값을 유지한다. 그러나 모든 인스턴스에서 같은 값을 유지해야 하는 변수는 static을 붙여서 클래스변수로 정의해야 한다.

클래스 변수(static 변수)는 인스턴스를 생성하지 않아도 사용할 수 있다.
- static이 붙은 변수(클래스변수)는 클래스가 메모리에 올라갈 때 이미 자동적으로 생성되지 때문이다.

클래스 메서드(static 메서드)는 인스턴스 변수를 사용할 수 없다.
- 인스턴스 변수는 인스턴스가 반드시 존재해야만 사용할 수 있는데, 클래스 메서드(static이 붙은 메서드)는 인스턴스 생성 없이 호출 가능하므로 클래스 메서드가 호출되었을 때 인스턴스가 존재하지 않을 수도 있다.
  반면에 인스턴스 변수나 인스턴스메서드는 static이 붙은 멤버들을 사용하는 것이 언제나 가능하다. 인스턴스 변수가 존재한다는 것은 static변수가 이미 메모리에 존재한다는 것을 의미하기 때문이다.

메서드 내에서 인스턴스 변수를 사용하지 않는다면, static을 붙이는 것을 고려한다.
- 메서드의 작업내용 중에서 iv를 필요로 한다면, static을 붙일 수 없다. 반대로 iv를 필요로 하지 않는다면 static을 붙이자. 메서드 호출시간이 짧아지므로 성능이 향상된다. static을 안 붙인 메서드(인스턴스 메서드)는 실행 시 호출되어야 할 메서드를 찾는 과정이 추가적으로 필요하기 때문에 시간이 더 걸린다.

💡

- 클래스의 멤버변수 중 모든 인스턴스에 공통된 값을 유지해야하는 것이 있는지 살펴보고 있으면, static을 붙여준다.

- 작성한 메서드 중에서 인스턴스 변수나 인스턴스 메서드를 사용하지 않는 메서드에 static을 붙일 것을 고려한다.

30. 오버로딩(overloading)

한 클래스 내에 같은 이름의 메서드를 여러 개 정의하는 것

조건 : 매개변수의 개수, 타입이 달라야 한다.

오버로딩의 대표적인 예 : println()

PrintStream클래스에는 어떤 종류의 매개변수를 저장해도 출력할 수 있도록 아래와 같이 10개의 오버로딩된 println메서드를 정의해놓고 있다.

void println()
void println(boolean x)
void println(char x)
void println(char[] x)
void println(double x)
void println(float x)
void println(int x)
void println(long x)
void println(Object x)
void println(String x)

println 메서드를 호출할 때 매개변수로 넘겨주는 값의 타입에 따라서 위의 오버로딩된 메서드들 중의 하나가 선택되어 실행되는 것이다.

32. 생성자(constructor)

<정의>

생성자 : 인스턴스 초기화 메서드

<특징>

생성자의 이름은 클래스의 이름과 같다

생성자는 리턴 값이 없다.
→ 생성자도 메서드이기 때문에 리턴값이 없다는 의미의 void를 붙여야 하지만, 모든 생성자가 리턴값이 없으므로 void를 생략할 수 있게 한 것

<정의 방법>

클래스이름(타입 변수명, 타입 변수명, ...) {
	// 인스턴스 생성 시 수행될 코드,
	// 주로 인스턴스 변수의 초기화 코드를 적는다.
}

class Point {
	Point() { // 매개변수가 없는 생성자.
		...
	}

	Point(int x, int y) { // 매개변수가 있는 생성자.
		...
	}
}

<주의 해야할 것>

연산자 new가 인스턴스를 생성하는 것이지 생성자가 인스턴스를 생성하는 것이 아니다.

생성자는 단순히 iv의 초기화에 사용되는 조금 특별한 메서드일 뿐임.

33. 기본 생성자(default constructor)

모든 클래스에는 반드시 하나 이상의 생성자가 정의되어 있어야 한다.

그러나 지금까지 클래스에 생성자를 정의하지 않고도 인스턴스를 생성할 수 있었던 이유는 컴파일러가 제공하는 ‘기본 생성자(default constructor)’ 덕분이었다.

컴파일 할 때, 소스파일(*.java)의 클래스에 생성자가 하나도 정의되지 않은 경우 컴파일러는 자동적으로 아래와 같은 내용의 기본 생성자를 추가하여 컴파일한다.

클래스이름() {} // 기본 생성자
Point() {}   // Point 클래스의 기본 생성자

+) 특별히 인스턴스 초기화 작업이 요구되어지지 않는다면 생성자를 정의하지 않고 컴파일러가 제공하는 기본 생성자를 사용하는 것도 좋다.

// 예제
class Data_1 {
    int value;
}

class Data_2 {
    int value;

    Data_2(int x) { // 매개변수가 있는 생성자
        value = x;
    }
}

class Ex6_11 {
    public static void main(String[] args) {
        Data_1 d1 = new Data_1();
        Data_2 d2 = new Data_2(); // compile error 발생
    }
}

위 예제를 컴파일하면 에러가 발생한다. The constructor Data_2() is undefined 라는 내용의 에러메시지인데, Data_2 클래스에 생성자 Data_2()가 정의되어 있지 않기 때문에 에러가 발생한 것이다.

Data_1에는 정의되어있는 생성자가 하나도 없으므로 컴파일러가 기본 생성자를 추가해주었지만, Data_2에는 이미 생성자 Data_2(int x)가 정의되어 있으므로 기본 생성자가 추가되지 않있기 때문이다.

컴파일러가 자동적으로 기본 생성자를 추가해주는 경우는 ‘클래스 내에 생성자가 하나도 없을 때’뿐이라는 것을 명심해야한다.

Data_1 d1 = new Data_1();
Data_1 d2 = new Data_2();

→

Data_1 d1 = new Data_1();
Data_1 d2 = new Data_2(10);

이 예제에서 컴파일 에러가 발생하지 않도록 하기 위해서는 위의 오른쪽 코드와 같이 Data_2 클래스의 인스턴스를 생성할 때 생성자 Data_2(int x)를 사용하던가, 아니면 Data_2 클래스에 생성자 Data_2()를 추가로 정의해주면 된다.

💡

기본 생성자가 컴파일러에 의해 추가되는 경우는 클래스에 정의된 생성자가 하나도 없을 때 뿐이다.

34. 매개변수가 있는 생성자

Car c = new Car();
c.color = "white";
c.gearType = "auto";
c.door = 4;

→


Car c = new Car("white", "auto", 4);

위의 양쪽 코드 모두 같은 내용이지만, 오른쪽의 코드가 더 간결하고 직관적이다. 이처럼 클래스를 작성할 때 다양한 생성자를 제공함으로써 인스턴스 생성 후에 별도로 초기화를 하지 않아도 되게 하는 것이 바람직하다.

36. 생성자에서 다른 생성자 호출하기 - this()

💡

<생성자에서 다른 생성자를 호출할 때의 규칙>
1. 생성자의 이름으로 클래스 이름 대신 this를 사용한다.
2. 한 생성자에서 다른 생성자를 호출할 때는 반드시 첫 줄에서만 호출이 가능하다.

Car(String color) {
	door = 5;              // 첫 번째 줄
	Car(color, "auto", 4); // 에러1. 생성자의 두 번째 줄에서 다른 생성자 호출
												 // 에러2. this(color, "auto", 4);로 해야함
}

생성자에서 다른 생성자를 첫 줄에서만 호출이 가능하도록 한 이유는 생성자 내에서 초기화 작업도중에 다른 생성자를 호출하게 되면, 호출된 다른 생성자에 내에서도 멤버변수들의 값을 초기화할 것이므로 다른 생성자를 호출하기 이전의 초기화 작업이 무의미해질 수 있기 때문이다.

Car() {
	color = "white";
	gearType = "auto";
	door = 4;
}

→


Car {
	this("white", "auto", 4);
}

같은 클래스 내의 생성자들은 일반적으로 서로 관계가 깊은 경우가 많아서 이처럼 서로 호출하도록 하여 유기적으로 연결해주면 더 좋은 코드를 얻을 수 있다. 그리고 수정이 필요한 경우에 보다 적은 코드만을 변경하면 되므로 유지보수가 쉬워진다.

37. 객체 자신을 가리키는 참조변수 - this

Car(String c, String g, int d) {
	color = c;
	gearType = g;
	door = d;
}

→

Car(String color, String gearType, int door) {
	// this.color는 iv, color는 lv
	this.color = color;
	this.gearType = gearType
	this.door = door;
}

오른쪽 코드에서처럼 생성자의 매개변수로 선언된 변수의 이름이 color로 인스턴스 변수 color와 같을 경우에는 이름만으로는 두 변수가 서로 구별이 안 된다. 이런 경우에는 인스턴스 변수 앞에 ‘this’를 사용하면 된다.

💡

this 인스턴스 자신을 가리키는 참조변수, 인스턴스의 주소가 저장되어 있다.

인스턴스 메서드에 지역변수로 숨겨진 채로 존재한다.

this(), this(매개변수) 생성자, 같은 클래스의 다른 생성자를 호출할 때 사용한다.

+) this와 this()는 비슷하게 생겼을 뿐 완전히 다름. this는 ‘참조변수'이고 this()는 ‘생성자'이다.

38. 변수의 초기화

💡

멤버변수(클래스 변수와 인스턴스 변수)와 배열의 초기화는 선택이지만, 지역변수의 초기화는 필수이다.

<각 타입의 기본값(default value)>

자료형	기본값
boolean	false
char	‘\u0000’
byte, short, int	0
long	0L
float	0.0f
double	0.0d 또는 0.0
참조형	null

39. 멤버변수의 초기화

💡

1. 클래스 변수(cv) → 인스턴스 변수(iv)
2. 자동 초기화 → 명시적 초기화(간단) → 초기화 블럭, 생성자(복잡)

명시적 초기화(explicit initialization)

변수를 선언과 동시에 초기화하는 것

class Car {
	int door = 4;            // 기본형(primitive type) 변수의 초기화
	Engine e = new Engine(); // 참조형(reference type) 변수의 초기화
}

초기화 블럭(initialization block)

클래스 초기화 블럭 : 클래스 변수의 복잡한 초기화에 사용된다.

인스턴스 초기화 블럭 : 인스턴스 변수의 복잡한 초기화에 사용된다.

초기화 블럭을 작성하려면, 인스턴스 초기화 블럭은 단순히 클래스 내에 블럭 {} 만들고 그 안에 코드를 작성하기만 하면 된다. 그리고 클래스 초기화 블럭은 인스턴스 초기화 블럭 앞에 단순히 static을 덧붙이기만 하면 된다.

// 예제 6-14
class Ex6_14 {
    static {
        System.out.println("static { } "); // 클래스 초기화 블럭
    }

    {
        System.out.println("{ }"); // 인스턴스 초기화 블럭
    }

    public Ex6_14() {
        System.out.println("생성자");
    }

    public static void main(String[] args) {
        System.out.println("Ex6_14 bt = new Ex6_14();");
        Ex6_14 bt = new Ex6_14();

        System.out.println("Ex6_14 bt2 = new Ex6_14();");
        Ex6_14 bt2 = new Ex6_14();
    }
}

<실행결과>
static { }
Ex6_14 bt = new Ex6_14();
{ }
생성자
Ex6_14 bt2 = new Ex6_14();
{ }
생성자

예제가 실행되면서 Ex6_14이 메모리에 로딩될 때, 클래스 초기화 블럭이 가장 먼저 수행되어 ‘static {}’이 화면에 출력된다. 그 다음에 main메서드가 수행되어 Ex6_14의 인스턴스가 생성되면서 인스턴스 초기화 블럭이 먼저 수행되고, 끝으로 생성자가 수행된다.

위의 실행결과에서도 알 수 있듯이 클래스 초기화 블럭은 처음 메모리에 로딩될 때 한번만 수행되었지만, 인스턴스 초기화 블럭은 인스턴스가 생성될 때마다 수행되었다.

// 예제 6-15
class Ex6_15 {
    static int[] arr = new int[10];

    static {
        for(int i = 0 ; i < arr.length; i++) {
            // 1과 10사이의 임의의 값을 배열 arr에 저장한다.
            arr[i] = (int)(Math.random() * 10) + 1;
        }
    }

    public static void main(String[] args) {
        for(int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d] : %d\n", i, arr[i]);
        }
    }
}

명시적 초기화를 통해 배열 arr을 생성하고, 클래스 초기화 블럭을 이용해서 배열의 각 요소들을 random()을 사용해서 임의의 값으로 채우도록 했다.

이처럼 배열이나 예외처리가 필요한 초기화에서는 명시적 초기화만으로는 복잡한 작업을 할 수 없다. 이런 경우에 추가적으로 클래스 초기화 블럭을 사용하도록 한다.

<실행결과>
arr[0] : 1
arr[1] : 2
arr[2] : 7
arr[3] : 6
arr[4] : 4
arr[5] : 8
arr[6] : 8
arr[7] : 8
arr[8] : 7
arr[9] : 5

Uploaded by N2T