🍀 final 변수와 상수

final 키워드는 말 그대로 “끝” 이라는 뜻이다. final로 변수를 선언하면 그 값을 더 이상 바꿀 수 없다. final 키워드는 변수, 메서드, 클래스에 사용될 수 있지만, 일단 지금은 변수에 붙을 경우에 대해 알아보자.

package final1;

public class FinalLocalMain {
    public static void main(String[] args) {
        final int data1 = 10;

        // Cannot assign a value to final variable 'data1'
        // data1 = 20;

        finalMethod(30);
    }

    // Value of parameter 'parameter' is always '30'
    static void finalMethod(final int parameter) {
        // Cannot assign a value to final variable 'parameter'
        // parameter = 20;
    }
}

보다시피 final을 data1처럼 지역 변수로 설정할 경우, 최초 한번만 할당 가능하다. 이후에 그 변수의 값을 변경하려고 한다면 컴파일 오류가 발생한다. 마찬가지로, 매개 변수에 final이 붙은 경우에도 메서드 내부에서 매개 변수의 값을 변경할 수 없다. 따라서 메서드 호출 시점에 사용된 값이 끝까지 사용되는 것이다.

 

🤿 멤버 변수에서의 final 사용

다음으로, final을 멤버 변수에 사용해보자.

package final1;

public class ConstructInit {

    final int value;

	// 생성자를 통해 한번만 초기화
    public ConstructInit(int value) {
        this.value = value;
    }
}

위처럼 멤버 변수에 final이 붙으면 생성자를 통해서 한번만 초기화 될 수 있다. 그리고 static 변수에서 final을 선언할 수 있다.

package final1;

public class FieldInit {

    static final int CONST_VALUE = 10;  // 정적 상수
    final int value = 10;  // 초기화된 인스턴스 final 변수

    // Cannot assign a value to final variable 'value'
    public FieldInit(int value) {
        this.value = value;
    }
}

하지만, 위의 코드에서는 value 값에 이미 값이 할당되었기 때문에, 생성자에서 다시 초기화를 시도하면 중복된 초기화가 되어서 컴파일 에러가 발생한다. 따라서 변수 선언 시 초기화를 하지 않고 생성자에서 초기화를 하든지, 선언 시 초기화를 하고 생성자에서는 다시 초기화하지 말아야 한다.

 

이제 위의 예제들을 실제로 사용해보자.

package final1;

public class FinalFieldMain {
    public static void main(String[] args) {
        System.out.println("--생성자로 초기화--");
        ConstructInit c1 = new ConstructInit(10);
        ConstructInit c2 = new ConstructInit(20);

        System.out.println("생성자로 초기화된 c1 값: " + c1.value);
        // c1.value = 20;  // Cannot assign a value to final variable 'value'

        System.out.println("생성자로 초기화된 c2 값: " + c2.value);

        System.out.println("--필드에서 바로 초기화--");
        FieldInit f1 = new FieldInit();
        FieldInit f2 = new FieldInit();
        FieldInit f3 = new FieldInit();

        System.out.println("멤버 변수 f1 값: "+ f1.value);
        System.out.println("멤버 변수 f1 값: "+ f2.value);
        System.out.println("멤버 변수 f1 값: "+ f3.value);

        System.out.println("--상수(CONST_VALUE) 출력--");
        System.out.println(FieldInit.CONST_VALUE);
    }
}

/*
--생성자로 초기화--
생성자로 초기화된 c1 값: 10
생성자로 초기화된 c2 값: 20
--필드에서 바로 초기화--
멤버 변수 f1 값: 10
멤버 변수 f1 값: 10
멤버 변수 f1 값: 10
--상수(CONST_VALUE) 출력--
10
*/

위의 ConstructInit과 같이 생성자를 이용해서 final 필드를 초기화 하는 경우, 각 인스턴스마다 final 필드에 각각 다른 값을 할당할 수 있다. 물론 이미 값을 할당했다면 그 값을 다시 변경할 수는 없다. 하지만, 이미 멤버 변수에서 초기화까지 진행한 FieldInit의 value는 인스턴스를 아무리 많이 생성해도 초기화된 값 10으로 고정적으로 출력되는 것을 확인할 수 있다. 아래 그림을 통해 더 자세하게 살펴보자.

FieldInit과 같이 final 필드를 필드에서 초기화하면, 모든 FieldInit 인스턴스의 값은 초기화된 값을 갖는다. 왜냐하면, 생성자 초기화와는 다르게 멤버 변수를 초기화하는 것은 초기화하는 값으로 바로 박혀버리는 것이기 때문이다. 이러면 무슨 문제가 발생할까? 인스턴스는 무지하게 많은데 모두 같은 값을 사용하기 때문에 결과적으로 보면 메모리를 낭비하는 꼴이다. 어차피 다 값이 10인데, 심지어 바뀌지도 않는다. 이런 상황은 명확히 중복이 발생한 상황이다. 바로 이럴 때 사용하면 좋은 것이 static 영역이다.

 

아까 CONST_VALUE처럼 static final을 같이 써 주면 공용 변수인데 값이 바뀌지 않게 된다. 알다시피 static 영역은 단 하나만 존재하는 영역이다. 따라서 CONST_VALUE 변수는 JVM 상에서 단 하나만 존재하므로 중복과 메모리 비효율 문제를 회피할 수 있는 것이다.

 

⛓ static final : 상수

이런 CONST_VALUE와 같은 값을 “상수” 라고 한다. 상수는 변하지 않고, 항상 같은 값을 갖는 것을 말한다. 자바에서는 단 하나만 존재하고 변하지 않는 고정된 값을 상수라 한다. 이러한 이유로 상수는 static final 키워드를 사용한다. 상수는 기능이 아니라 고정된 값 자체를 사용하는 것이 목적이다. 값이 고정되어 있기 때문에 필드에 직접 접근해서 사용한다.

package final1;

public class Constant {

    public static final double PI = 3.141592;

    public static final int HOURS_IN_DAY = 24;
    public static final int MINUTES_IN_HOUR = 60;
    public static final int SECONDS_IN_MINUTE = 60;
    
    public static final int MAX_USERS = 2000;
}

이처럼 애플리케이션 안에는 다양한 상수가 존재할 수 있다. 이런 상수들은 애플리케이션 전반에 걸쳐서 사용될 수 있기 때문에 대부분 public을 붙이는 것이 적절하다. 또한, 상수는 런타임에 변경할 수 없다. 상수를 변경하려면 프로그램을 종료하고 코드를 변경한 다음, 프로그램을 다시 실행해야 한다.

 

그리고 상수는 중앙에서 값을 관리할 수 있다는 장점이 있다. 아래 코드를 보자.

package final1;

public class ConstantMain1 {
    public static void main(String[] args) {
        System.out.println("--프로그램 최대 참여자 수: 1000명");
        int currentUserCount = 999;

        process(currentUserCount++);
        process(currentUserCount++);
        process(currentUserCount++);
        process(currentUserCount++);

    }

    private static void process(int currentUserCount) {
        System.out.println("참여자 수:" + currentUserCount);
        if (currentUserCount > 1000) {
            System.out.println("대기자로 등록합니다...");
        } else {
            System.out.println("게임에 참여합니다!");
        }
    }
}

/*
--프로그램 최대 참여자 수: 1000명
참여자 수:999
게임에 참여합니다!
참여자 수:1000
게임에 참여합니다!
참여자 수:1001
대기자로 등록합니다...
참여자 수:1002
대기자로 등록합니다...
*/

이런 코드의 문제는, 만약 프로그램에 참여할 수 있는 제한 인원수를 바꾸려고 한다면 여러 코드를 바꿔야 할 수 있다는 점이다. 그리고 지금이야 설명이 적혀 있어서 망정이지, 1000명에 대한 설명이 없다면 처음 이 코드를 본 사람은 1000명이 어떤 의미인지 알기가 힘들 것이다. 이런 것을 “Magic Number” 라고 한다.

 

이럴 때 상수를 사용하면 값을 변경할 때 일괄적으로 깔끔하게 처리할 수 있고, 의미도 아주 잘 녹아 있기 때문에 아주 좋다.

package final1;

public class ConstantMain1 {
    public static void main(String[] args) {
        System.out.println("--프로그램 최대 참여자 수: " + Constant.MAX_USERS + "명");
        int currentUserCount = 999;

        process(currentUserCount++);
        process(currentUserCount++);
        process(currentUserCount++);
        process(currentUserCount++);

    }

    private static void process(int currentUserCount) {
        System.out.println("참여자 수:" + currentUserCount);
        if (currentUserCount > Constant.MAX_USERS) {
            System.out.println("대기자로 등록합니다...");
        } else {
            System.out.println("게임에 참여합니다!");
        }
    }
}

/*
--프로그램 최대 참여자 수: 2000명
참여자 수:999
게임에 참여합니다!
참여자 수:1000
게임에 참여합니다!
참여자 수:1001
게임에 참여합니다!
참여자 수:1002
게임에 참여합니다!
*/

 

🎯 final 변수와 참조

변수에는 “기본형 변수” 와 “참조형 변수” 가 있었다. final을 기본형 변수에 사용하면 값을 변경할 수 없고, 참조형 변수에 사용하면 참조값을 변경할 수 없는 것이다. 아래 예제를 살펴보자.

package final1;

public class Data {
    public int value;
}

package final1;

public class FinalRefMain {
    public static void main(String[] args) {
        final Data data = new Data();  // 참조형 변수에 final 선언
        
        // Cannot assign a value to final variable 'data'
        // data = new Data();

        // 참조 대상의 값은 변경 가능하다.
        data.value = 10;
        System.out.println("data가 참조하는 인스턴스의 value 값 = " + data.value);
        data.value = 20;
        System.out.println("data가 참조하는 인스턴스의 value 값 = " + data.value);
    }
}

/*
data가 참조하는 인스턴스의 value 값 = 10
data가 참조하는 인스턴스의 value 값 = 20
*/

참조형 변수에 final이 붙었고, 참조형 변수 data에 이미 참조값을 할당했으므로 참조값을 변경하는 것은 불가능하다.

하지만... “참조 대상의 값은 변경이 가능하다.”

생각해보면 당연한 것이, 참조값이 고정되었다는 말은 다른 객체를 참조할 수 없다는 말이지, 그 안의 인스턴스 변수를 변경할 수 없다는 말은 아니다.