6-3장 변수와 메서드 下 (3.7 ~ 3.12)

 

7. JVM의 메모리 구조

* cv는 클래스 변수, lv는 지역 변수, iv는 인스턴스 변수를 뜻한다.

 

메서드 영역 (method area)

 

프로그램 실행 중 어떤 클래스가 사용되면, JVM은 해당 클래스의 클래스 파일(*.class)을 읽어서 분석하여 클래스에 대한 정보를(클래스 데이터)를 이곳에 저장한다. 이 떄, 그 클래스의 클래스 변수(class variable)도 이 영역에 함께 생성된다.

 

힙 (heap)

 

인스턴스가 생성되는 공간. 프로그램 실행 중 인스턴스는 모두 이곳에 생성된다. 즉, 인스턴스 변수(instance variable)들이 생성되는 공간이다.

 

호출스택 (call stack 또는 execution stack)

 

메서드의 작업에 필요한 메모리 공간을 제공한다. 메서드가 호출되면, 호출스택에 호출된 메서드를 위한 메모리가 할당되며, 이 메모리는 메서드가 작업을 수행하는 동안 지역변수(매개변수 포함)들과 연산의 중간 결과 등을 저장하는데 사용된다. 그리고 메서드가 작업을 마치면 할당되었던 메모리 공간은 반환되어 비워진다.

 

호출스택의 변화

class CallStackTest {
    public static void main(String[] args) {
    	firstMethod() ; // static메서드는 객체 생성없이 호출가능하다.
    }
    static void firstMethod() {
    	secondMethod();
    }
    static void secondMethod() {
    	System.out.println("secondMethod()");
    }
}

 

 

1~2: JVM에 의해서 main메서드가 호출됨으로써 프로그램이 시작된다. 이때, 호출스택에는 main메서드를 위한 메모리 공간이 할당되고 main메서드의 코드가 수행된다.

 

3: main메서드에서 firstMethod()를 호출한 상태이다. 아직 main메서드가 끝난 것이 아니므로 main메서드는 호출 스택에 대기상태로 남아있고 firstMethod()의 수행이 시작된다. 

 

4. firstMethod()에서 다시 secondMethod()를 호출했다. firstMethod()는 secondMethod()가 수행을 마칠 때까지 대기상태에 있게 된다. secondMethod()가 수행을 마쳐야 firstMethod()의 나머지 문장들이 수행될 수 있기 때문이다.

 

5. secondMethod()에서 println()을 호출했다. println메서드에 의해 'secondMethod()'가 화면에 출력된다.

 

6. println메서드의 수행이 완료되어 호출스택에서 사라지고 자신을 호출한 secondMethod()로 되돌아간다. 대기 중이던 secondMethod()는 println()을 호출한 이후부터 수행을 재개한다.

 

7. secondMethod()에 더 이상 수행할 코드가 없으므로 종료되고, 자신을 호출한 firstMethod()로 돌아간다.

 

8. firstMethod()에도 더 이상 수행할 코드가 없으므로 종료되고, 자신을 호출한 main메서드로 돌아간다.

 

9. main메서드에도 더 이상 수행할 코드가 없으므로 종료되어, 호출스택은 완전히 비워지게 되고 프로그램은 종료된다.

 

 

호출스택의 특징

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

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

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

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

 

 

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

 

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

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

 

기본형 매개변수 예시

 

class Data {
    int x;
}

class Test {
    public static void main(String[] args) {
        Data d = new Data();
        d.x = 10;
        System.out.println("main() : x = " + d.x);

        change(d.x);

        System.out.println("After change(x)");
        System.out.println("main() : x = " + d.x);
    }

    static void change(int x) {  // 기본형 매개변수
        x = 1000;
        System.out.println("change() : x = " + x);
    }
}

 

실행 결과

main() : x = 10
change() : x = 1000
After change(x)
main() : x = 10

 

change메서드에서 main메서드로부터 넘겨받은 d.x의 값을 1000으로 변경했는데도 main메서드에서는 d.x의 값이 그대로이다.  그 이유는 d.x의 값이 변경된 것이 아니라, change메서드의 매개변수 x의  값이 변경된 것이기 때문이다. 

즉, 원본이 아닌 복사본이 변경된 것이라 원본에는 아무런 영향을 미치지 못한다.

이처럼 기본형 매개변수는 변수에 저장된 값만 읽을 수 있을 뿐 변경할 수는 없다.

 

 

참조형 매개변수 예시 1

 

class Test {
    public static void main(String[] args) {
        Data d = new Data();
        d.x = 10;
        System.out.println("main() : x = " + d.x);

        change(d);

        System.out.println("After change(d)");
        System.out.println("main() : x = " + d.x);
    }

    static void change(Data d) {
        d.x = 1000;
        System.out.println("change() : x = " + d.x);
    }
}

 

실행 결과

main() : x = 10
change() : x = 1000
After change(d)
main() : x = 1000

 

change메서드의 매개변수를 참조형으로 선언했기 때문에, x의 값이 아닌 주소가 매개변수 d에 복사되었다. 이제 main메서드의 참조변수 d와 change메서드의 참조변수 d는 같은 객체를 가리키게 된다. 따라서 매개변수 d로 x의 값을 읽는 것과 변경하는 것이 모두 가능하다. 

 

참조형 매개변수 예시 2

 

class Test {
    public static void main(String[] args) {
        int[] x = {10};
        System.out.println("main() : x = " + x[0]);

        change(x);

        System.out.println("After change(x)");
        System.out.println("main() : x = " + x[0]);

    }

    static void change(int[] x) {
        x[0] = 1000;
        System.out.println("change() : x = " + x[0]);
    }
}

 

배열도 객체와 같이 참조변수를 통해 데이터가 저장된 공간에 접근한다. 이전 예제와 같이 변수 x도 int배열 타입의 참조변수이기 때문에 같은 결과를 얻는다.

 

9. 참조형 반환타입

class Data {
    int x;
}

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

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

    }

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

        return tmp;
    }
}

 

실행 결과

d.x = 10
d2.x = 10

 

실행 과정

1. copy메서드를 호출하면서 참조변수 d의 값이 매개변수 d에 복사된다.

2. 새로운 객체를 생성한 다음, d.x에 저장된 값을 tmp.x에 복사한다.

3. copy메서드가 종료되면서 반환한 tmp의 값은 참조변수 d2에 저장된다.

4. copy메서드가 종료되어 tmp는 사라졌지만, d2로 새로운 객체를 다룰 수 있다.

 

✅ 반환타입이 '참조형'이라는 것은 메서드가 '객체의 주소'를 반환한다는 것을 의미한다.

 

10. 재귀호출 (recursive call)

💡메서드 내부에서 메서드 자신을 다시 호출하는 것

 

재귀 호출 예시

 

팩토리얼 식: f(n) = n * f(n-1), 단 f(1) = 1

class Test {
    public static void main(String[] args) {
        System.out.println(factorial(2));
    }

    static int factorial(int n) {
        int result;

        if (n == 1) {
            result = 1;
        } else {
            result = n * factorial(n - 1);
        }

        return result;
    }
}

 

실행 과정

1. factorial(2)를 호출하면서 매개변수 n에 2가 복사된다.

2. 'return 2 * factorial(1);'을 계산하려면 factorial(1)을 호출한 결과가 필요하다. factorial(1)이 호출되고 매개변수 n에 1이 복사된다.

3. if문의 조건식이 참이므로 1을 반환하면서 메서드는 종료된다. 그리고 factorial(1)을 호출한 곳으로 되돌아간다.

4. 이제 factorial(1)의 결괏값인 1을 얻었으므로, return문이 다음의 과정으로 계산된다.

return 2 * factorial(1);
-> return 2 * 1;
-> return 2;

 

재귀호출의 주의점

 

- 스택 오버플로우 에러

위의 예시의 경우 매개변수 n의 값이 0이거나 100,000와 같이 큰 값이면 계속 재귀호출이 일어나 스택에 데이터가 쌓인다. 어느 시점에 이르러서는 결국 스택의 저장한계를 넘게되고, '스택 오버플로우 에러'가 발생한다.

 

개선된 코드

class Test {
    public static void main(String[] args) {
        System.out.println(factorial(2));
    }

    static int factorial(int n) {
        if (n <= 0 || n > 12) {
            return -1;
        }
        if (n == 1) {
            return 1;
        }
        return n * factorial(n - 1);
    }
}

n의 상한값을 12로 정한 이유는 13!의 값이 메서드 factorial의 반환타입인 int의 최댓값(약 20억)보다 크기 때문이다.

 

반복문으로 구현

 

class Test {
    public static void main(String[] args) {
        System.out.println(factorial(2));
    }

    static int factorial(int n) {
        int result = 1;

        while (n != 0) {
            result *= n--;
        }
        return result;
    }
}

재귀호출과 달리 많은 수의 반복에도 '스택 오버플로우 에러'와 같은 메모리 부족 문제를 겪지 않을 뿐만 아니라 속도도 빠르다.

 

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

 

인스턴스 메서드는 인스턴스 변수와 관련된 작업을 하는, 즉 메서드의 작업을 수행하는데 인스턴스 변수를 필요로 하는 메서드이다. 인스턴스 변수는 인스턴스 변수는 인스턴스(객체)를 생성해야만 만들어지므로 인스턴스 메서드 역시 인스턴스를 생성해야만 호출할 수 있다.

 

클래스 매서드는 인스턴스와 관계없는(인스턴스 변수나 인스턴스 메서드를 사용하지 않는) 메서드이다.

 

* 멤버 변수: 클래스 영역에 선언된 변수, static이 붙은 것은 클래스 변수(static 변수), static이 붙지 않은 것은 인스턴스 변수이다. 

 

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

 

생성된 각 인스턴스는 독립적이기 때문에 각 인스턴스의 변수는 서로 다른 값을 유지한다. 그러나 모든 인스턴스에서 같은 값이 유지되어야 하는 변수는 static을 붙여서 클래스 변수로 정의해아한다.

 

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

 

static이 붙은 변수(클래스 변수)는 클래스가 메모리에 올라갈 때 이미 자동적으로 생성된다.

 

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

 

인스턴스 변수는 인스턴스가 반드시 존재해야만 사용할 수 있는데, 클래스 메서드(static이 붙은 메서드)는 인스턴스 생성 없이 호출가능하므로 클래스 메서드가 호출되었을 때 인스턴스가 존재하지 않을 수도 있다. 그래서 클래스 메서드에서 인스턴스 변수의 사용을 금지한다.

 

4. 메서드 내에서 인스턴스 변수를 사용하지 않는다면, static을 붙이는 것을 고려한다.

 

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

 

✅정리

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

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

 

12. 클래스 멤버와 인스턴스 멤버 간의 참조와 호출

같은 클래스에 속한 멤버들 간에는 별도의 인스턴스를 생성하지 않고도 서로 참조 또는 호출이 가능하다. 단, 클래스 멤버가 인스턴스 멤버를 참조 또는 호출하고자 하는 경우에는 인스턴스를 생성해야 한다.

그 이유는 인스턴스 멤버가 존재하는 시점에 클래스 멤버는 항상 존재하지만, 클래스 멤버가 존재하는 시점에 인스턴스 멤버가 존재하지 않을 수도 있기 때문이다.

 

* 인스턴스 멤버란 인스턴스 변수와 인스턴스 메서드를 의미한다. 클래스 멤버란 클래스 변수와 클래스 인스턴스를 의미한다.

 

class MemberCall {
    int iv = 10;
    static int cv = 20;

    int iv2 = cv;
    // static int cv2 = iv;         // 에러. 클래스 변수는 인스턴스 변수를 사용할 수 없음.
    static int cv2 = new MemberCall().iv; // 이처럼 객체를 생성해야 사용가능.

    static void staticMethod1() {
        System.out.println(cv);
        // System.out.println(iv); // 에러. 클래스 메서드에서 인스턴스 변수를 사용불가.

        MemberCall c = new MemberCall();
        System.out.println(c.iv); // 객체를 생성한 후에야 인스턴스 변수의 참조가능.
    }

    void instanceMethod1() {
        System.out.println(cv);
        System.out.println(iv); // 인스턴스 메서드에서는 인스턴스 변수를 바로 사용가능.
    }

    static void staticMethod2() {
        staticMethod1();
        // instanceMethod1() ; // 에러. 클래스 메서드에서는 인스턴스 메서드를 호출할 수 없음.

        MemberCall c = new MemberCall();
        c.instanceMethod1(); // 인스턴스를 생성한 후에야 호출할 수 있음.
    }

    void instanceMethod2() { // 인스턴스 메서드에서는 인스턴스 메서드와 클래스 메서드
        staticMethod2();     // 모두 인스턴스 생성없이 바로 호출이 가능하다.
        instanceMethod1();
    }
}

클래스 멤버는 언제나 참조 또는 호출이 가능하기 때문에 인스턴스 멤버가 클래스 멤버를 사용하는 것은 가능하다. 클래스 멤버 간의 참조 또는 호출도 가능하다. 그러나, 인스턴스 멤버는 반드시 객체를 생성한 후에만 참조 또는 호출이 가능하기 때문에 클래스 멤버가 인스턴스 멤버를 참조, 호출하기 위해서는 반드시 객체를 생성해야 한다.

 

또한 인스턴스 멤버 간의 호출도 가능하다. 하나의 인스턴스 멤버가 존재한다는 것은 인스턴스가 이미 생성되어 있다는 것을 의미하며, 즉 다른 인스턴스 멤버들도 모두 존재하기 때문이다. 

 

알아두면 좋아요!

 

MemberCall c = new MemberCall();
c.instanceMethod1();

 

위와 같은 두 줄을 한 줄로 줄일 수 있다.

int result = new MemberCall().instanceMethod1();

대신 참조변수를 사용하지 않았기 때문에 생성된 MemberCall인스턴스는 더 이상 사용할 수 없다.

 

 

Reference

자바의 정석 - 남궁 성