4. 래퍼, Class 클래스

래퍼 클래스 - 기본형의 한계1

기본형의 한계

자바는 객체 지향 언어이다. 그런데 자바 안에 객체가 아닌 것이 있다. 바로 int, double 과 같은 기본형(primitive type)이다.

기본형은 객체가 아니기 때문에 다음과 같은 한계점이 있다.

• 객체가 아님 : 기본형 데이터는 객체가 아니기 때문에, 객체 지향 프로그래밍의 장점을 살릴 수 없다.

  • 예를 들어 기본형 데이터는 메서드를 제공할 수 없다.

  • 추가적으로 객체 참조가 필요한 제네릭, 컬렉션 프레임워크를 사용할 수 없다.

• null 값을 가질 수 없다 : 기본형 데이터 타입은 null 값을 가질 수 없다.

  • 때로는 데이터가 "없음" 이라는 상태를 나타내야 할 필요가 있는데,

  • 기본형 타입은 항상 값을 가지기 때문에 이런 표현을 할 수 없다.

아래 코드에서 보듯이 기본형 타입은 값을 비교하기 위해서 외부 메서드를 사용해서 비교해야만 한다. 이런 경우 만약 value 가 객체라면 객체 스스로 자기 자신의 값과 다른 값을 비교할 수 있는 메서드를 만드는 것이 더 유용할 것이다.

public class MyIntegerMathodMain0 {

    public static void main(String[] args) {
        int value = 10;
        int i1 = compareTo(value, 5);
        int i2 = compareTo(value, 10);
        int i3 = compareTo(value, 20);
        System.out.println("i1 = " + i1);
        System.out.println("i2 = " + i2);
        System.out.println("i3 = " + i3);
    }

    public static int compareTo(int value, int target) {
        if (value < target) {
            return -1;
        } else if (value > target) {
            return 1;
        } else {
            return 0;
        }
    }
}

직접 만든 래퍼 클래스

int 를 클래스로 만들어보자. int 는 클래스가 아니지만, int 값을 가지고 클래스를 만들면 된다.

아래 MyInteger 는 특정 기본형을 감싸서 만드는 클래스 형태인데 이를 래퍼 클래스(Wrapper class) 라고 한다.

MyInteger 클래스는 단순한 데이터 조각인 int 를 내부에 품고, 메서드를 통해 다양한 기능을 추가했다.

덕분에 데이터 조각에 불과한 int 를 MyInteger 를 통해 객체로 다룰 수 있게 되었다.

• 객체 지향적인 코드로 변신했다!

• DDD 에서도 래퍼 클래스를 통해서 도메인을 더욱 명확히 표현할 수 있다.

public class MyInteger {

    private final int value;

    public MyInteger(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public int compareTo(int target) {
        if (value < target) {
            return -1;
        } else if (value > target) {
            return 1;
        } else {
            return 0;
        }
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

public class MyIntegerMethodMain1 {

    public static void main(String[] args) {
    
        MyInteger myInteger = new MyInteger(10);
        int i1 = myInteger.compareTo(5);
        int i2 = myInteger.compareTo(10);
        int i3 = myInteger.compareTo(20);

        System.out.println("i1 = " + i1);
        System.out.println("i2 = " + i2);
        System.out.println("i3 = " + i3);
    }
}

래퍼 클래스 - 기본형의 한계2

기본형과 null

기본형은 항상 값을 가져야 한다. 하지만 때로는 데이터가 '없음' 이라는 상태가 필요할 수 있다.

객체의 경우 데이터가 없다는 null 이라는 명확한 값이 존재한다.

아래 코드에서는 래퍼 클래스를 통해서 찾는 값이 없을 때 명확하게 null 을 리턴해준다.

public class MyIntegerNullMain1 {
    public static void main(String[] args) {
        MyInteger[] intArr = {new MyInteger(-1), new MyInteger(0), new MyInteger(1)};
        System.out.println(findValue(intArr, -1));
        System.out.println(findValue(intArr, 0));
        System.out.println(findValue(intArr, 1));
        System.out.println(findValue(intArr, 1000));
    }

    private static MyInteger findValue(MyInteger[] intArr, int target) {
        for (MyInteger myInteger : intArr) {
            if (myInteger.getValue() == target) {
                return myInteger;
            }
        }
        return null;
    }
}

래퍼 클래스 - 자바 래퍼 클래스

지금까지 설명한 래퍼 클래스는 기본형을 객체로 감싸서 더 편리하게 사용하도록 도와주기 때문에, 상당히 유용하다. 쉽게 이야기해서 래퍼 클래스는 기본형의 객체 버전이다.

자바는 기본형에 대응하는 래퍼 클래스를 기본으로 제공한다.

• byte -> Byte

• short -> Short

• int -> Integer

• long -> Long

• float -> Float

• double -> Double

• char -> Character

• boolean -> Boolean

그리고 자바가 제공하는 기본 래퍼 클래스는 다음과 같은 특징을 가지고 있다.

• 불변이다.

• equals 로 비교해야 한다.

public class WrapperClassMain {
    public static void main(String[] args) {
        
        Integer newInteger = new Integer(10);   // 미래에 삭제 예정, 대신에 valueOf() 를 사용
        Integer integerObj = Integer.valueOf(10);   // -128 ~ 127 자주 사용하는 숫자 값 재사용, 불변
        System.out.println("newInteger = " + newInteger);
        System.out.println("integerObj = " + integerObj);

        Long longObj = Long.valueOf(100);
        System.out.println("longObj = " + longObj);

        Double doubleObj = Double.valueOf(10.5);
        System.out.println("doubleObj = " + doubleObj);

        System.out.println("내부 값 읽기");
        int intValue = integerObj.intValue();
        System.out.println("intValue = " + intValue);
        long longValue = longObj.longValue();
        System.out.println("longValue = " + longValue);

        System.out.println("비교");
        System.out.println("== : " + (newInteger == integerObj));
        System.out.println("equals " + (newInteger.equals(integerObj)));
    }
}

래퍼 클래스 생성 - 박싱(Boxing)

• 기본형을 래퍼 클래스로 변경하는 것을 마치 박스에 물건을 넣은 것 같다고 해서 박싱(Boxing) 이라고 한다.

• new Integer(10) 은 직접 사용하면 안된다. 자바 버전의 하위 호환성 때문에 동작은 하지만 추후에 제거 될 예정이다.

• 대신에 Integer.valueOf(10) 을 사용하면 된다.

  • 내부에서 new Integer(10) 을 사용해서 객체를 생성하고 돌려준다.

• 추가로 Integer.valueOf(10) 에는 성능 최적화(캐시) 기능이 있다. (자주 사용하는 범위의 Integer 클래스 미리 생성)

intValue() - 언박싱(Unboxing)

• 래퍼 클래스에 들어있는 기본형 값을 다시 꺼내는 메서드이다.

• 박스에 들어있는 물건을 꺼내는 것 같다고 해서 언박싱(Unboxing) 이라고 한다.

비교는 equals() 사용

• 래퍼 클래스는 객체이기 때문에, == 비교를 하면 인스턴스의 참조 값을 비교한다.

• 래퍼 클래스는 내부의 값을 비교하도록 equals() 를 재정의 해두었다. 따라서 값을 비교하려면 equals() 를 사용해야 한다.

래퍼 클래스 - 오토 박싱

오토 박싱 - Autoboxing

개발자들이 오랜기간 개발을 하다 보니 기본형을 래퍼 클래스로 변환하거나 또는 래퍼 클래스를 기본형으로 변환하는 일이 자주 발생했다. 그래서 많은 개발자들이 불편함을 호소했다.

자바는 이런 문제를 해결하기 위해서 자바 1.5 부터 오토 박싱(Auto-boxing), 오토 언박싱(Auto-Unboxing) 을 지원한다.

오토 박싱과 오토 언박싱은 컴파일러가 개발자 대신 valueOf, xxxValue 등의 코드를 추가해주는 기능이다. 덕분에 기본형과 래퍼형을 서로 편리하게 변환할 수 있다.

public class AutoBoxingMain2 {
    public static void main(String[] args) {

        int value = 7;
        Integer boxedValue = value; // 오토 박싱(Auto-boxing)

        int unboxedValue = boxedValue; // 오토 언박싱(Auto-unboxing)

        System.out.println("boxedValue = " + boxedValue);
        System.out.println("unboxedValue = " + unboxedValue);
    }
}

래퍼 클래스 - 주요 메서드와 성능

래퍼 클래스 - 주요 메서드

public class WraperUtilsMain {
    public static void main(String[] args) {
    
        Integer i1 = Integer.valueOf(10);    // 객체형 반환 
        Integer i2 = Integer.valueOf("10");  // 객체형 반환 
        int i = Integer.parseInt("10");      // 기본형 반환 
        
        // 비교 
        int compareResult = i1.compareTo(20);
        System.out.println("compareResult = " + compareResult);

        // 산술 연산
        System.out.println("sum : " + Integer.sum(10, 20));
        System.out.println("min : " + Integer.min(10, 20));
        System.out.println("max : " + Integer.max(10, 20));
    }
}

래퍼 클래스와 성능

래퍼 클래스는 객체이기 때문에 기본형보다 다양한 기능을 제공한다.

그렇다면 더 좋은 래퍼 클래스만 제공하면 되지 기본형을 제공하는 이유는 무엇일까?

public class WrapperVsPrimitive {
    public static void main(String[] args) {
        int iterations = 1_000_000_000;
        long startTime, endTime;

        // 기본형 사용
        long sumPrimitive = 0;
        startTime = System.currentTimeMillis();
        for (int i = 0; i < iterations; i++) {
            sumPrimitive += i;
        }
        endTime = System.currentTimeMillis();

        System.out.println("sumPrimitive = " + sumPrimitive);
        System.out.println(endTime - startTime + "ms");

        // Wrapper 클래스 사용
        Long sumWrapper = Long.valueOf(0L);
        startTime = System.currentTimeMillis();
        for (int i = 0; i < iterations; i++) {
            sumWrapper += i;
        }
        endTime = System.currentTimeMillis();

        System.out.println("sumWrapper = " + sumWrapper);
        System.out.println(endTime - startTime + "ms");
    }
}

실행 결과를 살펴보면 기본형 연산이 래퍼 클래스보다 5배 정도 빠른 것을 확인할 수 있다.

• 래퍼 클래스의 인스턴스는 내부에 필드로 가지고 있는 기본형의 값 뿐 아니라 자바에서 객체를 다루는데 필요한 객체 메타데이터를 포함하므로 더 많은 메모리를 사용한다. 자바 버전과 시스템마다 다르지만 약 8-16 바이트의 메모리를 더 사용한다.

기본형, 래퍼 클래스 중 어떤 것을 사용?

• 성능 차이가 나는 것은 확인했다.

• 하지만, 실제 서비스에서 10억번 정도의 연산을 하는 경우가 많을까?

• 실제 성능의 병목 지점이 아니라면 유지보수 측면에서 나은 코드를 선택하는 것이 현명하다.

Class 클래스

자바에서 Class 클래스는 클래스의 정보(메타데이터) 를 다루는데 사용된다. Class 클래스를 통해 개발자는 실행 중인 자바 애플리케이션 내에서 필요한 클래스의 속성과 메서드에 대한 정보를 조회하고 조작할 수 있다.

Class 클래스의 주요 기능은 다음과 같다.

• 타입 정보 얻기: 클래스의 이름, 슈퍼클래스, 인터페이스, 접근 제한자 등과 같은 정보를 조회할 수 있다.

• 리플렉션: 클래스에 정의된 메서드, 필드, 생성자 등을 조회하고, 이들을 통해 객체 인스턴스를 생성하거나 메서드 를 호출하는 등의 작업을 할 수 있다.

• 동적 로딩과 생성: Class.forName() 메서드를 사용하여 클래스를 동적으로 로드하고, newInstance() 메서드를 통해 새로운 인스턴스를 생성할 수 있다.

• 애노테이션 처리: 클래스에 적용된 애노테이션(annotation)을 조회하고 처리하는 기능을 제공한다.

예를 들어 String.class 는 String 클래스에 대한 Class 객체를 나타내며, 이를 통해 String 클래스에 대한 메타데이터를 조회하거나 조작할 수 있다.

public class ClassMetaMain {
    
    public static void main(String[] args) throws ClassNotFoundException {
        
        // class 조회
        Class<String> clazz = String.class;
//        Class<? extends String> clazz1 = new String().getClass();
//        Class<?> clazz2 = Class.forName("java.lang.String");

        // 모든 필드 출력
        Field[] declaredField = clazz.getDeclaredFields();
        for (Field field : declaredField) {
            System.out.println("field = " + field.getType() + " :: " + field.getName());
        }

        // 모든 메서드 출력 
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("declaredMethod = " + declaredMethod);
        }
        
        // 수퍼클래스 출력 
        Class<? super String> superclass = clazz.getSuperclass();
        System.out.println("superclass = " + superclass);

        Class<?>[] interfaces = clazz.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("anInterface = " + anInterface);
        }
    }
}

클래스 생성하기

Class 클래스에는 클래스의 모든 정보가 들어가 있다. 이 정보를 기반으로 인스턴스를 생성하거나, 메서드를 호출하고, 필드 값도 변경할 수 있다. 간단하게 인스턴스를 생성해보자.

public class Hello {
    public String hello() {
        return "hello!";
    }
}

public class ClassCreateMain {
    public static void main(String[] args) throws Exception {
        Class<Hello> helloClass = Hello.class;

        Hello hello = helloClass.getDeclaredConstructor().newInstance();
        String hello1 = hello.hello();
        System.out.println("hello1 = " + hello1); // hello!
    }
}

참고 - 리플렉션(reflection)

Class 를 사용하면 클래스의 메타 정보를 기반으로 클래스에 정의된 메서드, 필드, 생성자 등을 조회하고, 이들을 통해 객체 인스턴스를 생성하거나 메서드를 호출하는 작업을 할 수있다. 이런 작업을 리플렉션이라고 한다.

추가로 애노테이션 정보를 읽어서 특별한 기능을 수행할 수도 있다. 최신 프레임워크들은 이런 기능을 적극 활용한다.