이펙티브 자바 아이템 26 - 로 타입은 사용하지 말라 - 핵심 정리
아이템 26 - 로 타입은 사용하지 말라 - 핵심 정리
이 글은 백기선 님의 이펙티브 자바 강의와 이펙티브 자바 3 / E 편을 참고하여 작성하였습니다.
제네릭은 자바 5 버전 부터 들어온 기능이다.
public class GenericBasic {
public static void main(String[] args) {
// Generic 사용하기 전
List numbers = new ArrayList();
numbers.add(10);
numbers.add("whiteship");
for (Object number: numbers) {
System.out.println((Integer)number); // 오류 발생
}
}
}제네릭이 도입되기 전에는 위와같이 List 를 타입없이 정의를 했다.
이렇게 타입없이 정의하는 걸 로 타입 이라고 한다.
타입을 정의할 수 있음에도 불구하고 선언하지 않는 걸 말한다.
로 타입 을 사용하는 경우에는 해당 컬렉션에 Object 로 값이 들어가게된다.
이렇게되면 꺼내서 사용을 할 때 오류가 발생할 가능성이 크다.
때문에 버그를 추적하기가 쉽지 않다.
public class GenericBasic {
public static void main(String[] args) {
// Generic 등장 이후
List<Integer> nuberms = new ArrayList<>();
nuberms.add(10);
nuberms.add("whiteship"); // 컴파일 에러
for (Integer number: nuberms) {
System.out.println(number);
}
}
}Generic 등장 이후에는 위와같이 사용한다.
List<Integer> 를 선언해 List 에는 Integer 밖에 넣을 수 없다.
때문에 다른 타입의 값을 넣게되는 경우 컴파일 타임에 확인이 가능해진다.
로 타입 을 사용하면 형변환 이 필요하지만 Generic 을 사용하면 형변환 이 필요없어진다.
이러한 이유로 우리는 Generic 을 사용하게 된다.
용어 정리
public class Box<E> {
private E item;
private void add(E e) {
this.item = e;
}
private E get() {
return this.item;
}
public static void main(String[] args) {
Box<Integer> box = new Box<>();
box.add(10);
System.out.println(box.get() * 100);
printBox(box);
}
private static void printBox(Box<?> box) {
System.out.println(box.get());
}
}제네릭 타입은 코드를 정의하는 입장과 사용하는 입장으로 나눠 생각하면 이해가 쉽다.
public class Box<E> {
}클래스 선언부에 Box<E> 는 해당 클래스가 E 라는 매개변수를 사용할 수 있다.
이러한 클래스를 제네릭 클래스 라고 부른다.
이떄 E 는 D 라고 해도 무방하며 선언하는 사람의 자유이다.
private E item;
private void add(E e) {
this.item = e;
}
private E get() {
return this.item;
}제네릭 클래스 는 E 라는 어떠한 타입의 매개변수를 정의할 수 있고,
해당 타입을 파라미터로 받는 메서드, return 하는 메서드를 선언할 수 있다.
이때 E 는 타입 매개변수 라고 부른다.
public static void main(String[] args) {
Box<Integer> box = new Box<>();
box.add(10);
System.out.println(box.get() * 100);
printBox(box);
}Box<E> 클래스의 E 자리에 Box<Integer> 와 같이 Integer 를 넣었다.
이때 Integer 를 실제 타입 매개변수 라고 한다.
Box<Integer> 를 매개 변수화 타입 이라고 부른다.
Integer 라는 특성이 매개 변수화 되어있는 Box 라는 타입이다.
public class Box<E> {
}위의 제네릭 클래스에서 E 는 아무거나 선언이 가능하다.
E 의 타입을 한정적으로 제한할 수 있는데
public class Box<E extends Number> {
}<E extends Number> 를 한정적 타입 매개변수 라고 한다.
Number 클래스를 상속받은 클래스들로 제한할 수 있다.
public static void main(String[] args) {
Box<Integer> box = new Box<>(); // 가능하다.
Box<String> strBox = new Box<>(); // 불가능하다.
}<E extends Number> 로 한정적 타입 매개변수 를 선언했기 때문에
Number 클래스를 상속받지 않은 String 클래스를 실제 타입 매개변수로 사용할 수 없다.
public static void main(String[] args) {
Box<?> box = new Box<>();
box.add(10);
System.out.println(box.get() * 100);
printBox(box);
}타입을 선언하는 곳에서 ? 를 사용할 수 있는데 이를 비한정적 와일드 카드 타입 이라고 한다.
<? extends Number> 처럼 extends 나 super 가 없는 경우를 비한정적 와일드 카드 타입 이라고 한다.
비한정적 와일드 카드 타입 은 아무런 타입이나 대응이 된다.
<?> 는 <? extends Object> 가 생략된 것이다.
비한정적 와일드 카드 타입 을 extends 나 super 를 써서 타입 한정을 지을 수 있다.
<? extends Number> 는 한정적 와일드 카드 타입 이라고 한다.
이러한 와일드 카드는 컬렉션에 무언가를 넣을 때 사용하는게 아닌다.
와일드 카드 타입 으로 컬렉션을 선언하면 아무것도 넣을 수 없게된다.
public class Box<E> {
private E item;
private void add(E e) {
this.item = e;
}
private E get() {
return this.item;
}
public static void main(String[] args) {
Box<Integer> box = new Box<>();
box.add(10);
box.add("string"); // 불가능 하다.
System.out.println(box.get() * 100);
printBox(box);
}
private static void printBox(Box<?> box) {
System.out.println(box.get());
}
} private static void printBox(Box<?> box) {
System.out.println(box.get());
}printBox 메서드처럼 와일드 카드 타입 은 매개변수의 타입으로 사용해야한다.
printBox 는 비한정적 와일드 카드 타입 으로 매개변수를 받기 때문에 아무런 Box 타입이나 전달이 가능하다.
Box<Integer> 와 Box<Object> 는 엄연히 다른 타입이다.
매개변수화 타입을 사용해야 하는 이유
public class GenericBasic {
public static void main(String[] args) {
// Generic 사용하기 전
List numbers = new ArrayList();
numbers.add(10);
numbers.add("whiteship");
for (Object number: numbers) {
System.out.println((Integer)number);
}
}
}Generic 을 사용하기 전에는 아무 타입이나 컬렉션에 넣을 수 있기 때문에 안정성 이 깨지게 된다.
public class GenericBasic {
public static void main(String[] args) {
// Generic 등장 이후
List<Integer> nuberms = new ArrayList<>();
nuberms.add(10);
nuberms.add("whiteship");
for (Integer number: nuberms) {
System.out.println(number);
}
}
}Generic 을 사용하면 안정성이 깨지지 않게된다.
그리고 코드에 컬렉션에 어떤 타입이 들어가게되는지 선언시에 나타낼 수 있다.
표현력 이 올라간다.
List<Integer> 를 통해 Integer 타입이 들어가게 되는 걸 명확하게 알 수 있다.
자바는 하위버전 호환성을 위해 로 타입 을 허용했다.
Generic 을 컴파일하면 모든 Generic 타입이 사라지게된다.
public class Box<E> {
private E item;
private void add(E e) {
this.item = e;
}
private E get() {
return this.item;
}
public static void main(String[] args) {
Box<Integer> box = new Box<>();
box.add(10);
System.out.println(box.get() * 100);
printBox(box);
}
private static void printBox(Box<?> box) {
System.out.println(box.get());
}
}위의 제네릭 클래스의 일부 바이트 코드를 보면
INVOKEVIRTUAL effective/code/chapter04/item26/terms/Box.get ()Ljava/lang/Object;
CHECKCAST java/lang/Integer
INVOKEVIRTUAL java/lang/Integer.intValue ()I
BIPUSH 100위처럼 전체 타입이 Object 로 되어있고
CHECKCAST java/lang/IntegerInteger 로 타입 캐스팅하는 코드가 들어가 있다.
즉, Box<Integer> 는 소스 코드에만 보이는 정보인 것이다.
사실상 컴파일 된 코드는 로 타입처럼 보이지만 Box<Integer> 를 통해 컴파일러가 Integer 로 형변환하는 코드를 넣어주게된다.
우리는 코드를 편하게 작성하지만 컴파일된 코드 중간 중간에 로 타입 을 쓰던 버전과 비슷하게
타입을 캐스팅 하는 코드가 들어가게 된다.
실질적으로 컴파일된 클래스 파일에서는 로 타입 이 사용되고 소스 코드에서도 로 타입 이 지원된다.
자바의 하위버전 호환성을 유지하기 위함이다.
List 와 List<Object> 의 차이
// 코드 26-4 런타임에 실패한다. - unsafeAdd 메서드가 로 타입(List)을 사용 (156-157쪽)
public class Raw {
public static void main(String[] args) {
List<String> strings = new ArrayList<>();
unsafeAdd(strings, Integer.valueOf(42));
String s = strings.get(0); // 컴파일러가 자동으로 형변환 코드를 넣어준다.
}
private static void unsafeAdd(List list, Object o) {
list.add(o);
}
}그렇다면 raw 타입과 Object 타입에는 어떤 차이가 있을까?
unsafeAdd 메서드를 보면 매개변수 타입을 굉장히 넓은 범위로 받고 있다.
어떤 값이 오던지 List 에 값을 넣어주게 된다.
위의 코드에서는 잘못된 값을 넣을 때 에러가 발생하는게 아니라 잘못된 값을 꺼낼 때 에러가 발생한다.
private static void unsafeAdd(List<Object> list, Object o) {
list.add(o);
}매개변수 타입을 위처럼 변경하면 값을 아예 넣을 수없다.
List<String> 과 List<Object> 다른 타입이기 때문이다.
때문에 조금 더 안전한 코드를 사용할 수 있게된다.
private static void unsafeAdd(List list, Object o) {
list.add(o);
}List 와 같이 로 타입 을 사용하는 것을 타입 안정성을 잃었다 라고 한다.
Set 과 Set<?>의 차이
public class Numbers {
static int numElementsInCommon(Set s1, Set s2) {
int result = 0;
for (Object o1 : s1) {
if (s2.contains(o1)) {
result++;
}
}
return result;
}
public static void main(String[] args) {
System.out.println(Numbers.numElementsInCommon(Set.of(1, 2, 3), Set.of(1, 2)));
}
}numElementsInCommon 메서드는 전달받은 두 개의 Set 에서 공통인자의 갯수를 세는 메서드이다.
코드를 실행해보면 원하는 값이 잘 나온다.
하지만 위처럼 로 타입 을 사용하면 안정성 이 깨지게 된다.
매개변수로 아무 타입의 Set 을 전달할 수 있게된다.
static int numElementsInCommon(Set s1, Set s2) {
s1.add("AWDASDASD");
int result = 0;
for (Object o1 : s1) {
if (s2.contains(o1)) {
result++;
}
}
return result;
}위처럼 해당 컬렉션에 아무거나 넣을 수 있게된다.
static int numElementsInCommon(Set<?> s1, Set<?> s2) {
s1.add("AWDASDASD");
int result = 0;
for (Object o1 : s1) {
if (s2.contains(o1)) {
result++;
}
}
return result;
}위처럼 Set<?> 로 매개변수를 받도록 수정한다.
<?> 를 사용하면 어떠한 타입이든 한 종류의 타입을 가지고 있는 Set 을 의미한다,
System.out.println(Numbers.numElementsInCommon(Set.of(1, 2, 3), Set.of(1, 2)));위의 코드에서 Set.of(1, 2, 3) 는 하나 종류의 타입 만을 다루고 있다.
때문에 numElementsInCommon(Set<?> s1, Set<?> s2) 에 매개변수로 전달 할 수 있다.
Set<?> 이 어떠한 타입이라도 담을 수 있는 가장 범용적인 매개변수화 Set 타입 이다.
Set<Integer> 이나 Set<String> 도 Set<?> 로 받을 수 있다.
Set 와 Set<?> 의 차이점은 안정성이다.
Set 에는 아무거나 추가할 수 있지만 Set<?> 에는 null 외에는 아무것도 넣을 수 없다.
때문에 안전한 Set 이 된다.
모든 경우에 제네릭에 타입을 선언해 사용하는 것이 좋은 습관이다.
단, 두가지의 예외가 있는데
public class UseRawType<E> {
private E e;
public static void main(String[] args) {
System.out.println(UseRawType.class); //UseRawType<Integer>.class -> 컴파일 에러
UseRawType<String> stringType = new UseRawType<>();
System.out.println(stringType instanceof UseRawType);
}
}UseRawType.class 처럼 .class 는 매개변수화 타입과 같이 사용할 수 없다.
UseRawType<Integer>.class 은 컴파일 했을 시 존재하지 않기 때문이다.
<Integer> 는 컴파일시 소거되기 때문에 UseRawType 라는 클래스만 남기 때문이다.
다른 경우로는 instanceof 가 있다.
stringType instanceof UseRawType<Integer> 처럼 제네릭 타입을 사용할 수는 있지만 어처피 소거되기 때문에 의미가 없다.
instanceof 에서 제네릭 타입을 사용하는 것은 코드를 장황하게 만들 뿐이다.
.class 와 instanceof 를 사용하는 경우를 제외하고 모두 매개변수화 타입 을 사용하는 것을 권장한다.