용어 참조
- 타입 : 자바에서는 클래스, 추상클래스, 인터페이스, 열거형(Enum), 배열을 의미. 기본형, 참조형을 포괄하는 개념
- 기본형: byte, short, int, long, float, double, char, String, boolean (call by value)
- 참조형: 기본형을 제외한 모든 타입 (call by reference)
매개변수 vs 인자
- 매개변수(Parameter): 함수 선언할 때 변수의 이름
- 인자(Argument): 함수를 호출할 때 전달하는 값
Generic Types
generic 타입은 클래스, 인터페이스를 타입 파라미터화하는 것이다. Box 클래스는 generic 타입을 설명하면서 코드를 수정할 것이다.
A generic type is a generic class or interface that is parameterized over types. The following Box class will be modified to demonstrate the concept.
A Simple Box Class
generic을 사용하지 않은 예제로 시작해봅시다. Box 클래스는 set(추가), get(조회) 2개의 메서드가 있습니다.
Begin by examining a non-generic Box class that operates on objects of any type. It needs only to provide two methods: set, which adds an object to the box, and get, which retrieves it:
public class Box {
private Object object;
public void set(Object object) { this.object = object; }
public Object get() { return object; }
}
객체의 set, get 메서드는 기본형을 제외하면 어떤 타입(참조형)이든 인자로 넣을수 있다. Box 클래스가 사용되어지지만 컴파일 타임에 검증할 방법이 없다. 코드 일부분에서는 Integer를 넣고 Integer가 return되어지길 기대하지만 다른 일부분에서는 실수로 String을 입력해서 런타임 에러가 나올 것이다.
Since its methods accept or return an Object, you are free to pass in whatever you want, provided that it is not one of the primitive types. There is no way to verify, at compile time, how the class is used. One part of the code may place an Integer in the box and expect to get Integers out of it, while another part of the code may mistakenly pass in a String, resulting in a runtime error.
Generic 버전의 Box 클래스.
A Generic Version of the Box Class
generic 클래시는 아래 포멧처럼 정의되었다.
A generic class is defined with the following format:
class name<T1, T2, ..., Tn> { /* ... */ }
타입 파라미터 문법은 클래스명 뒤에 꺽쇠(<>) 기호로 구분된다. 이것은 T1, T2, …, and Tn 등으로 타입 매개변수를 명시한다.(타입변수라고 불리기도한다.)
The type parameter section, delimited by angle brackets (<>), follows the class name. It specifies the type parameters (also called type variables) T1, T2, …, and Tn.
Box 클래스를 generics로 변경해보자. “public class Box” 코드를 “public class Box
To update the Box class to use generics, you create a generic type declaration by changing the code “public class Box” to “public class Box
Box 클래스가 이렇게 바뀐다.
With this change, the Box class becomes:
/**
* Generic version of the Box class.
* @param <T> the type of the value being boxed
*/
public class Box<T> {
// T stands for "Type"
private T t;
public void set(T t) { this.t = t; }
public T get() { return t; }
}
소스 코드 변경에서 보이듯, 기존 코드에서 Object 대신 T로 수정되었다. Type 변수는 기본형 빼고는(=참조형)이면 된다.(클래스/인터페이스/배열 타입 또는 다른 Type 변수가 Type 변수로 될 수 있다.)
As you can see, all occurrences of Object are replaced by T. A type variable can be any non-primitive type you specify: any class type, any interface type, any array type, or even another type variable.
generic 인터페이스를 만드는 방법도 같다.
This same technique can be applied to create generic interfaces.
Type 파라미터 네이밍 관습
Type Parameter Naming Conventions
관습에 의하면, Type 파라미터는 단일 대문자입니다. 이 기준은 이미 알고 있는 변수 네이밍 관습에 극명하게 반대입니다. (좋은점은)이런 관습이 없으면 Type 변수와 일반적인 클래스 혹은 인터페이스명 사이에 차이를 전달하기 어려울겁니다.
By convention, type parameter names are single, uppercase letters. This stands in sharp contrast to the variable naming conventions that you already know about, and with good reason: Without this convention, it would be difficult to tell the difference between a type variable and an ordinary class or interface name.
일반적으로 사용되어지는 Type파라미터명
The most commonly used type parameter names are:
E - Element (자바 콜렉션 프레인워크에 광범위하게 사용됨 - used extensively by the Java Collections Framework)
K - Key
N - Number
T - Type
V - Value
S,U,V etc. - 2nd, 3rd, 4th types
이러한 이름들이 자바SE API을 통해 쓰여지는 것을 볼 수 있을 것입니다.
You’ll see these names used throughout the Java SE API and the rest of this lesson.
Generic Type 호출과 객체 생성
Invoking and Instantiating a Generic Type
코드내에 generic Box 클래스를 참조하려면, generic Type을 호출해 Integer 같은 구현값(타입값)으로 T를 교체합니다.
To reference the generic Box class from within your code, you must perform a generic type invocation, which replaces T with some concrete value, such as Integer:
Box<Integer> integerBox;
흔한 메소드 호출과 generic type 호출이 비슷하고 생각할 수 있다. 하지만 메소드에 인자를 전달하는 반면에 Box 클래스에 type 인자를 전달한다(이번에는 Integer임).
You can think of a generic type invocation as being similar to an ordinary method invocation, but instead of passing an argument to a method, you are passing a type argument — Integer in this case — to the Box class itself.
Type 파라미터’, ‘Type 인자’ 용어 설명: 많은 개발자들은 “type 파라미터”와 “type 인자”를 혼용해서 사용한다. 하지만 이 용어나 같지 않다. 코딩할 때 파라미터화한 type을 생성하기 위해서 type인자를 만든다. 그 결과, Foo
Type Parameter and Type Argument Terminology: Many developers use the terms “type parameter” and “type argument” interchangeably, but these terms are not the same. When coding, one provides type arguments in order to create a parameterized type. Therefore, the T in Foo
다른 변수를 선언하듯이, 이 코드는 새로운 Box 객체를 실제로 생성하지 않습니다. 간단히 말하면 integerBox 변수는 “Integer 타입의 Box 클래스”를 가리킨다.( Box
generic 타입 호출은 일반적으로 파라미터화된 type으로 알려져 있다.
An invocation of a generic type is generally known as a parameterized type.
클래스를 객체화할때 사용하는 new 키워드는 기존과 같지만 Generics를 위한 표기법으로
To instantiate this class, use the new keyword, as usual, but place
Box<Integer> integerBox = new Box<Integer>();
````
### 다이아몬드 연산자(<>) `The Diamond`
자바SE 7부터 컴파일러가 코드의 문맥을 보고 타입을 추론 할수 있게 되어 타입 인자가 필요한 부분에 empty type argument(빈 type 인자 = <>)를 사용할 수 있다. 꺽쇠(<>)는 비공식적이지만 다이아몬드라고 불린다. 예를 들면, Box<Integer> 객체를 생성할때 아래의 문법을 따른다:
<br>
In Java SE 7 and later, you can replace the type arguments required to invoke the constructor of a generic class with an empty set of type arguments (<>) as long as the compiler can determine, or infer, the type arguments from the context. This pair of angle brackets, <>, is informally called the diamond. For example, you can create an instance of Box<Integer> with the following statement:
```java
Box<Integer> integerBox = new Box<>();
다이아몬드 표기법과 타입 추론에 대한 더 자세한 정보는 타입 추론을 보시오.
For more information on diamond notation and type inference, see Type Inference.
복수개의 타입매개변수
Multiple Type Parameters
이전에 말했듯이, generic 클래스는 여러개의 타입매개변수를 가질수 있다. 예를들어, generic OrderdPair클래스는 generic Pair 인터페이스를 구현하였다.
As mentioned previously, a generic class can have multiple type parameters. For example, the generic OrderedPair class, which implements the generic Pair interface:
public interface Pair<K, V> {
public K getKey();
public V getValue();
}
public class OrderedPair<K, V> implements Pair<K, V> {
private K key;
private V value;
public OrderedPair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
}
아래는 OrderedPair클래스로 두개의 객체를 만드는 코드이다.
The following statements create two instantiations of the OrderedPair class:
Pair<String, Integer> p1 = new OrderedPair<String, Integer>("Even", 8);
Pair<String, String> p2 = new OrderedPair<String, String>("hello", "world");
코드는 OrderedPair
The code, new OrderedPair
이전에 다아몬드 연산자를 언급했듯이, 자바 컴파일러는 OrderedPair
As mentioned in The Diamond, because a Java compiler can infer the K and V types from the declaration OrderedPair
OrderedPair<String, Integer> p1 = new OrderedPair<>("Even", 8);
OrderedPair<String, String> p2 = new OrderedPair<>("hello", "world");
generic 인터페이스를 생성하는것은 generic 클래스를 만드는 방법과 같다
To create a generic interface, follow the same conventions as for creating a generic class.
타입 파라미터화
Parameterized Types
매개변수타입(예 K, V)은 매개변수화된 타입(예 List
You can also substitute a type parameter (i.e., K or V) with a parameterized type (i.e., List
OrderedPair<String, Box<Integer>> p = new OrderedPair<>("primes", new Box<Integer>(...));
위의 코드에서 매개변수화된 타입(Parameterized Type)은 위의 소스에서는 Box<Integer>을 의미