[CH06] 객체지향프로그래밍1 (OOP)

본 포스팅은 자바의 정석 교재를 공부하며, 간단히 정리/기록 용도로 작성하였습니다. 혹여, 잘못된 내용이 있다면 지적해주시면 감사하겠습니다.

 

  기술이 발전할 수록 프로그램의 규모가 커지고 사용자들의 요구가 빠르게 변화해나가는 상황을 절차적 언어로는 해결하기 어려웠으며, 이에 대한 대안으로 객체지향언어를 이용한 개발방법론이 대두되었다. 객체 지향 언어는 코드 간 서로 관계를 맺어주어 유기적으로 프로그램을 구성할 수 있다. 객체 지향 언어의 특징은 아래와 같다.

 

  ●  코드의 재사용성이 높다.

      :  새로운 코드를 작성할 때 기존 코드를 이용하여 쉽게 작성할 수 있다.

  ●  코드의 유지보수가 용이하다.

      :  코드 간의 관계를 이용하여 적은 노력으로도 쉽게 코드를 수정할 수 있다.

  ●  신뢰성이 높은 프로그래밍이 가능하다.

      :  제어자/메서드를 활용하여 데이터를 보호하고 올바른 값을 유지하도록 해서 코드의 중복을 제거하여 코드의 불일치로부터 발생하는 오동작을 방지할 수 있다.

 

  상속, 다형성과 같은 객체지향개념을 받아들일 때,  코드의 재사용성 / 유지보수 / 중복된 코드의 제거와 같이 3 가지 관점에서 바라보면 보다 쉽게 이해할 수 있다. 

---

클래스와 객체

  클래스란 객체의 설계도/틀이라고 정의할 수 있으며 객체를 생성하기 위해 사용한다. 객체는 가지고 있는 기능/속성에 따라서 용도가 다르며, 클래스에 정의된 내용대로 메모리에 생성된 것이라고 생각하자. 클래스와 객체의 관계는 설계도와 제품 간의 관계를 생각하면 된다. 잘 만들어놓은 설계도가 있으면 제품의 품질은 상당히 보장되기 마련이다. JDK 에서는 프로그래밍을 위해 많은 JAVA API 를 제공하고 있으며 이를 이용하여 원하는 기능을 설계할 수 있다.

 

객체와 인스턴스

  클래스로부터 객체를 만드는 과정은 클래스의 인스턴스화(instantidate)라고 한다. 이러한 클래스로부터 만들어진 객체를 클래스의 인스턴스(instance)라고 한다. 인스턴스와 객체는 같은 의미이기 때문에 엄격히 구분할 필요는 없지만 클래스에서 인스턴스화 시킨 객체를 보통 인스턴스라고 한다.

 

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

  객체는 일반적으로 다수의 속성과 다수의 기능을 가진다. 객체는 속성과 기능의 집합이며 객체가 가지고 있는 속성 및 기능을 객체의 멤버(member)라고 한다. 클래스는 객체의 설계도이므로 객체의 모든 속성 및 기능이 정의되어 있으며 클래스로부터 생성한 객체는 클래스로부터 기능과 속성을 부여받는 것이다. 속성과 기능을 나타내는 용어는 아래와 같이 다양하게 존재한다.

 

속성(property) : 멤버변수(member variable), 특성(attribute), 필드(field), 상태(state)

기능(function) : 메서드(method), 함수(function), 행위(behavior)

 

classs TV{
///////////////////////////////////  속성
  String color;
  boolean power;
  int channnel;

///////////////////////////////////  기능
  void power()  { power = !power; }
  void channelUp()  { channel ++; }
  void channelDown() { channel -- ; }

}

인스턴스의 생성 및 사용

  클래스를 선언한 것은 제품의 설계도를 작성한 것에 불과하며, 인스턴스를 생성해야 제품을 사용할 수 있다. 클래스로부터 인스턴스를 만드는 방법은 여러 가지가 있지만 아래의 방식이 대표적이다.

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

class Tv{
    String color;
    boolean power;
    int channel;
    
    void power() { power = !power;}
    void channelUp() { ++channel;}
    void channelDown() { --channel;}
}

class TvSet{
    public static void main(String[] args) {
        Tv t;  // TV 인스턴스를 참조하기 위한 변수 t 를 선언한 것
        t = new Tv(); // TV 인스턴스를 생성한 것
        t.channel = 7; // 멤버변수의 값을 7로 한 것
        t.channelDown(); // 메서드를 호출한 것
        System.out.println("현재 채널은 " + t.channel + " 입니다.");
    }
}

Tv t ;

라고 하면 Tv 클래스 타입을 가지는 참조 변수 t 를 선언한 것으로, 메모리에 참조 변수 t 를 위한 공간이 마련되고, 아직 인스턴스가 생성된것은 아니므로 이를 이용해서 아무것도 할 수 없다.

 

이어서,

t = new Tv() ;

라고 하면 new operator 에 의해서 Tv class 의 인스턴스가 memory 의 빈 공간에 생성되며, 멤버 변수는 각 자료형에 해당하는 기본값으로 초기화된다. 그리고 대입 연산자에 의해 생성된 객체의 주소 값이 참조 변수인 t 에 저장되며, 이제부터 t 를 이용하여 Tv 인스턴스에 접근이 가능해진다. ( 인스턴스를 다루기 위해서 반드시 참조변수가 필요하다. )

 

t.channel = 7;

과 같이 멤버 변수에 접근할 수 있으며,

 

t.channelDown();

으로 참조변수 t 가 참조하고 있는 Tv 인스턴스의 메서드인 channelDown 을 호출할 수 있다.

 

인스턴스는 참조 변수를 통해서만 다룰 수 있는 것이고 참조 변수의 타입은 인스턴스의 타입과 일치해야 한다.

 

만약에 Tv 인스턴스를 t1, t2 로 총 2개를 선언한 다음 t2 = t1 을 수행한다면 어떻게 될까.

 

  Tv t1  = new Tv(); 와 Tv t2 = new Tv(); 에서 참조변수 t1, t2 는 각각의 인스턴스의 주소를 저장한다. 이때 t2 = t1 을 수행하면 t2 가 가지고 있던 인스턴스의 주소값은 잃어버리게 되고 t1 에 저장되어 있던 인스턴스의 주소값이 t2 에 저장된다. 이와 같이 자신을 참조하고 있는 참조 변수가 하나도 없는 인스턴스가 발생하면, 가비지 컬렉터 (Garbage Collector) 에 의해 자동으로 메모리가 제거된다.

  참조 변수에는 하나의 값만이 저장될 수 있어서 두개 이상의 참조 변수가 하나의 인스턴스를 참조하는 것은 가능하지만 하나의 참조 변수로 둘 이상의 인스턴스를 가리킬 수는 없다.

 

객체 배열

  여러 개의 객체를 다루어야 하는 상황에서 객체를 배열로 다룰 수 있다. 배열 안에 객체가 저장되는 것은 아니고, 주소가 저장되며 객체 배열은 참조변수들을 배열의 형태로 묶어놓은 참조 변수 배열이라고 할 수 있다. 

Tv tv1, tv2, tv3;            ->     Tv[ ] tvArr  =  new Tv[3];

  위와 같이 객체 배열을 정의하면 각각의 원소들은 참조 변수의 디폴트값인 null 로 초기화되며, 객체 배열을 생성해놓고 객체 배열의 각 요소에 객체의 참조 변수를 저장하는 것을 잊지 않도록 유의하자. 

 

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

// 혹은
Tv[ ] tvArr = new Tv[100] ;
for(int i = 0 ; i < tvArr.length; i ++) {
    tvArr[i] = new Tv();
}

  객체 배열에는 같은 타입의 객체만 저장될 수 있다. 그러면 어떻게 하면 다양한 타입의 객체를 하나의 배열에 저장할 수 있을까? 이는 polymorhphism(다형성) 에 대한 이해가 필요하다.  - 추후 다룸.

 

 

클래스의 또 다른 정의

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

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

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

4. 클래스 : 데이터와 함수의 결합을 의미

 

  자바와 같은 객체지향언어에서는 변수와 함수를 하나의 클래스에서 정의해서 각각의 관계를 쉽게 다룰 수 있도록 하였다. 이와 같이 서로 관련되어 있는 변수를 정의하고, 해당 변수들에 대한 처리를 수행하는 함수를 정의한 것이 클래스이다. C언어에서 문자열은 char 배열이지만 JAVA 에서는 String 클래스로 다루는데, 이는 문자열을 단순한 배열로 보는 것에서 보다 나아가, 문자열 데이터와 이를 다루는 함수들을 묶기 위함이다. 

 

  객체지향언어에서 사용자 정의 타입(user - defined type)은 바로 class 와 같다. 서로 관련되어 있는 데이터들을 하나의 의미 단위로 묶어서 사용할 수 있는데, class 를 이용하면 각각의 데이터에 대한 inconsistency 를 방지하기 위해 제어자/메서드를 활용하여 데이터 무결성을 유지할 수 있다.

public class Time{
    private int hour;
    private int minute;
    private float second;
    
    public int getHour() { return hour;}
    public int getMinute() { return minute; }
    public int getSecond() { return second; }
    
    public void setHour(int h){
        if(h<0 || h>23) return;
        hour = h;
    }
    
    public void setMinute(int m){
        if (m<0 || m>59) return;
        minute = m;
    }
    
    public void setSecond(float s){
        if(s<0.0f || s>59.99f) return;
        second = s;
    }
}

 

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

  변수는 클래스 변수, 인스턴스 변수, 지역 변수로 총 3 가지로 구분할 수 있는데 선언된 위치에 따라서 결정된다. 멤버 변수를 제외한 나머지 변수들은 모두 지역 변수이며, 멤버 변수 중에서 static 키워드가 붙은 것은 클래스 변수라고 하고 그렇지 않은 것은 인스턴스 변수이다.

 

● 인스턴스 변수 (Instance variable)

: 클래스 영역에서 선언된 변수로 클래스가 인스턴스를 생성할 때 만들어진다. 그래서 인스턴스 변수의 ㄱ밧을 읽거나 저장하려면 인스턴스를 먼저 생성해야 한다. 인스턴스는 독립적인 저장공간을 가지기 때문에 서로 다른 값을 가질 수 있는데, 인스턴스마다 고유한 상태를 유지해야 하는 속성은 인스턴스 변수로 선언한다.

 

● 클래스 변수 (Class variable)

:  클래스 영역에서 선언된 변수로 클래스가 메모리에 올라가면 생성되며, 인스턴스 변수 앞에 static 키워드를 붙이면 된다. 인스턴스 마다 독립적인 저장 공간을 가지는 인스턴스 변수와는 다르게 클래스 변수는 모든 인스턴스가 공통된 저장공간을 공유한다. 단일 클래스의 모든 인스턴스들이 공통적인 값을 유지하도록 하기 위해서는 해당 속성을 클래스 변수로 선언해야 한다. 클래스 변수는 인스턴스 변수와는 다르게 인스턴스를 생성치 않고도 사용할 수 있다. 클래스가 메모리에 loading 될 때 생성되고 이후 프로그램이 종료될 때 까지 유지되는데, public 키워드를 앞에 붙이면 전역변수의 성격을 가지게 된다.

 

● 지역 변수(Local variable)

:  메서드 내에서 선언이 되면 해당 메서드 내에서만 사용이 가능하며, 메서드가 종료됨과 동시에 소멸되어 사용할 수 없다.

 

 

메서드

   메서드(method)란 특정 작업을 수행하는 일련의 문장들을 하나의 단위로 묶은 것으로, 함수와 비슷한 의미이며 메서드를 사용함으로써 3 가지 장점을 얻을 수 있다.

 

● 높은 재사용성(reusability)

:   만들어진 메서드는 수없이 호출이 가능하다.

 

● 중복된 코드의 제거

:  코드를 짜다 보면 중복되는 부분이 일부 발생하게 되는데, 해당 부분을 메서드로 만들 경우 반복되는 문장을 하나의 문장으로 줄일 수 있어서 코드의 유지보수에 유리하다. 

 

● 프로그램의 구조화

:  큰 규모의 프로그램을 설계하는 단계에서 메서드를 여러 개 정의하여 복잡한 프로그램의 구조를 단순화시킬 수 있다. 

 

  메서드는 선언부(header)와 구현부(body)로 이루어져 있으며, 선언부에서는 메서드의 이름과 매개변수 및 반환 타입을 설정한다. 메서드의 구현부(body) 에서는 원하는 동작에 해당하는 문장을 넣으면 되는데, 메서드가 반환값을 가질 경우 지정한 반환 타입과 일치하거나 자동 형변환이 가능해야만 한다. 

 

인자(argument)와 매개변수(parameter)

:   메서드를 호출 할 때, 괄호 안에 넣어주는 값들을 인자라고 한다. 이러한 인자들은 메서드가 호출됨에 따라 매개변수에 대입된다. 매서드의 구현부를 작성할 때 반드시 매개 변수의 값이 적절한 지 확인해야 한다. 이상 동작에 대한 예외처리에 대해 반드시 고려하는 방어적 프로그래밍을 수행하도록 한다.

 

JVM 의 메모리 구조

   응용 프로그램이 실행되면 JVM 은 system 으로부터 프로그램을 수행하기 위한 메모리를 할당받고 JVM 은 해당 메모리 영역을 용도에 맞추어 여러 영역으로 구분하여 관리한다. 그 중, 3가지 주요 영역인 method area , call stack, heap 에 대해 살펴보자.

 

● Method area

:  프로그램이 실행되는 중 어떤 클래스가 사용되면, JVM 은 해당 클래스 파일을 읽은 뒤 분석하여 클래스에 대한 정보 및 클래스 변수를 Method area 에 저장한다.

 

● Heap

:  인스턴스가 생성되는 공간으로 프로그램 실행 도중 생성되는 인스턴스들은 여기에 저장된다.

 

● call stack | execution stack

:  호출 스택(call stack)은 메서드 작업 시 필요한 메모리 공간을 제공하며, 메서드가 호출되면 call stack 에 호출된 메서드를 위한 메모리가 할당되고 해당 메모리는 메서드가 작업을 수행하는 동안에 지역변수(parameter 포함)들과 연산의 중간 결과들을 저장하는데 사용된다. 메서드가 작업을 마치면 할당된 메모리 공간은 반환되어 비워진다. 각각의 메서드를 위한 공간은 구별된다. 가장 처음에 호출된 메서드의 공간은 가장 아래에 마련된다. 첫 번째에 호출된 메서드의 수행 도중 두 번째 메소드를 호출하는 경우, 첫 번째 메서드의 공간 바로 위에 두 번째 메소드의 작업 공간이 마련되고 수행된 이후에 두 번째 메소드의 메모리는 반환되고 다시 이어서 첫 번째 메소드가 수행되는 구조이다. 그러므로 현재 수행되고 있는 메소드를 확인하고자 할 때에는 호출 수택의 가장 위에 위치엔 메서드를 확인하면 된다.

 

  호출 스택의 특징을 정리하면 아래와 같다.

1.  메서드가 호출되면 수행에 필요한 메모리를 스택에 할당받음.

2.  메서드의 수행이 끝나면 메모리가 반환되고 스택에서 제거됨.

3.  호출스택의 가장 위에 위치한 메서드가 바로 현재 실행 중인 메서드임.

4.  아래에 있는 메서드는 바로 위에 있는 메서드를 호출한 parent 메서드임.

 

class CallStackTest{
    public static void main(String[] args) {
        firstMethod();
    }
    static void firstMethod(){
        secondMethod();
    }
    static void secondMethod(){
        System.out.println("secondMethod()");
    }
}

main() 은 firstMethod 를 호출한다. 그리고 firstMethod() 는 secondMethod() 를 호출하는데, 객체를 생성하지 않고도 메서드가 호출될 수 있도록 하기 위해서는 앞에 static 키워드를 붙여주어야 한다. 

 

1. 먼저 JVM 에 의해서 main 메서드가 호출되므로 호출 스택에는 main 메서드를 위한 공간이 할당되고 main 메서드가 수행된다.

2. main 메서드 수행 도중 firstMethod() 를 호출하므로 호출 스택의 main 메서드는 대기 상태로 남아있고 위에 firstMethod 메서드를 위한 작업 공간이 할당되고 수행을 시작한다.

3. firstMethod() 수행 도중 SecondMethod() 를 호출하므로, firstMethod() 또한 대기 상태로 남아있게 되고 SecondMethod() 를 위한 작업 공간이 할당되고 수행된다.

4. SecondMethod() 에서 println() 을 호출하므로, println 메서드에 의해 SecondMethond() 라는 문장이 출력된다. 

5. println 메서드의 수행이 완료되면 호출 스택에서 사라지는데, parent method 인 SecondMethod() 는 이후에 수행할 코드가 없으므로 순차적으로 SecondMethod() 도 호출 스택에서 사라진다.

6. 같은 논리로 main 메서드 까지 호출 스택에서 비워지게 되고 최종적으로 프로그램이 종료된다.

 

기본형 매개변수와 참조형 매개변수

   메서드를 호출할 때 매개변수를 복사해서 넘겨주는데, 기본형인 경우에는 값이 복사되지만 참조형인 경우에는 인스턴스의 주소가 복사된다. 메서드의 매개변수를 기본형으로 선언한다면 오직 read 만 가능하지만, 참조형으로 선언할 경우 read & write 가 가능하다. 

class ArrayExample{
    public static void main(String[] args) {
        int[] arr = new int[] { 3, 2, 1, 6, 5, 4};
        
        printArr(arr);
        sortArr(arr);
        printArr(arr);
        System.out.println("sum = " + sumArr(arr));
    }
    static void printArr(int[] arr){
        System.out.println("[");
        for(int i : arr)
            System.out.println(i + ", ");
        System.out.println("]");
    }
    
    static int sumArr(int[] arr){
        int sum = 0;
        for(int i = 0 ; i <arr.length ; i++)
            sum += arr[i];
        return sum;
    }
    
    static void sortArr(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++)
            for (int j = 0; j < arr.length - 1 - i; j++)
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
    }
}

 

재귀 메서드(Recursive method)

    메서드 실행 도중 자기 자신을 다시 호출하는 메서드를 재귀 메서드라고 일컫는다. 이와 같은 재귀 함수를 짤 때는 탈출 조건을 명확하게 정해주어야 한다. 그렇지 못하면 무한 루프에 빠지게 된다. 메서드를 호출하는 것은 단순 반복 루프와 비교하면 매개변수의 복사와 종료 후 복귀할 주소를 저장하는 과정 등이 추가로 필요하기 때문에 재귀 호출의 수행시간이 더 오래 걸린다. 그럼에도 재귀 호출을 사용하는 이유는 바로 논리적 간결성 때문이다.  아래는 재귀 메서드의 대표격인 팩토리얼을 테스트 할 수 있도록 구현한 것이다. 클래스 내부에서 factorial 은 static method 이기 때문에 인스턴스를 만들지 않고도 호출하여 테스트할 수 있다. 

class FactorialTest{
    public static void main(String[] args) {
        int result = factorial(4);

        System.out.println(result);
    }
    
    static int factorial(int n){
        int result = 0;
        if( n == 1)
            result = 1;
        else
            result = n*factorial(n-1);
        return result;
    }
}

아래는 지수합을 테스트하는 클래스이다.

class PowerTest{
    public static void main(String[] args) {
        int x = 2;
        int n = 5;
        long result = 0;
        
        for(int i = 1; i <=n ; i++)
            result += power(x,i);
        System.out.println(result);
    }
    static long power(int x, int n){
        if(n==1) return x;
        return x * power(x, n-1);
    }
}

 

클래스 메서드(static 메서드)와 인스턴스 메서드

    클래스 메서드는 클래스 변수와 같이 객체를 따로 생성하지 않고도 클래스이름.메서드이름 와 같은 방식으로 호출이 하능한 것이며, 인스턴스 메서드는 반드시 객체를 생성해야지만 호출이 가능한 메서드이다. 보통 인스턴스 변수와 관련된 작업이 요구되는 경우 인스턴스 메서드로 만들고, 인스턴스와 관계없이 작업이 가능한 경우 클래스 메서드로 정의하곤 한다.

 

● 클래스를 설계할 때에는 멤버 변수 중 모든 인스턴스에 공통적으로 사용하는 것에 static 을 붙이도록 한다.

:  생성되는 각 인스턴스들은 서로 독립적인 관계이기 때문에 각각의 인스턴스 변수들은 서로 다른 값을 유지하지만 모든 인스턴스에 대하여 같은 같이 유지되어야 하는 변수는 static 키워드를 이용하여 클래스 변수로 정의하도록 한다.

 

● 클래스 변수(static 변수)는 인스턴스를 생성하지 않아도 사용할 수 있다.

:  static 키워드가 붙은 변수(class 변수)는 클래스가 메모리에 올라갈 때 자동적으로 생성되기 때문이다.

 

● 클래스 메서드(static 메서드)는 인스턴스 변수를 사용할 수 없다.

:  인스턴스 변수는 인스턴스가 반드시 존재해야지만 사용이 가능하다. 이는 클래스 메서드는 인스턴스 생성과 관계 없이 호출이 가능하기 때문에 클래스 메서드가 호출 된 경우 인스턴스가 존재하지 않을 수도 있다. 그렇기 때문에 클래스 메서드에서 인스턴스 변수의 사용을 금지하는 반면 인스턴스 변수 및 인스턴스 메서드에서는 static 키워드가 붙은 멤버들을 사용하는 것이 항상 가능한데, 이는 인스턴스 변수가 존재한다는 것이 static 변수가 메모리에 이미 올려져 있다는 것을 의미하기 때문이다.

 

● 메서드 내에서 인스턴스 변수를 사용하지 않는 경우, static 메서드로 사용하는 것을 고려한다.

:  메서드의 작업 내용 중, 인스턴스변수가 필요하다면 static 키워드를 붙일 수 없지만 인스턴스 변수를 사용하지 않는 메서드라면 static 키워드를 붙이면 메서드의 호출 시간이 보다 짧아지기 때문에 성능이 올라가는 효과가 있다. static 키워드를 붙이지 않은 인스턴스 메서드의 경우 실행할 때 호출되어야 할 메서드를 찾는 과정이 추가적으로 필요하기 때문이다.

 

클래스 메서드와 인스턴스 멤버간의 참조와 호출

    같은 클래스 내부의 멤버 간에는 별도의 인스턴스를 만들지 않아도 서로 참조/호출이 가능하다. 이때 클래스 멤버가 인스턴스 멤버를 참조/호출하려고 하면 인스턴스를 생성해야 한다. 왜냐면 인스턴스 멤버가 존재하는 시점에 클래스 멤버는 항상 존재하는데, 클래스 멤버가 존재하는 시점에 인스턴스 멤버(인스턴스 변수 및 메서드)는 존재하지 않을 수 있다. 

 

같은 클래스 내의 인스턴스 메서드와 static 메서드 간의 호출을 설명하고 있는 코드이다. 위의 경우 staticMethod2 에서 instanceMethod 를 호출하려고 하지만 에러가 뜨는 모습이다. 같은 클래스 내의 메서드는 서로 객체의 생성 혹은 참조변수 없이 직접 호출이 가능하지만 static 메서는 인스턴스 메서드를 호출할 수 없기 때문이다. (인스턴스 멤버가 존재할 때 클래스 멤버는 항상 존재하겠지만, 반대로 클래스 멤버가 존재한다고 하더라고 인스턴스 멤버가 존재할 것이라는 보장은 없기 떄문이다.)

 

인스턴스 메서드는 인스턴스 변수를 호출/참조할 수 있지만 static 메서드는 인스턴스 변수를 참조할 수 없다.

 

class MemberCall{
    int iv = 10;
    static int cv = 20;
    
    int iv2 = cv;
    static int cv2 = iv; // error
    // class 변수는 instance 변수를 사용할 수 없다.
    
    static void staticMethod1() {
        System.out.println(cv);
        System.out.println(iv); // error
        // class 메서드에서 instance 변수 사용불가
        MemberCall c = new MemberCall();
        System.out.println(c.iv);
        // 이와 같이 객체를 생성해야만 인스턴스 변수참조가능
    }
    
    void instanceMethod1(){
        System.out.println(cv);
        System.out.println(iv);
        // instance 메소드에서는 instance 변수를 바로 사용가능
    }
    
    static void staticMethod2(){
        staticMethod1();
        instanceMethod1(); // error
        // class 메서드에서는 인스턴스 메서드 호출 불가
        MemberCall c = new MemberCall();
        c.instanceMethod1(); // 인스턴스를 생성한 후에야 사용 가능
    }
    void instanceMethod2(){
        staticMethod1();
        instanceMethod1();
    }
}

실제로는 같은 클래스에서 클레스 멤버가 인스턴스 멤버를 참조/호출해야 하는 경우는 매우 드물다고 한다. 이러한 경우가 발생한다면, 인스턴스 메소드로 작성해야할 메소드를 클래스 메서드로 작성하고 있는 것은 아닌지 확인하는 것이 좋다고 한다. 

 

오버로딩(overloading)

    한 클래스 안에서 같은 이름의 메서드를 여러 개 정의하는 것을 메서드 오버로딩(method overloading) 이라고 하며, 같은 이름의 메서드일지라도 매개변수의 개수 혹은 타입이 다른 경우 같은 이름을 사용해서 메서드를 정의할 수 있다. 오버로딩을 하기 위해서는 아래의 조건을 만족하여야 한다.

 

● 메서드의 이름이 같을 것

● 매개변수의 개수 혹은 타입이 다를 것

 

위 조건을 만족하지 못하는 메서드는 중복 정의이기 때문에 컴파일 에러가 발생한다. 또한 오버로딩된 메서드들은 매개 변수에 의해서만 구분되므로 반환 타입은 오버로딩을 구현하는 데에 영향을 끼치지 않음에 유의하자.

 

  가장 대표적인 오버로딩의 예시는 println 메서드이다. println 안에서 어느 값을 넣더라도 출력이 되지만, 실제로는 호출할 때 매개변수로 지정하는 값의 타입이 달라지면 호출되는 println 메서드 또한 달라진다. PrintStream class 를 살펴보면 어떤 종류의 매개변수를 지정하더라도 출력이 가능하도록 println 에 대한 10개의 오버로딩을 구현하고 있다. 호출 시 매개변수로 넘겨지는 값의 타입에 따라서 오버로딩된 메서드 중 하나가 선택되어 실행되는 것이다. 

int add(int a, int b) { return a+b;}
long add(long a, long b) {return a+b;}
long add(int[] a){
    long result = 0;
    for(int i = 0 ; i < a.length; i ++)
        result += a[i];
    return result;
}

  위와 같이 오버로딩을 사용하면 같은 기능을 수행하는 메서드는 동일한 이름으로 네이밍할 수 있기 때문에 코드의 유지보수에 유리하다. 

 

가변인자(varargs)와 오버로딩

    JDK1.5 부터 동적으로 메서드의 매개변수 개수를 지정할 수 있으며, 이를 가변인자(variable arguments)라고 한다. 가변 인자는 타입... 변수명 과 같이 선언한다. PrintStream 클래스의 printf() 메서드가 대표적인 예시이다.

public PrintStream printf(String format, Object... args) { ... }

   만약에 여러 문자열을 하나로 결합한 다음 반환하는 concatenate 메서드를 작성하려고 한다면, 매개 변수의 개수에 따라서 여러 개를 오버로딩해야 할 것이지만 가변 인자를 사용하면 메서드 하나만으로도 간단하게 구현할 수 있다.

String concatenate(String... str){
    ...
}

위 메서드를 호출할 때에는 인자의 개수를 가변적으로 지정할 수 있다 .심지어는 인자가 아예 없어도 가능하며, 배열을 넣는 것도 가능하다. 가변인자는 내부적으로 배열을 이용하는 것이므로 가변인자가 선언된 메서드를 호출할 때마다 배열이 새로 생성된다. 그렇기 때문에 가변 인자는 편리한 것은 맞지만 이와 같은 비효율적인 요소가 숨어있으므로 필요한 경우에만 사용하도록 한다. 

 

단순히 메서드의 매개변수 타입을 배열로 하는 것이 가변인자와 동일할까? 그렇지는 않다. 매개변수의 타입을 단순히 배열로 한 메서드는 반드시 인자를 지정해주어야 해서 인자를 생략할 수 없다. 

 

가변인자를 오버로딩 할 때에는 한 가지 주의해야 할 점이 있다. 

class source{
    public static void main(String[] args) {
        String[] strArr = {"100", "200", "300"};

        System.out.println(concatenate("", "100", "200", "300"));
        System.out.println(concatenate("-", strArr));
        System.out.println(concatenate(",", new String[]{"1", "2", "3"}));
        System.out.println("[" + concatenate(",", new String[0]) + "]");
        System.out.println("["+concatenate(",") + "]");
    }
    static String concatenate(String delim, String... args){
        String result = "";

        for(String str : args){
            result += str + delim;
        }
        return result;
    }

    /*
    static String concatenate(String... args){
        return concatenate("", args);
    }

     */

}

concatenate 메서드는 매개변수로 입력된 문자열에 대하여 delim 을 사이에 포함시켜서 반환한다. 가변인자로 매개변수를 선언하였으므로 문자열 개수에 상관없이 매개 변수로 지정할 수 있다. 위 코드에서 주석 처리한 메서드를 풀고 컴파일을 할 경우에는 에러가 발생한다. 이는 두 오버로딩 된 메서드가 구분되지 않아서 발생하는 것으로, 가변인자를 선언한 메서드를 오버로딩하면 구별되지 못하는 경우가 발생할 수 있기 때문에 조심해야 하며, 가능하면 가변인자를 사용한 메서드는 오버로딩 하지 않는것이 좋다.

 

생성자(Constructor)

    생성자는 인스턴스가 생성될 때 호출되는 인스턴스 초기화 메서드이다. 그러므로 인스턴스 변수의 초기화 시 사용되며, 인스턴스가 생성될 때 실행되어야 할 작업을 위해서도 사용된다. 생성자는 메서드처럼 클래스 내부에서 선언되며, 메서드와 구조가 유사하지만 리턴값은 없다. 생성자의 조건은 아래와 같다.

 

● 생성자의 이름은 클래스의 이름과 같아야 한다.

● 생성자는 리턴값이 없다.

 

  생성자 또한 오버로딩이 가능하기 때문에 하나의 클래스 내에서 매개 변수가 각각 다른 여러 개의 생성자를 만들 수 있다. 다만 조심해야할 것은 생성자가 인스턴스를 직접적으로 생성하는 것은 아니며, 실제로 인스턴스를 생성하는 것은 연산자인 new 이다. 만약에 Card 클래스의 인스턴스를 생성하기 위해 Card c = new Card(); 와 같은 코드를 실행시켰다고 가정해보자. 그러면 먼저, new 연산자에 의해서 heap 메모리 영역에 Card 클래스의 인스턴스가 생성된다. 그리고 생성자 Card() 가 호출되어 수행되며, 연산자 new 에 의한 결과로 생성된 Card 인스턴스 주소가 반환되어서 참조 변수인 c 에 저장되는 것이다. 

 

기본 생성자(Default Constructor)

    모든 클래스에는 반드시 하나 이상의 생성자가 정의되어 있어야 한다. 하지만 코드 상에서 생성자를 구현하지 않아도 되는데, 이는 컴파일러가 기본 생성자를 제공하기 때문이다. 클래스 내부에서 생성자가 하나도 정의되지 않은 경우 컴파일러는 아무런 매개변수를 가지지 않고 아무런 기능을 수행하지 않는 기본 생성자를 추가한 다음에 컴파일을 진행한다. 

class Data1{
    int value;
}
class Data2{
    int value;
    Data2(int x){
        value = x;
    }
}

class ConstructorTest{
    public static void main(String[] args){
        Data1 d1 = new Data1();
        Data2 d2 = new Data2();
    }
}

위 코드를 실행하면 Data2 d2 = new Data2(); 에서 컴파일 오류가 발생한다. Data2 에서 Data2() 라는 생성자를 찾지 못하기 때문인데, 이는 Data2 클래스에서 Data2() 라는 생성자가 정의되어있지 않기 때문에 발생한다. Data1 에서도 동일한데 Data1 에서는 오류가 발생하지 않는다. 이는 Data1 에서는 생성자가 하나도 없어서 컴파일러가 Data1() 이라는 기본 생성자를 추가했기 때문이며, Data2 에는 Data2(int x) 생성자가 하나 있기 때문에 기본 생성자를 추가하지 않은 것이고, main 메서드에서 Data2 d2 = new Data2() 와 같이 작성하면 Data2() 와 같은 생성자가 호출되어야 하지만 없기 때문에 오류가 발생하는 것이다.

 

아래와 같이 매개 변수를 가지는 생성자를 정의하여 클래스의 인스턴스 변수를 원하는 값으로 초기화 할 수 있도록 구현할 수 있다. 

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

 

생성자에서 다른 생성자 호출하기 this(), this

    같은 클래스의 멤버들 간에는 서로 호출이 가능한 것 처럼 생성자 간에도 서로 호출이 가능하다. 하지만 이는 아래의 두 조건을 만족했을 때 가능하다.

 

● 생성자의 이름으로 클래스의 이름 대신에 this 를 사용할 것

● 한 생성자에서 다른 생성자를 호출할 때에는 반드시 첫 줄에서만 호출이 가능함

 

생성자에서 다른 생성자를 첫 줄에서만 호출이 가능하도록 한 것은 생성자 내부에서 초기화 작업 도중에 다른 생성자를 호출하는 경우에는 호출된 다른 생성자 내에서도 멤버 변수들을 값을 초기화한다면 이전 작업이 무의미해지는 경우가 발생할 수 있기 때문이며, 관련되어 추후에 자세히 다루도록 하자.

class Car{
    String color;
    String gearType;
    int door;

    Car(){
        this("white", "auto", 4);
    }
    Car(String color){
        this(color, "auto", 4);
    }
    Car(String c, String g, int d){
        this.color = c;
        this.gearType = g;
        this.door = d;
    }
}

  위와 같이 this 를 이용하여 구현하는 것이 코드의 유지보수에 유리하다. this 는 참조 변수로 인스턴스 자신을 가리킨다. 참조 변수를 통해서 인스턴스 멤버에 접근했던것 처럼 this 를 이용해서 인스턴스 변수에 접근할 수 있는 것이다. 하지만 this 는 인스턴스 멤버만 사용할 수 있으며 static 메서드(클래스 메서드)에서는 인스턴스 멤버를 사용할 수 없는 것처럼 this 를 사용할 수 없다. static 메서드는 인스턴스를 생성하지 않아도 호출될 수 있으므로 static 메서드가 호출되었을 때 인스턴스가 존재하지 않을수도 있기 때문이다. 

 

  생성자를 포함한 모든 인스턴스 메서드에는 자신이 관련된 인스턴스를 가리키는 참조 변수인 this 가 지역변수로 숨겨진 상태로 전재한다. 보통 인스턴스 메서드는 특정 인스턴스와 관련된 작업을 하므로 자신과 관련된 인스턴스의 정보가 필요하지만, static 메서드는 인스턴스와 관련 없는 자업을 해서 인스턴스에 대한 정보가 필요 없기 때문이다. 

 

● this : 인스턴스 자기 자신을 가리키는 참조변수로, 인스턴스의 주소가 저장되어 있으며 모든 인스턴스 메서드에 지역 변수로 숨겨진 상태로 존재한다.

● this(), this(parameter)  :  생성자로, 같은 클래스의 다른 생성자를 호출할 때 이와 같이 사용한다.

 

만약에 현재 사용하고 있는 인스턴스와 동일한 상태를 가지는 인스턴스를 하나 더 만들고자 한다면 생성자를 이용하면 된다. 두 개의 인스턴스가 같은 상태를 가진다는 것은 인스턴스 변수의 값이 모두 동일하다는 것이다.

Car(Car c){
    color = c.color;
    gearType = c.gearType;
    door = c.door;
}

이와 같이 생성자를 구현하면, 매개변수로 넘어온 Car 인스턴스와 동일한 상태의 인스턴스를 쉽게 만들 수 있다. 

 

변수의 초기화

    변수 선언 시, 멤버변수(클래스 변수, 인스턴스 변수)와 배열의 초기화는 선택적이지만, 지역변수의 초기화는 필수적이다. 지역변수를 초기화하지 않고 컴파일 시, 에러가 발생한다. 멤벼 변수를 초기화하는 방법에는 3가지가 존재한다.

 

1. 명시적 초기화(explicit initialization)

  변수를 선언함과 동시에 초기화하는 것을 의미한다. 기본형 변수의 초기화는 int door = 4; 와 같이 하고, 참조형 변수의 초기화는 Engine e = new Engine(); 과 같이 해주면 된다. 간단하고 명료한 방법이지만, 복잡한 초기화 작업이 필요할 시에는 초기화 블럭(initializaton block) 혹은 생성자를 사용해야 한다.

 

2. 초기화 블럭(initialization block)

  초기화 블럭은 클래스 초기화 블럭과 인스턴스 초기화 블럭이 있다. 클래스 초기화 블럭은 클래스 변수의 초기화에 사용되며, 인스턴스 초기화 블럭은 인스턴스 변수의 초기화에 사용된다. 초기화 블럭 내에서는 메서드 내에서와 같이 조건문, 반복문, 예외처리 등을 자유롭게 사용할 수 있기 때문에, 초기화 작업이 복잡하여 명시적 초기화만으로는 부족한 경우에 초기화 블럭을 사용한다. 클래스 초기화 블럭은 인스턴스 초기화 블럭 앞에 static 키워드를 덧붙여주기만 하면 된다.

class temp{
	static { /* 클래스 초기화 블럭 */ }
    
    {
      /* 인스턴스 초기화 블럭 */
    }
}

  인스턴스 변수는 주로 생성자를 활용하여 초기화하고, 인스턴스 초기화 블럭은 모든 생성자에서 공통으로 수행해야 하는 코드를 넣는데에 사용한다.

class Car{
    String color;
    String gearType;
    int door;
    int count;
    int serialNo;
    Car(){
        count++;
        serialNo = count;
        color = "White";
        gearType = "Auto";
    }
    Car(String color, String gearType) {
        count++;
        serialNo = count;
        this.color = color;
        this.gearType = gearType;
    }
}

  위 코드를 보면, Car() 생성자와 Car(String color, String gearType) 생성자에 중복된 기능을 수행하는 부분이 존재한다. 이러한 중복은 코드의 유지보수를 어렵게 하는 주요 요인이 된다. 이와 같이 클래스의 모든 생성자에 대하여 공통적으로 수행되어야 할 문장에는 인스턴스 블럭을 활용하면 보다 간결해진다. 코드 중복을 제거함으로써 코드의 신뢰성을 높여 주고, 오류 발생 가능성을 줄여준다. 재사용성을 높이고, 중복을 제거하는 것이 객체지향프로그래밍이 추구하는 궁극적인 목표이다.

class Car{
    String color;
    String gearType;
    int door;
    int count;
    int serialNo;
    {
        count++;
        serialNo = count;
    }
    Car(){

        color = "White";
        gearType = "Auto";
    }
    Car(String color, String gearType) {
        this.color = color;
        this.gearType = gearType;
    }
}

class source{
    static{ // 클래스 초기화 블럭
        System.out.println("static { }");
    }
    { // 인스턴스 초기화 블럭
        System.out.println("{  }");
    }
    public source(){
        System.out.println("generator");
    }
    public static void main(String[] args) {
        System.out.println("source bt = new source() ; ");
        source bt = new source();

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

 

  위 코드가 실행되면 source 가 메모리에 로딩되고, class 초기화 블럭이 수행되어 static { } 이 화면에 출력된다. 다음에는 main 메서드의 수행에 따라서 source 인스턴스가 생성되어, 인스턴스 초기화 블럭이 실행되고, 생성자가 실행된다. 클래스 초기화 블럭은 메모리에 로딩될 때 최초 1회만 수행되지만, 인스턴스 초기화 블럭은 인스턴스가 생성될 때마다 수행되는 것을 알 수 있다.

class source{
    static int[] arr = new int[10];
    static{
        for(int i = 0 ; i < arr.length; i ++)
        {
            arr[i] = (int)(Math.random()*10 + 1);
        }
    }
    public static void main(String[] args) {
        for(int i = 0 ; i < arr.length ; i ++)
            System.out.println("arr[" + i + "] = " + arr[i]);
    }
}

  이와 같이 배열이나 예외처리 등 복잡한 초기화 작업이 필요한 경우에는 명시적 초기화만 이용하여 수행할 수 없고 클래스 초기화 블럭을 사용하여 처리할 수 있다.

 

멤버 변수의 초기화 시기 및 순서

    초기화가 수행되는 순서에 대하여 알아보자. 클래스 변수는 클래스가 처음 로딩될 때, 최초 1회 초기화된다. 인스턴스 변수는 인스턴스가 생성될 때마다 각 인스턴스 별로 초기화가 이루어진다. 클래스변수는 기본값 - 명시적 초기화 - 클래스 초기화 블럭의 순서로 초기화가 진행되며, 인스턴스변수는 기본값 - 명시적 초기화 - 인스턴스 초기화 블럭 - 생성자 순서로 초기화가 진행된다.

 

  프로그램 실행 도중에 클래스에 대한 정보가 필요하다면, 클래스는 메모리에 로딩된다. 클래스 멤버를 사용했을 때, 인스턴스를 생성했을 때와 같은 상황에 해당한다. 하지만 해당 클래스가 메모리에 이미 올라와있다면, 다시 로딩하지 않고 초기화도 진행되지 않는다. 

 

   클래스의 로딩 시기는 어떤 JVM 을 사용하느냐에 따라서 달라질 수 있다. 클래스가 필요할 때 바로 메모리에 로딩될 수도 있고, 실행효율을 높이기 위해서 프로그램이 실행될 때 미리 로딩되도록 설계된 경우도 있다.

class InitTest{
    // Explicit initialization
    static int cv = 1; 
    int iv = 1;
    
    static { cv = 2; } // class 초기화 블럭
    { iv = 2; }; // instance 초기화 블럭
    
    InitTest(){ // Constructor
        iv = 3;
    }
}

 

  위 클래스는 클래스 변수 cv 와 인스턴스 변수 iv 를 하나씩 가지고 있다. 인스턴스를 생성하였을 때, 먼저 cv 가 메모리(method area)에 생성되고 cv 에는 int 형의 기본값인 0 이 저장된다. 그 다음에는 명시적 초기화에 의해 cv 에는 1이 저장되고, 마지막에 클래스 초기화 블럭이 수행되어 cv 에 2가 저장된다.

 

  InitTest 클래스의 인스턴스가 생성되면서, iv 가 메모리(heap)에 올라간다. iv 역시 int 형 변수이기 때문에 기본값인 0 이 저장되고 다음에는 명시적 초기화에 의해 1이 저장된다. 그리고 인스턴스 초기화 블럭이 수행되어 iv 에는 2가 저장되고, 최종적으로 생성자에 의해 3이 저장된다.

 

class Document{
    static int count = 0 ;
    String name; // Document name
    Document()
    {
        this("no_title" + (++count));
    }
    Document(String name){
        this.name = name;
        System.out.println("Document " + this.name + " is generated.");
    }
}

class source {
    public static void main(String[] args) {
        Document d1 = new Document();
        Document d2 = new Document("Java.txt");
        Document d3 = new Document();
        Document d4 = new Document();
    }
}

  Document 인스턴스가 생성될 때마다 count 값을 증가시켜서, Document 의 이름을 설정하지 않는 경우에는 no_title1, no_title2, no_title3 과 같이 구분되도록 설정하였다. 인스턴스 생성 시 공통적으로 수행되는 작업이므로 인스턴스 초기화 블럭을 이용하였다.

 

---

References

https://opentutorials.org/course/1223/4551

언어소개 - 생활코딩

http://www.yes24.com/Product/Goods/24259565

Java의 정석 - YES24