변경 가능성을 최소화하라(불변 클래스를 만들 때 고려할 것)(3) - [4장. 클래스와 인터페이스(아이템17)]

  이전 글

• 변경 가능성을 최소화하라(불변 클래스를 만드는 다섯 가지 규칙)(1) - [4장. 클래스와 인터페이스(아이템17)]
• 변경 가능성을 최소화하라(불변 클래스의 장점, 단점, 단점 대처 방법)(2) - [4장. 클래스와 인터페이스(아이템17)]

 

  이번 글에서는 '불변 클래스를 만들 때 고려할 것'에 대해서 알아보자.

 

1. 상속을 막을 수 있는 또 다른 방법 🦓

  이전 글을 통해 불변 클래스를 보장하려면 자신을 상속하지 못하게 해야 한다는 것을 알 수 있었다. 자신을 상속하지 못하게 하는 가장 쉬운 방법으로 final 클래스에 대해서 알아보았다.

  하지만 더 유연한 방법이 있다. 모든 생성자를 private 혹은 package-private으로 만들고 public 정적 팩터리를 제공하는 방법이다.

// 1. private 생성자
public class Complex {
    private final double re;
    private final double im;

    private Complex(double re, double im) {
        this.re = re;
        this.im = im;
    }
    
    // 내부 클래스에서 상속 가능
    private static class MyComplex extends Complex {
        
        private MyComplex(double re, double im){
            super(re, im);
        }
    }
    
    ...
}

// 2. package-private 생성자
package com.item17;

public class Complex {
    private final double re;
    private final double im;

    Complex(double re, double im) {
        this.re = re;
        this.im = im;
    }
}

----------

// 같은 패키지에서 상속 가능
package com.item17; // 같은 패키지

public class MyComplex extends Complex {
    MyComplex(double re, double im) {
        super(re, im);
    }
}

  생성자를 private로 만들면 내부에서만 상속을 허용해 주는 것이고, package-private로 만들면 같은 패키지에서만 상속을 허용해 주는 것이다.

  외부에서 해당 인스턴스를 사용하기 위해서는 아래와 같이 public 정적 팩터리를 사용하면 된다.

public class Complex {
    private final double re;
    private final double im;

    private Complex(double re, double im) {
        this.re = re;
        this.im = im;
    }

    private static class MyComplex extends Complex {

        private MyComplex(double re, double im){
            super(re, im);
        }
    }
    
    // 정적 팩터리
    public static Complex valueOf(double re, double im){
        return new Complex(re, im);
    }
    
    ...
}

----------

public static void main(String[] args) {
    Complex complex = Complex.valueOf(1, 0.5);
}

  해당 방식을 사용하면 2가지 장점을 가질 수 있다.

📘 장점 1. 유연하다.

  이처럼 제한적이지만 상속을 허용하게 된다면 다양한 구체적인 클래스를 만들 수 있다는 이점이 있다. 정적 팩터리를 사용하면 내부의 구현체를 바꿀 수 있다. 아래처럼 MyComplex라는 것을 이용하여 구현체를 바꿀 수 있다. 

public class Complex {
    private final double re;
    private final double im;

    private Complex(double re, double im) {
        this.re = re;
        this.im = im;
    }

    private static class MyComplex extends Complex {

        private MyComplex(double re, double im){
            super(re, im);
        }
    }    

    public static Complex valueOf(double re, double im){
        return new MyComplex(re, im); // Complex에서 MyComplex로 변경
    }
    
    ...
}

  내부에서는 MyComplex뿐만 아니라 얼마든지 다른 구현체로 바꿀 수 있다. 내부에서 처리되는 것이기 때문에 물론 외부에서는 아무런 변경을 못 느낀다!

  이것이 final 클래스를 사용하는 것과 비교해서 더 유연하다고 하는 이유이다.

📘 장점 2. 캐싱 기능을 사용할 수 있다.

  다음 릴리스에서 객체 캐싱 기능을 추가해 성능을 끌어올릴 수도 있다. 정적 팩터리를 사용했을 때 매번 새로운 인스턴스를 만들어 주는 게 아니라 캐싱해 놓은 인스턴스를 리턴할 수 있다.

 

(추가적으로, 위의 Complex와 같은 클래스를 '사실상 final'(=effectively final)이라고 불린다. )

 

2. 재정의가 가능한 클래스는 방어적인 복사를 사용해야 한다. 🦄

  불변 클래스인데 'final 클래스' 또는 'private 또는 package-private 생성자 + 정적 팩터리'로 구현해놓지 않은 경우에는 어떻게 해야 할까? 즉, 상속을 허용해 놓았다면 어떻게 해야 할까?

public static BigInteger safeInstance(BigInteger val){

    // 방어적 복사
    return val.getClass() == BigInteger.class ?
            val : new BigInteger(val.toByteArray());
}

  위의 코드에서 인수로 받는 객체의 타입을 예측할 수 없다. BigInteger의 하위 인스턴스가 가변 객체일 수도 있기 때문이다. 이런 상황에서 안전하게 사용하려면 신뢰할 수 없는 하위 클래스의 인스턴스라고 확인되면, 이 인수들을 가변이라 가정하고 방어적으로 복사를 해서 사용해야 한다.

 

3. 모든 '외부에 공개하는' 필드가 final 이어야 한다. 🐴

  앞의 글에서 불변 클래스를 만들기 위해 '모든 필드를 private으로 선언한다'라는 규칙이 있었다. 하지만 모든 필드라는 제약을 조금 완화시킨다면 '모든 외부에 공개되어 있는 필드는 final로 선언한다'라고 할 수 있다.

public final class PhoneNumber {

    private final short areaCode, prefix, lineNum;

    public PhoneNumber(short areaCode, short prefix, short lineNum) {
        this.areaCode = areaCode;
        this.prefix = prefix;
        this.lineNum = lineNum;
    }
    
    ...
    
    private volatile int hashCode;

    @Override
    public int hashCode() {
        if(this.hashCode != 0){
            return hashCode;
        }

        synchronized (this){
            int result = hashCode;
            if(result == 0){
                result = Short.hashCode(areaCode);
                result = 31 * result + Short.hashCode(prefix);
                result = 31 * result + Short.hashCode(lineNum);
                this.hashCode = result;
            }

            return result;
        }
    }
}

  위와 같이 어떤 불변 클래스는 계산 비용이 큰 값을 나중에 (처음 쓰일 때) 계산하여 final이 아닌 필드에 캐시 해놓기도 한다. 똑같은 값을 다시 요청하면 캐시 해둔 값을 반환하여 계산 비용을 절감하는 것이다.

  하지만 이 방법은 그 객체가 불변이기 때문에 사용할 수 있는데, 몇 번을 계산해도 항상 같은 결과가 만들어짐이 보장되기 때문이다.

 

해당 글은 백기선 님의 '이펙티브 자바 완벽 공략'을 참고하였습니다.