[CH12] Generics, Enumeration, Annotation

본 포스팅은 자바의 정석 교재를 공부하며, 간단히 정리/기록 용도로 작성하였습니다. 혹여, 잘못된 내용이 있다면 지적해주시면 감사하겠습니다.

 

 

---

1. Generics

  Generics 는 다양한 타입의 객체들을 다루는 메서드나 Collection class 에 compile 시 type checking 을 해주는 기능이다. 객체 타입을 compile - time 에 check 하므로 프로그램 안정성(의도치 않은 타입의 객체가 저장되고, 불러올 때 잘못된 캐스팅으로 인해 발생하는 오류가 줄어듦)이 높아지고 형변환 등의 작업을 없애준다.  다루고자 하는 객체의 타입을 미리 명시하여 타입 안정성을 높이고 코드가 간결해진다.

 

  class Box<T> {

T item;

 

void setItem (T item) { this.item = item; }

T getItem() { return item; }

}

 

  위와 같은 Generic class 에서 T 는 type variable 이라고 한다. 위와 같이 선언한 Box Class 의 Object 는 아래와 같이 생성할 수 있다.

 

Box<String> b = new Box<String>();

b.setItem(new Object());

b.setItem("ABC");

string item = b.getItem();

 

  Box 클래스는 class Box<T> {  } 와 같이 선언되어 있다.  Box<T> 는 Generic class 이며 T의 Box 혹은 T Box 라고 읽는다. T 는 type variable 혹은 type parameter 이며 Box 는 raw type(원시 타입) 이라고 부른다. Box 객체 생성 시, <T> 자리에 <String> 을 예시로 선언하였는데, 이때 String 은 parameterized type 이라고 한다. 

 

  Limitiation of Generics 

T[] itemArr; 와 같이 배열 타입의 참조 변수를 선언하는 것은 가능하지만 new T[10] 과 같이 배열을 생성하는 것은 허용되지 않는다. Generic 은 run - time 중에 결정되는데, new operator 은 compile 단계에서 type 가 무엇인지 정확히 알아야만 하므로 허용하지 않는 것이며, instanceof operator 도 동일한 원리로 안된다. generic array 를 생성해야 하는 필요가 있다면, new operator 대신에 Reflection API 의 newInstance() 처럼 동적 객체 생성 메서드로 배열을 만들거나, Object 배열을 생성한 다음에 T[] 로 형변환하는 것이 대안이다.

 

  Generic class 의 객체 생성과 사용

import java.util.ArrayList;

class source{
    public static void main(String[] args) {
        Box<Fruit> fruitBox = new Box<Fruit>();
        Box<Apple> appleBox = new Box<Apple>();
        Box<Toy> toyBox = new Box<Toy>();

        fruitBox.add(new Fruit());
        fruitBox.add(new Apple());

        appleBox.add(new Apple());
        appleBox.add(new Apple());

        toyBox.add(new Toy());

        System.out.println(fruitBox);
        System.out.println(appleBox);
        System.out.println(toyBox);

    }
}

class Fruit { public  String toString() { return "Fruit"; }}
class Apple extends Fruit { public  String toString() { return "Apple"; }}
class Grape extends Fruit { public  String toString() { return "Grape"; }}
class Toy { public  String toString() { return "Toy"; }}

class Box<T>{
    ArrayList<T> list = new ArrayList<T>();
    void add(T item) { list.add(item);}
    T get(int i) { return list.get(i);}
    int size() { return list.size();}
    public String toString(){ return list.toString();}
}

 

  제한된 Generic class

type 문자로 사용할 type 를 명시하면 한 종류의 type 만 저장할 수 있도록 제한할 수 있다. 하지만 type 에는 제한이 없는데, 타입 매개변수 T 에 지정할 수 있는 타입의 종류를 제한할 수 없을까? 이는 generic 타입에 extends 키워드를 사용하면 특정 타입의 자손들만 대입할 수 있도록 제한할 수 있다. 클래스가 아닌 인터페이스를 구현해야 한다는 제약이 필요하더라도 implements 키워드가 아닌 extends 키워드를 사용함에 주의하자.

import java.util.ArrayList;

class Fruit implements Eatable{
    public String toString() { return "Fruit"; }
}

interface Eatable{ }

class FruitBox<T extends Fruit & Eatable> extends Box<T> {}

class source{
    public static void main(String[] args) {
        FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
        FruitBox<Apple> appleBox = new FruitBox<>();
        FruitBox<Grape> grapeBox = new FruitBox<>();

        fruitBox.add(new Fruit());
        fruitBox.add(new Apple());
        fruitBox.add(new Grape());

        appleBox.add(new Apple());
        grapeBox.add(new Grape());

        System.out.println("fruitBox-" + fruitBox);
        System.out.println("appleBox-" + appleBox);
        System.out.println("grapeBox-" + grapeBox);
    }
}

 

  와일드 카드

Generic 타입이 다른 것 만으로는 오버로딩이 성립하지 않는다.Generic 타입을 다르게 메소드를 구현하려면 와일드 카드를 사용한다. 

 

<? extends T> 와일드 카드의 상한 제한. T와 그 자손들만 가능

<? super T> 와일드 카드의 하한 제한. T와 그 조상들만 가능

<?> 제한 없음. 모든 타입이 가능하며 <? extends Object> 와 동일함

 

import java.util.ArrayList;

class Fruit implements Eatable{
    public String toString() { return "Fruit"; }
}
interface Eatable{ }
class FruitBox<T extends Fruit & Eatable> extends Box<T> {}

class Juicer {
    static Juice makeJuice(FruitBox<? extends Fruit> box){
        String tmp = "";
        for(Fruit f : box.getList())
            tmp += f + " ";
        return new Juice(tmp);
    }
}
class Juice{
    String name;
    Juice(String name){this.name = name + "Juice";}
    public String toString() {return name;}
}

class source{
    public static void main(String[] args) {
        FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
        FruitBox<Apple> appleBox = new FruitBox<>();

        fruitBox.add(new Apple());
        fruitBox.add(new Grape());
        appleBox.add(new Apple());
        appleBox.add(new Apple());

        System.out.println(Juicer.makeJuice(fruitBox));
        System.out.println(Juicer.makeJuice(appleBox));
    }
}

class Apple extends Fruit { public  String toString() { return "Apple"; }}
class Grape extends Fruit { public  String toString() { return "Grape"; }}
class Toy { public  String toString() { return "Toy"; }}

class Box<T>{
    ArrayList<T> list = new ArrayList<T>();
    void add(T item) { list.add(item);}
    T get(int i) { return list.get(i);}
    int size() { return list.size();}
    ArrayList<T> getList() { return list; }
    public String toString(){ return list.toString();}
}

 

  Generic method

메서드 선언부에 generic type 이 선언된 method 를 말한다. 하나 유의할 점은 Generic method 를 호출할 때, 대입된 type 를 생략할 수 없는 경우에는 참조변수나 클래스 이름도 생략할 수 없다는 것이다. Generic method 를 이용하면 매개변수의 type 이 복잡한 경우 유용하다. 

 

2. Enumeration

   열거형 Direction 이 아래처럼 정의되어있다고 가정하자.

 

enum Direction { EAST, SOUTH, WEST, NORTH }

 

위의 열거형 상수 각각이 Direction 객체이며, 위를 class 로 정의하고자 한다면 아래와 같을 것이다.

 

class Direction {

static final Direction EAST = new Direction("EAST");

static final Direction SOUTH = new Direction("SOUTH");

static final Direction WEST = new Direction("WEST ");

static final Direction NORTH = new Direction("NORTH ");

 

private String name;

private Direction(String name) { this.name = name; }

}

 

  Direction Class 의 static 상수 EAST, SOUTH, WEST, NORTH 의 값은 객체의 주소이고 바뀌지 않으므로 == 로 비교가 가능하다. 또한 모든 열거형은 abstract class Enum 의 자손이므로, 대략 아래와 같이 구현되어있다.

 

abstract class MyEnum <T extends MyEnum<T>> implements Comparable<T> {

static int id = 0;

int ordinal;

String name = "";

public int ordinal() { return ordinal; }

MyEnum(String name){

this.name = name;

ordinal = id++;

}

public int compareTo(T t){

return ordinal - t.ordinal();

     }

}

 

  MyEnum 클래스를 <T extends MyEnum<T>> 와 같이 해주었기 때문에, 타입 T 는 무조건 MyEnum<T> 의 자손이어야 하는 제약이 걸리게 되고, 이러한 이유로 compareTo 를 간단하게 작성할 수 있었던 것이다. 

 

 

3. Annotation

  소스코드 안에 주석처럼 프로그램에 영향을 주지 않으면서도 다른 프로그램에게 유용한 정보를 제공하는 메모를 말한다.

 

표준 애너테이션

1. @Override

2. @Deprecated

3. @SuppressWarnings

4. @SafeVarargs

5. @Functionalinterface

6. @Native

 

메타 애너테이션

7. @Taget

8. @Documented

9. @Inherited

10. @Retention

11. @Repeatable

 

---

References

http://www.yes24.com/Product/Goods/24259565

Java의 정석 - YES24