자바의 정석 12장: 지네릭스, 열거형, 애너테이션

2️⃣

[ 출처 ]
자바의 정석:
https://product.kyobobook.co.kr/detail/S000001550352
자바의 정석 유튜브:
https://www.youtube.com/playlist?list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp

12-1 지네릭스(Generics)란?

12-2 타입 변수

12-3 타입 변수에 대입하기

12-4 지네릭스 용어

12-5 지네릭 타입과 다형성

12-7 Iterator<E>

12-8 HashMap<K,V>

12-9 제한된 지네릭 클래스

12-11 지네릭스의 제약

12-12 와일드 카드<?>

12-14 지네릭 메서드

12-15 지네릭 타입의 형변환

12-16 지네릭 타입의 제거

12-17 열거형(enum)

12-18 열거형(enum)

12-19 열거형의 조상 - java.lang.Enum

12-20 열거형에 멤버 추가하기

12-23 애너테이션이란?

12-24 표준 애너테이션

12-25 @Override

12-26 @Deprecated

12-27 @FunctionalInterface

12-27 @SuppressWarnings

12-29 메타 애너테이션

12-30 @Target

12-31 @Retention

12-32 @Documented, @Inherited

12-33 @Repeatable

12-34 애너테이션 타입 정의하기

12-35 애너테이션 타입 정의하기

12-36 모든 애너테이션의 조상 - java.lang.annotation.Annotation

12-37 마커 애너테이션 - Marker Annotation

12-38 애너테이션 요소의 규칙

🌞12장 연습문제

12-1 지네릭스(Generics)란?

• 컴파일 시 타입을 체크해 주는 기능(compile-time type check) - JDK1.5

// Tv객체만 저장할 수 있는 ArrayList를 생성
ArrayList<Tv> tvList = new ArrayList<Tv>();

tvList.add(new Tv());    // OK
tvList.add(new Audio()); // 컴파일 에러. Tv 외에 다른 타입은 저장 불가 

//Tv t = (Tv)tvList.get(0);
Tv t = tvList.get(0); // 형변환 불필요

⭐

지네릭스의 장점
1. 객체의 타입 안정성을 제공한다.
2. 타입체크와 형변환을 생략할 수 있으므로 코드가 간결해진다.

<참고>

1. 객체의 타입 안정성을 높인다는 것은 의도하지 않은 타입의 객체를 저장하는 것을 막고, 저장된 객체를 꺼내올 때 원래의 타입과 다른 타입으로 형변환되어 발생할 수 있는 오류를 줄여준다는 것이다.

   → 런타임에 발생할 수 있는 에러를 컴파일 타임에 잡을 수 있다. (ClassCastException 해결)

2. JDK1.5 이후 지네릭스가 도입된 이후에는 지네릭스를 꼭 써야 한다.

   → 에러가 나는 것은 아니지만 안 좋은 코드다.

12-2 타입 변수

• 클래스를 작성할 때, Object타입 대신 타입 변수(E)를 선언해서 사용.

  JDK1.5부터 일반클래스(Object) → 지네릭 클래스(타입변수 - E)로 변경

  public class ArrayList extends AbstractList {
  	private transient Object[] elementData;
  	public boolean add(Object o) { /* 내용생략 */ }
  	public Object get(int index) { /* 내용생략 */ }
  		...
  }

  →

  public class ArrayList<E> extends AbstractList<E> {
  	private transient E[] elementData;
  	public boolean add(E o) { /* 내용생략 */ }
  	public E get(int index) { /* 내용생략 */ }
  		...
  }

12-3 타입 변수에 대입하기

• 객체를 생성 시, 타입 변수(E) 대신 실제 타입(Tv)을 지정(대입)

  // 타입 변수 E 대신에 실제 타입 Tv를 대입
  //       참조변수                     생성자
  ArrayList<Tv> tvList = new ArrayList<Tv>();

• 타입이 대입되고 나면, ArrayList의 선언에 포함된 타입 변수 E가 아래와 같이 지정된 타입으로 바뀐다고 생각하면 된다.

  public class ArrayList<E> extends AbstractList<E> {
  	private transient E[] elementData;
  	public boolean add(E o) { /* 내용생략 */ }
  	public E get(int index) { /* 내용생략 */ }
  		...
  }

  →

  public class ArrayList extends AbstractList {
  	private transient Tv[] elementData;
  	public boolean add(Tv o) { /* 내용생략 */ }
  	public Tv get(int index) { /* 내용생략 */ } // Object가 아닌 Tv를 반환
  		...
  }

• 타입 변수 대신 실제 타입이 지정되면, 형변환 생략 가능

  → 형변환만 없어져도 코드를 훨씬 간결하게 할 수 있다.

  ArrayList tvList = new ArrayList();
  tvList.add(new Tv());
  Tv t = (Tv) tvList.get(0); // get 반한 type == Object

  →

  ArrayList<Tv> tvList = new ArrayList<Tv>();
  tvList.add(new Tv());
  Tv t = tvList.get(0); // 형변환 불필요

12-4 지네릭스 용어

💡

Box<T> 지네릭 클래스, ‘T의 Box’또는 ‘T Box’라고 읽는다.

T 타입 변수 또는 타입 매개변수. (T는 타입 문자)

Box 원시 타입(raw type)

12-5 지네릭 타입과 다형성

• 참조 변수와 생성자의 대입된 타입은 일치해야 한다.

  ArrayList<Tv> list = new ArrayList<Tv>();      // Ok. 일치
  ArrayList<Product> list = new ArrayList<Tv>(); // 에러. 불일치 / 다형성처럼 Product와 Tv가 조상 자손 관계여도 안 된다.

• 지네릭 클래스간의 다형성은 성립. (여전히 대입된 타입은 일치해야)

  List<Tv> list = new ArrayList<Tv>();  // Ok. 다형성. ArrayList가 List를 구현
  List<Tv> list = new LinkedList<Tv>(); // Ok. 다형성. ArrayList가 List를 구현

• 매개변수의 다형성도 성립.

  ArrayLisst<Product> list = new ArrayList<Product>();
  list.add(new Product());
  list.add(new Tv());      // Product의 자손도 OK.
  list.add(new Audio());   // Product의 자손도 OK.

  상속 계층도 : Project ← (Tv), (Audio)

  boolean add(E e) { ... }

  →

  // Producet와 그 자손 객체 가능(다형성)
  // Product e = new Tv();
  boolean add(Product e) { ... }

• 예제 12-1

  package Test;
  
  import java.util.ArrayList;
  import java.util.List;
  
  class Product {}
  class Tv extends Product {}
  class Audio extends Product {}
  
  class Ex12_1 {
      public static void main(String[] args) {
          ArrayList<Product>    productList = new ArrayList<Product>();
          ArrayList<Tv>         tvList = new ArrayList<Tv>();
          // ArrayList<Product> tvList2 = new ArrayList<Tv>(); // 에러
          // List<Tv>              tvList3 = new ArrayList<Tv>(); // OK. 다형성
  
          productList.add(new Tv());    // public boolean add(Product e) / Product와 그 자손 OK
          productList.add(new Audio()); // 
  
          tvList.add(new Tv()); // public boolean add(Tv e) / Tv 그 자손 OK
          tvList.add(new Tv());
          // tvList.add(new Audio()); // Tv와 Audio는 어떠한 관계도 없기 때문에 넣을 수 없음
          
          printAll(productList);
          // printAll(tvList);  // 컴파일 에러가 발생한다. / ArrayList<Product> P = new ArrayList<Tv>(); 참조변수의 타입과 생성자의 타입 불일치
      }
  
      public static void printAll(ArrayList<Product> list) {
          for (Product p : list) {
              System.out.println(p);
          }
      }
  }

12-7 Iterator<E>

• 클래스를 작성할 때, Object타입 대신 T와 같은 타입 변수를 사용

  public interface Iterator {
  	boolean hasNext();
  	Object next();
  	void remove();
  }

  →

  public interface Iterator<E> {
  	boolean hasNext();
  	E next();
  	void remove();
  }

  Iterator it = list.iterator();
  while (it.hasNext()) {
  	Student s = (Student)it.next();
  }

  →

  Iterator<Student> it = list.iterator();
  while (it.hasNext()) {
  	Student s = it.next(); // 형변환 불필요
  }

• 예제 12-2

  package Test;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  
  class Main {
      public static void main(String[] args) {
          ArrayList<Student> list = new ArrayList<Student>();
          list.add(new Student("가가가", 1, 1));
          list.add(new Student("나", 1, 2));
          list.add(new Student("다324334", 2, 1));
  
          Iterator<Student> it = list.iterator();
          // Iterator it = list.iterator();
          while (it.hasNext()) {
              // Student s = it.next();
              // Student s = (Student) it.next(); // 지네릭스를 사용하지 않으면 형변환 필요.
              System.out.println(it.next().name);
          }
      }
  }
  
  class Student {
      String name = "";
      int ban;
      int no;
  
      Student(String name, int ban, int no) {
          this.name = name;
          this.ban = ban;
          this.no = no;
      }
  }

12-8 HashMap<K,V>

• 여러 개의 타입 변수가 필요한 경우, 콤마(,)를 구분자로 선언

  HashMap<String, Student> map = new HashMap<String, Student>(); // 생성
  map.put("자바", new Student("자바", 1, 1, 100, 100, 100)); // 데이터 저장

  public class HashMap<K,V> extends AbstractMap<K,V> { // 일부 생략
  			...
  	public V get(Object key) { /* 내용 생략 */ }
  	public V put(K key, V value) { /* 내용 생략 */ }
  	public V remove(Object key) { /* 내용 생략 */ }
  			...
  }

  →

  public class HashMap<K,V> extends AbstractMap<K,V> { // 일부 생략
  			...
  	public Student get(Object key) { /* 내용 생략 */ }
  	public Student put(String key, Student value) { /* 내용 생략 */ }
  	public Student remove(Object key) { /* 내용 생략 */ }
  			...
  }

  Student s1 = (Student) map.get("1-1");

  ↔

  Student s1 = map.get("1-1"); // 형변환 불필요

<추가>

• JDK1.7부터 생성자에 타입지정 생략 가능

  HashMap<String, Student> map = new HashMap<String, Student>();
  HashMap<String, Student> map = new HashMap<>(); // OK. 

• 예제 12-2

  package chapter12;
  
  import java.util.*;
  
  class Ex12_2 {
  	public static void main(String[] args) {
          HashMap<String, Student> map = new HashMap<>(); // jdk1.7부터 생성자의 타입지정 생략가능
          map.put("자바왕", new Student("자바왕", 1, 1, 100, 100, 100));
  
          // public Student get(Object key) {
          Student s = map.get("자바왕");
  
          System.out.println(map.get("자바왕").name);
  	} // main
  }
  
  class Student {
  	String name = "";
  	int ban;
  	int no;
      int kor;
      int eng;
      int math;
  
  	Student(String name, int ban, int no, int kor, int eng, int math) {
  		this.name = name;
  		this.ban = ban;
  		this.no = no;
          this.kor = kor;
          this.eng = eng;
          this.math = math;
  	}
  }

12-9 제한된 지네릭 클래스

타입 문자로 사용할 타입을 명시하면 한 종류의 타입만 저장할 수 있도록 제한할 수 있지만, 그래도 여전히 모든 종류의 타입을 지정할 수 있다는 것에는 변함이 없다. 그렇다면, 타입 매개변수 T에 지정할 수 있는 타입의 종류를 제한할 수 있는 방법은 없을까?

• extends로 대입할 수 있는 타입을 제한

  class FruitBox<T extends Fruit> { // Fruit과 그 자손만 타입으로 지정가능, Integer String 이런 거 안됨
  // class FruitBox<T> {            // 모든 타입 가능
  	ArrayList<T> list = new ArrayList<T>();
  	...
  }
  
  FruitBox<Apple> appleBox = new FruitBox<Apple>(); // OK
  FruitBox<Toy>   toyBox = new FruitBox<Toy>();     // 에러. Toy는 Fruit의 자손이 아님

  여전히 한 종류의 타입만 담을 수 있지만, Fruit 클래스의 자손들만 담을 수 있다는 제한이 더 추가되었다.

• 인터페이스인 경우에도 extends를 사용

  interface Eatable {}
  class FruitBox<T extends Eatable> { ... } // implements 안 씀

• 예제 12-3

  상속계층도

  

  package Test;
  
  import java.util.ArrayList;
  
  class Fruit implements Eatable {
      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"; }}
  
  interface Eatable {}
  
  public class Ex12_3 {
      public static void main(String[] args) {
          FruitBox<Fruit> fruitBox = new FruitBox();
          FruitBox<Apple> appleBox = new FruitBox();
          FruitBox<Grape> grapeBox = new FruitBox();
          // FruitBox<Grape> grapeBox = new FruitBox<Apple>(); // 에러. 타입 불일치
          // FruitBox<Toy> toyBox = new FruitBox(); // 에러. Toy는 Fruit의 자손 아님
  
          fruitBox.add(new Fruit());
          fruitBox.add(new Apple());
          fruitBox.add(new Grape());
          appleBox.add(new Apple());
          // appleBox.add(new Grape()); // 에러. Grape는 apple의 자손이 아님
          grapeBox.add(new Grape());
  
          System.out.println("fruitBox - " + fruitBox);
          System.out.println("appleBox - " + appleBox);
          System.out.println("grapeBox - " + grapeBox);
      } // main
  }
  
  // Fruit의 자손이고 Eatable 인터페이스를 구현한 클래스만 가능 / 인터페이스 같이쓸 땐 '&'
  class FruitBox<T extends Fruit & Eatable> extends Box<T> {}
  
  // Box는 내부적으로 ArrayList를 가지고 있음
  class Box<T> {
  	ArrayList<T> list = new ArrayList<T>();  // item을 저장할 list
  	void add(T item) { list.add(item);     } // 박스에 item을 추가
  	T get(int i)     { return list.get(i); } // 박스에서 item을 꺼낼 때
  	int size()       { return list.size(); } 
  	public String toString() { return list.toString();}
  }

12-11 지네릭스의 제약

• 타입 변수에 대입은 인스턴스 별로 다르게 가능

  Box<Apple> appleBox = new Box<Apple>(); // OK. Apple객체만 저장가능
  Box<Grape> grapeBox = new Box<Grape>(); // OK. Grape객체만 저장가능

• static멤버에 타입 변수 사용 불가

  class Box<T> {
  	static T item; // 에러
  	static int compare(T t1, T t2) { ... }  // 에러
  }

• 배열 생성할 때 타입 변수 사용불가. 타입 변수로 배열 선언은 가능

  class Box<T> {
  	T[] itemArr; // OK. T타입의 배열을 위한 참조변수
  		...
  	T[] toArray() {
  		T[] tmpArr = new T[itemArr.length]; // 에러. 지네릭 배열 생성불가
  	}
  	
  }

12-12 와일드 카드<?>

지네릭 타입에 다형성을 적용하는 방법

Q. 와일드카드는 매개변수에만 사용?

💡

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

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

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

• 하나의 참조 변수로 대입된 타입이 다른 객체를 참조 가능

  ArrayList<? extends Product> list = new ArrayList<Tv>(); // OK
  ArrayList<? extends Product> list = new ArrayList<Audio>(); // OK
  ArrayList<Product> list = new ArrayList<Tv>(); // 에러. 대입된 타입 불일치

  

• 메서드의 매개변수에 와일드 카드를 사용

  static Juice makeJuice(FruitBox<? extends Fruit> box) { // Fruit과 그 자손 가능
  	String tmp = "";
  	for (Fruit f : box.getList()) tmp += f + " ";
  	return new Juice(tmp);
  }
  
  // 둘 다 가능
  Juicer.makeJuice(new FruitBox<Fruit>());
  Juicer.makeJuice(new FruitBox<Apple>());

• 예제 12-4

  package Test;
  
  import java.util.ArrayList;
  
  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 Juice {
      String name;
  
      Juice(String name) {
          this.name = name + "Juice";
      }
  
      public String toString() {
          return name;
      }
  }
  
  class Juicer {
      // Fruit과 그 자손만 타입변수로 설정 가능
      static Juice makeJuice(FruitBox<? extends Fruit> box) {
          String tmp = "";
  
          for (Fruit f : box.getList()) {
              tmp += f + " ";
          }
  
          return new Juice(tmp);
      }
  }
  
  class Main {
      public static void main(String[] args) {
          // 저장 타입을 Fruit으로 제한
          FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
          FruitBox<Apple> appleBox = new FruitBox<Apple>();
  
          fruitBox.add(new Fruit());
          fruitBox.add(new Apple());
          fruitBox.add(new Grape()); // 매개변수의 다형성 성립 자손 Ok.
          appleBox.add(new Apple());
          appleBox.add(new Apple());
  
          System.out.println(Juicer.makeJuice(new FruitBox<Apple>()));
          // static 메서드
          System.out.println(Juicer.makeJuice(fruitBox));
          System.out.println(Juicer.makeJuice(appleBox));
          
          
      }
  }
  
  // 왜 빨간줄..? 상속을 받으면 자식 클래스에서 조상의 멤버들을 쓸 수 있으니까 지네릭 타입을 알아야해서 인듯?
  
  // Fruit과 그 자손만 타입변수로 설정 가능
  class FruitBox<T extends Fruit> extends Box<T> {}
  
  // 내부에 ArrayList를 가지고 있음
  class Box<T> {
      ArrayList<T> list = new ArrayList();
  
      // 반환타입이 T(제네릭)
      void add(T item) {
          list.add(item);
      }
  
      T get(int i) {
          return list.get(i);
      }
  
      // ArrayList를 반환
      ArrayList<T> getList() {
          return list;
      }
  
      int size() {
          return list.size();
      }
  
      @Override
      public String toString() {
          return list.toString();
      }
  }

12-14 지네릭 메서드

• 지네릭 타입이 선언된 메서드(타입 변수는 메서드 내에서만 유효)

  static <T> void sort(List<T> list, Comparator<? super T> c)

• 클래스의 타입 매개변수<T>와 메서드의 타입 매개변수 <T>는 별개

  class FruitBox<T> { // 지네릭 클래스
  		...
  	static <T> void sort(List<T> list, Comparator<? super T> c) { // 지네릭 메서드
  		...
  	}
  }

  → iv와 lv의 관계와 같다고 이해하면 됨 / 메서드 내에서는 lv가 우선되는 것처럼 지네릭 메서드 내에 있는 타입변수가 우선된다.

• 메서드를 호출할 때마다 타입을 대입해야 한다.(대부분 생략 가능)

  FruitBox<Fruit> fruitBox = new FruitBox<Fruit>();
  FruitBox<Apple> appleBox = new FruitBox<Apple>();
  
  System.out.println(Juicer.<Fruit>makeJuice(fruitBox));
  System.out.println(Juicer.<Apple>makeJuice(appleBox));

  static <T extends Fruit> Juice makeJuice(FruitBox<T> box) {
    String tmp = "";
    for (Fruit f : box.getList()) { tmp += f + " "; }
    return new Juice(tmp);
  }

  와일드카드 = 하나의 참조변수로 서로 다른 타입이 대입된 여러 지네릭 객체를 다루기 위한 것

  지네릭 메서드 = 지네릭 클래스처럼 메서드를 호출할 때마다 다른 지네릭 타입을 대입할 수 있게 한 것

  두 개의 용도는 완전히 다름 / 와일드카드가 사용불가능할 때 지네릭 메서드를 많이 쓴다.

  • ㅇ

    

• 메서드를 호출할 때 타입을 생략하지 않을 때는 클래스 이름 생략 불가

  → 생략 안 하는 경우 거의 없음 신경 안 써도 됨

  System.out.println(<Fruit>makeJuice(fruitBox));        // 에러. 클래스 이름 생략불가
  System.out.println(this.<Fruit>makeJuice(fruitBox));   // OK
  System.out.println(Juicer.<Fruit>makeJuice(fruitBox)); // Ok

12-15 지네릭 타입의 형변환

• 지네릭 타입과 원시 타입 간의 형변환은 바람직하지 않다.(경고 발생)

  Box<Object> objBox = null;  
  Box box = (Box) objBox;     // OK. 지네릭 타입 -> 원시 타입. 경고 발생
  objBox = (Box<Object>) box; // OK. 원시타입 -> 지네릭 타입. 경고 발생
  
  objBox = (Box<Object>) strBox; // 에러. Box<String> -> Box<Object>
  strBox = (Box<String>) objBox; // 에러. Box<Object> -> Box<String>
  // Box<String> b = new Box<Object>(); // 가 안 되는 맥락과 같음

  • // 같은 뜻임
    Box b = new Box<String>();
    b.add(new Integer(100));
    //Box b = (Box) new Box<String>();
    //bStr = (Box<String>) b; // Box -> Box<String> 가능 but 경고

• 와일드 카드가 사용된 지네릭 타입으로는 형변환 가능

  // Box<Object> objBox = (Box<Object>) new Box<String>(); // 에러. 형변환 불가능
  Box<? extends Object> wBox = (Box<? extends Object>) new Box<String>(); // OK
  Box<? extends Object> wBox = new Box<String>(); // 위 문장과 동일
  // Object와 그 자손 가능

  // 매개변수로 FruitBox<Fruit>, FruitBox<Apple>, FruitBox<Grape> 등이 가능
  static Juice makeJuice(FruitBox<? extends Fruit> box) {
  	FruitBox<? extends Fruit> box = new FruitBox<Fruit>(); // OK (FruitBox<? extends Fruit>) 으로 형변환이 가능하단 뜻이다.
  	FruitBox<? extends Fruit> box = new FruitBox<Apple>(); // OK
  }

• Ex12_3.java

  // FruitBox<Apple> -> FruitBox<? extends Fruit> 가능
  FruitBox<? extends Fruit> abox = new FruitBox<Apple>();
  
  // FruitBox<? extends Fruit> -? FruitBox<Apple> 가능? 가능!!!
  FruitBox<Apple> appleBox = (FruitBox<Apple>) abox; // OK. 경고발생

12-16 지네릭 타입의 제거

컴파일러는 지네릭 타입을 제거하고, 필요한 곳에 형변환을 넣는다. → 컴파일된 파일(*.class)에는 지네릭 타입에 대한 정보가 없다.

why? 지네릭이 도입되기 이전(JDK1.5 이전)의 소스 코드와의 호환성을 유지하기 위해서이다.(하위호환성)

1. 지네릭 타입의 경계(bound)를 제거

   class Box <T extends Fruit>
   	void add(T t) {
   		...
   	} 
   }

   →

   class Box {
   	void add(Fruit t) {
   		...
   	}
   }

   why? JDK1.5 이전 버전도 문제없이 돌아갈 수 있도록 하기 위해서(하위호환성)

   그래서 지네릭은 컴파일 타임에만 존재한다.

   <T> → Object (기본)

   <T extneds Fruit> → Fruit (타입이 제한된 경우에는 제한된 타입으로 )

2. 지네릭 타입 제거 후에 타입이 불일치하면, 형변환을 추가

   T get(int i) {
   	return list.get(i);
   }

   →

   Fruit get(int i) {
   	return (Fruit) list.get(i); // 반환 타입이 Object이기 때문에 형변환이 필요함
   }

   우리가 형변환을 생략한다고 해서 형변환을 안 해도 되는 것이 아니라 컴파일러가 추가를 해준다.

3. 와일드 카드가 포함된 경우, 적절한 타입으로 형변환 추가

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

   →

   static Juice makeJuice(FruitBox box) {
   	String tmp = "";
   	Iterator it = box.getList().iterator();
   	
   	while (it.hasNext()) {
   		tmp += (Fruit) it.next() + " "; // 반환 타입이 Object이므로 형변환 한다.
   	}
   
   	return new Juice(tmp);	
   }

결론 ⇒ 컴파일 타입에 지네릭 타입은 없어진다.

12-17 열거형(enum)

• 관련된 상수들을 같이 묶어 놓은 것. Java는 타입에 안전한 열거형을 제공

  Class Card {
  	static final int CLOVER = 0;
  	static final int HEART = 1;
  	static final int DIAMOND = 2;
  	static final int SPADE = 3;
  	// 카드 무늬
  
  	static final int TWO = 0;
  	static final int THREE = 1;
  	static final int FOUR = 2;
  	
  }

  →

  class Card {
      enum Kind { CLOVER, HEART, DIAMOND, SPADE }
      enum Value { TOW, THREE, FOUR }
  
  		final Kind kind;
  		final Value value;
  }

  if (Card.Kind.CLOVER == Card.Value.TWO) // 컴파일 에러. 타입이 달라서 비교 불가

  → Java의 열거형은 값&타입 모두 체크

12-18 열거형(enum)

• 열거형을 정의하는 방법

  enum 열거형이름 { 상수명1, 상수명2, ... }

• 열거형 타입의 변수를 선언하고 사용하는 방법

  enum Direction { EAST, SOUTH, WEST, NORTH }
  
  class Unit {
      int x, y;      // 유닛의 위치
      Direction dir; // 열거형 인스턴스 변수(iv)를 선언
  
      void init() {
          dir = Direction.EAST; // 유닛의 방향을 EAST로 초기화
      }
  }

• 열거형 상수의 비교에 ==와 compareTo() 사용 가능

  if (dir == Direction.EAST) { // true
      x++;
  } else if (dir > Direction.WEST) { // 에러 열거형 상수에 비교연산자 사용 불가
  
  } else if (dir.compareTo(Direction.WEST) > 0)  { // compareTo()는 사용 가능
  
  }

  compareTo() : 왼쪽이 크면 양수 / 오른쪽이 크면 음수 / 같으면 0

12-19 열거형의 조상 - java.lang.Enum

• 모든 열거형은 Enum의 자손이며, 아래의 메서드를 상속받는다.

  메서드	설명
  Class<E> getDeclaringClass()	열거형의 Class객체를 반환
  String name()	열거형 상수의 이름을 문자열로 반환
  int ordinal()	열거형 상수가 정의된 순서를 반환(0부터 시작)
  T valueOf(Class<T> enumType, String name)	지정된 열거형에서 name과 일치하는 열거형 상수를 반환

• values(), valueOf()는 컴파일러가 자동으로 추가

  static E[] values()
  static E valueOf(String name)
  
  Direction[] dArr = Direction.values();
  //Direction d = Direction.valueOf("WEST");
  
  for (Direction d : dArr) {
  	System.out.printf("%s=%d\n", d.name(), d.ordinal());
  }

열거형 상수가 객체이기 때문에 비교 연산자를 쓸 수 없고 compareTo()와 equals()를 쓴다.

• 예제 12-5

  package chapter12;
  
  enum Direction { EAST, SOUTH, WEST, NORTH }
  
  class Ex12_5 {
  	public static void main(String[] args) {
  		Direction d1 = Direction.EAST;
  		Direction d2 = Direction.valueOf("WEST");
  		Direction d3 = Enum.valueOf(Direction.class, "EAST");
  
  		System.out.println("d1="+d1);
  		System.out.println("d2="+d2);
  		System.out.println("d3="+d3);
  
  		System.out.println("d1==d2 ? "+ (d1==d2));
  		System.out.println("d1==d3 ? "+ (d1==d3));
  		System.out.println("d1.equals(d3) ? "+ d1.equals(d3)); // 하나하나가 객체이기 때문에 equals로 비교가 가능하다.
  //		System.out.println("d2 > d3 ? "+ (d1 > d3)); // 에러
  		System.out.println("d1.compareTo(d3) ? "+ (d1.compareTo(d3)));
  		System.out.println("d1.compareTo(d2) ? "+ (d1.compareTo(d2)));
  
  		switch(d1) {
  			case EAST: // Direction.EAST라고 쓸 수 없다.
  				System.out.println("The direction is EAST."); break;
  			case SOUTH:
  				System.out.println("The direction is SOUTH."); break;
  			case WEST:
  				System.out.println("The direction is WEST."); break;
  			case NORTH:
  				System.out.println("The direction is NORTH."); break;
  			default:
  				System.out.println("Invalid direction."); break;
  		}
  
  		Direction[] dArr = Direction.values(); // 열거형의 모든 상수를 배열로 반환.
  
  		for(Direction d : dArr)  // for(Direction d : Direction.values()) 
  			System.out.printf("%s=%d%n", d.name(), d.ordinal()); // 순서 
  	}
  }

12-20 열거형에 멤버 추가하기

• 불연속적인 열거형 상수의 경우, 원하는 값을 괄호()안에 적는다.

  enum Direction { EAST(1), SOUTH(5), WEST(-1), NORTH(10) } // () 생성자 호출ZZ v

• 괄호()를 사용하려면, 인스턴스 변수와 생성자를 새로 추가해 줘야 한다.

  enum Direction {
      EAST(2), SOUTH(3), WEST(-1), NORTH(10); // 끝에 ';'를 추가해야 한다.
  
      private final int value; // 정수를 저장할 필드(인스턴스 변수)를 추가
  
      // 생성자를 추가, private 생략(생성하는 항상 private이기 때문)
      Direction(int value) { this.value = value; }
  
      public int getValue() { return value; }    
  }

• 열거형의 생성자는 묵시적으로 private이므로, 외부에서 객체 생성불가

  Direction d = new Direction(1); // 에러. 열거형의 생성자는 외부에서 호출불가.

• 예제 12-6

  package chapter12;
  
  enum Direction2 { 
  	EAST(1, ">"), SOUTH(2,"V"), WEST(3, "<"), NORTH(4,"^");
  
  	private static final Direction2[] DIR_ARR = Direction2.values();
  	private final int value;
  	private final String symbol;
  
  	Direction2(int value, String symbol) { // 접근 제어자 private이 생략됨
  		this.value  = value;
  		this.symbol = symbol;
  	}
  
  	public int getValue()     { return value;  }
  	public String getSymbol() { return symbol; }
  
  	public static Direction2 of(int dir) {
          if (dir < 1 || dir > 4) 
              throw new IllegalArgumentException("Invalid value :" + dir);
  
          return DIR_ARR[dir - 1];
  	}	
  
  	// 방향을 회전시키는 메서드. num의 값만큼 90도씩 시계방향으로 회전한다.
  	public Direction2 rotate(int num) {
  		num = num % 4;
  
  		if(num < 0) num +=4; // num이 음수일 때는 시계반대 방향으로 회전 
  
  		return DIR_ARR[(value-1+num) % 4];
  	}
  
  	public String toString() {
  		return name()+getSymbol();
  	}
  } // enum Direction2
  
  
  class Ex12_6 {
  	public static void main(String[] args) {
  		for(Direction2 d : Direction2.values()) 
  			System.out.printf("%s=%d%n", d.name(), d.ordinal()); 
  
  		Direction2 d1 = Direction2.EAST;
  		Direction2 d2 = Direction2.of(2);
  
  		System.out.printf("d1=%s, %d%n", d1.name(), d1.getValue());
  		System.out.printf("d2=%s, %d%n", d2.name(), d2.getValue());
  		System.out.println(Direction2.EAST.rotate(1));
  		System.out.println(Direction2.EAST.rotate(2));
  		System.out.println(Direction2.EAST.rotate(-1));
  		System.out.println(Direction2.EAST.rotate(-2));
  	}
  }

12-23 애너테이션이란?

• 주석처럼 프로그래밍 언어에 영향을 미치지 않으며, 유용한 정보를 제공

• 애너테이션의 사용예

  // JUnit 단위 테스트 프로그램
  @Test // 이 메서드가 테스트 대상임을 테스트 프로그램에게 알린다.
  public void method() {
  	...
  }

12-24 표준 애너테이션

• Java에서 제공하는 애너테이션

12-25 @Override

• 오버라이딩을 올바르게 했는지 컴파일러가 체크하게 한다.

• 오버라이딩할 때 메서드 이름을 잘못적는 실수를 하는 경우가 많다.

  class Parent {
  	void parentMethod() { }
  }
  
  class Child extends Parent {
  	vodi parentmethod() { } // 오버라이딩하려 했으나 실수로 이름을 잘못적음
  }

• 오버라이딩할 때는 메서드 선언부 앞에 @Override를 붙이자.

  class Child extends Parent {
  	void parentMethod() { }
  }

  →

  class Child extends Parent {
  	@Override
  	void parentmethod() { }
  }

  

12-26 @Deprecated

• 앞으로 사용하지 않을 것으로 권장하는 필드나 메서드에 붙인다.

• @Deprecated의 사용 예, Date클래스의 getDate()

  @Deprecated
  public int getDate() {
      return normalize().getDayOfMonth();
  }

• Deprecated가 붙은 대상이 사용된 코드를 컴파일하면 나타나는 메시지

  

  에러 X, 경고 O

12-27 @FunctionalInterface

• 함수형 인터페이스에 붙이면, 컴파일러가 올바르게 작성했는지 체크

  함수형 인터페이스에는 하나의 추상메서드만 가져야 한다는 제약이 있음

  @FunctionalInterface
  public interface Runnable {
  	public abstract void run(); // 추상메서드
  }

12-27 @SuppressWarnings

• 컴파일러의 경고메시지가 나타나지 않게 억제한다.

• 괄호()안에 억제하고자하는 경고의 종류를 문자열로 지정

  @SuppressWarnings("unchecked")    // 지네릭스와 관련된 경고를 억제
  ArrayList list = new ArrayList(); // 지네릭 타입을 지정하지 않았음
  list.add(obj);                    // 여기서 경고가 발생

  컴파일러가 알려주는 경고를 보고 내가 확인했다는 뜻

• 둘 이상의 경고를 동시에 억제하려면 다음과 같이 한다.

  @SuppressWarnings ({"deprecation", "unchecked", "varargs", "rawypes"})

• ‘Xlint’옵션으로 컴파일하면, 경고메시지를 확인할 수 있다.

  괄호[]안이 경고의 종류. 아래의 경우 rawtypes

  

  • d

    

12-29 메타 애너테이션

→ 애너테이션을 만들 때 사용

• 메타 애너테이션은 ‘에너테이션을 위한 애너테이션’

• 메타 애너테이션은 java.lang.annotation 패키지에 포함

애너테이션	설명
@Target	애너테이션이 적용가능한 대상을 지정하는데 사용한다.
@Documented	애너테이션 정보가 javadoc으로 작성된 문서에 포함되게 한다.
@Inherited	애너테이션이 자손 클래스에 상속되도록 한다.
@Retention	애너테이션이 유지되는 범위를 지정하는데 사용한다.
@Repeatable	애너테이션을 반복해서 적용할 수 있게 한다.(JDK1.8)

12-30 @Target

• 애너테이션을 정의할 때, 적용대상 지정에 사용

  @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
  @Retention(RetentionPolicy.SOURCE)
  public @interface SuppressWarnings {
  		String[] value();
  }

  대상 타입	의미
  ANNOTATION_TYPE	애너테이션
  CONSTRUCTOR	생성자
  LOCAL_VARIABLE	지역변수
  METHOD	메서드
  PACKAGE	패키지
  PARAMETER	매개변수
  TYPE	타입(클래스, 인터페이스, enum)
  TYPE_PARAMETER	타입 매개변수(JDK1.8)
  TYPE_USE	타입이 사용되는 모든 곳(JDK1.8)

  import static java.lang.annotation.ElementType.*;
  
  @Target({FIELD, TYPE, TYPE_USE})   // 적용대상이 FIELD, TYPE, TYPE_USE
  public @interface MyAnnotation { } // MyAnnotation을 정의
  
  @MyAnnotation
  class MyClass {
  
      @MyAnnotation
      int i;        // 적용대상이 FIELD인 경우
  
      @MyAnnotation
      MyClass mc;   // 적용대상이 TYPE_USE인 경우
  }

12-31 @Retention

• 애너테이션이 유지(Retention)되는 기간을 지정하는데 사용

  유지 정책	의미
  SOURCE	소스 파일에만 존재, 클래스파일에는 존재하지 않음
  CLASS	클래스 파일에만 존재, 실행 시에 사용불가. 기본값
  RUNTIME	클래스 파일에 존재. 실행 시에 사용가능

  기본값 잘 안 씀. source랑 runtime만 알아두면 된다.

• 컴파일러에 의해 사용되는 애너테이션의 유지 정책은 SOURCE임

  @Target(ElementType.METHOD)
  @Retention(RetentionPolicy.SOURCE)
  public @interface Override {}

  ex) @Override - 오버라이딩 체크 / 컴파일러가 체크하고 끝이기 때문에 실행 시에 필요 없음ㄴ

• 실행 시에 사용 가능한 애너테이션의 정책은 RUNTIME이다.

  @Documented
  @Retention(RetentionPolicy.RUNTIME)
  @Target(ElementType.TYPE)
  public @interface FunctionalInterface {}

12-32 @Documented, @Inherited

→ 많이 사용 X, 가볍게 알아만 두면 됨

• javadoc으로 작성한 문서에 포함시키려면 @Documented를 붙인다.

  @Documented
  @Retention(RetentionPolicy.RUNTIME)
  @Target(ElementType.TYPE)
  public @interface FunctionalInterface {}

• 애너테이션을 자손 클래스에 상속하고자 할 때, @Inherited를 붙인다.

  @Inherited                    // @SuperAnno가 자손까지 영향 미치게
  @interface SuperAnno {}
  
  @SuperAnno
  class Parent {
  }
  
  class Child extends Parent {} // Child에 애너테이션이 붙은 것으로 인식

12-33 @Repeatable

• 반복해서 붙일 수 있는 애너테이션을 정의할 때 사용

  @Repeatable(ToDos.class) // ToDo애너테이션을 여러 번 반복해서 쓸 수 있게 한다.
  @interface ToDo {
  	String value();
  }

• @Repeatable이 붙은 애너테이션은 반복해서 붙일 수 있다.

  @ToDo("delete test codes.");
  @ToDo("override inherited methods");
  class MyClass {
  	...
  }

• @Repeatable인 @ToDo를 하나로 묶을 컨테이너 애너테이션도 정의해야 함

  @interface ToDos { // 여러 개의 ToDo애너테이션을 담을 컨테이너 애너테이션 ToDos
  	ToDo[] value();  // ToDo애너테이션 배열타입의 요소를 선언. 이름이 반드시 value이어야 함
  }

12-34 애너테이션 타입 정의하기

메서드인데 왜 실제 지정할 때는 변수처럼ㄷ씀?

• 애너테이션을 직접 만들어 쓸 수 있다.

  @interface 애너테이션 이름 {
  	타입 요소이름(); // 애너테이션의 요소를 선언한다.
  		...
  }

  @interface DateTime {
  	String yymmdd(); // 날짜
  	String hhmmss(); // 시간
  }

• 애너테이션의 메서드는 추상 메서드이며, 애너테이션을 적용할 때 지정(순서 X)

  @interface TestInfo {
  	int count();
  	String testedBy();
  	String[] testTools();
  	TestType testType();  // enum TestType { FIRST, FINAL }
  	Datetime testDate();  // 자신이 아닌 다른 애너테이션(@DateTime)을 포함할 수 있다.
  }

  @TestInfo( // 사용예
  	count = 3, testedBy = "Kim",
  	testTools = {"JUnit", "AutoTester"},
  	testTYpe = TestType.FIRST,
  	testDate = @DateTime(yymmdd="160101", hhmmss="235959")
  )
  
  public class NewClass { ... }

12-35 애너테이션 타입 정의하기

• 적용 시 값을 지정하지 않으면, 사용될 수 있는 기본값 지정 가능(null 제외)

  @interface TestInfo {
  	int count() default 1; // 기본값을 1로 지정
  }
  
  @TestInfo // @TestInfo(count=1)과 동일
  public class NewClass { ... }

• 요소가 하나이고 이름이 value일 때는 요소의 이름 생략간으

  @interface TestInfo {
  	String value();
  }
  
  @TestInfo("passed")
  class newClass { ... }
  

• 요소의 타입이 배열인 경우, 괄호{}를 사용해야 한다.

  @interface TestInfo {
  	String[] testTools();
  }

  @Test(testTools={"JUnit", "AutoTestar"})
  @Test(testTools={"JUnit"})
  @Test(testTools={}) // 값이 없을 때는 괄호{}가 반드시 필요

12-36 모든 애너테이션의 조상 - java.lang.annotation.Annotation

• Annotation은 모든 애너테이션의 조상이지만 상속 불가

  @interface TestInfo extends Annotation { // 에러. 허용되지 않는 표현
  	int count();
  	String testedBy();
  		...
  }

• 사실 Annotation은 인터페이스이다.

  package java.lang.annotation;
  
  public interface Annotation {
  	boolean equals(Object obj);
  	int hashCode();
  	String toString();
  
  	Class<? extedns Annotation> annotationType(); // 애너테이션의 타입을 반환
  }

모든 애너테이션의 조상은 Annotation 인터페이스이고 위와 같은 추상 메서드들을 가지고 있다.

이 추상메서드는 구현하지 않아도 사용할 수 있다. 모든 애너테이션은 추상메서드들을 포함하고 있는 셈이며 다른 요소들처럼 구현하지 않고도 사용할 수 있다.

12-37 마커 애너테이션 - Marker Annotation

• 요소가 하나도 정의되지 않은 애너테이션

  @Target (ElementType.METHOD)
  @Retention(RetentionPolicy.SOURCE)
  public @interface Override {} //  마커 애너테이션. 정의된 요소가 하나도 없다.
  
  @Target (ElementType.METHOD)
  @Retention(RetentionPolicy/SOURCE)
  public @interface Test {} //마커 애너테이션. 정의된 요소가 하나도 없다.
  

  → 대단한 건 아니고 그냥 이런 이름을 붙여서 부른다는 것만 알면 된다.

  @Test // 이 메서드가 테스트 대상임을 테스트 프로그램에게 알린다.
  public void method() {
  				...
  }
  
  @Deprecated
  public int getDate() {
  		return normalize().getDayOfMonth();
  }

  따로 할당할 값은 없지만 존재하는 것만으로도 이 애너테이션을 사용하는 프로그램에게 충분한 정보임

12-38 애너테이션 요소의 규칙

• 애너테이션의 요소를 선언할 때 아래의 규칙을 반드시 지켜야 한다.
  • 요소의 타입은 기본형, String enum, 애너테이션, Class(설계도 객체)만 허용됨
  • 괄호()안에 매개변수를 선언할 수 없다.
  • 예외를 선언할 수 없다.
  • 요소를 타입 매개변수로 정의할 수 없다.

• 아래의 코드에서 잘못된 부분은 무엇인지 생각해보자.

  @interface AnnoTest {
  	int id = 100; // 상수 OK. default 메서드 X
  	String major(int i, int j); // 괄호 안에 매개변수 선언 불가능ㄴ
  	String minor() throws Exception; // 예외 선언 안됨
  	ArrayList<T> list; // 요소를 타입 매개변수로 정의할 수 없다.
  }

걍 간단히 보고 넘어가기.. 외울필요 전혀 없음

• 예제 12-8

  package chapter12;
  
  import java.lang.annotation.*;
  import java.util.ArrayList;
  
  @Deprecated
  @SuppressWarnings("1111") // 유효하지 않은 애너테이션은 무시된다.
  @TestInfo(testedBy="aaa", testDate=@DateTime(yymmdd="160101",hhmmss="235959"))
  class Ex12_8 {
  	public static void main(String args[]) {
          ArrayList<Object> list = new ArrayList<Object>();
          list.add(3);
          
  		// Ex12_8의 Class객체를 얻는다.
  		Class<Ex12_8> cls = Ex12_8.class;
  
  		TestInfo anno = cls.getAnnotation(TestInfo.class);
  		System.out.println("anno.testedBy()="+anno.testedBy());
  		System.out.println("anno.testDate().yymmdd()=" +anno.testDate().yymmdd());
  		System.out.println("anno.testDate().hhmmss()=" +anno.testDate().hhmmss());
  
  		for(String str : anno.testTools())
  			System.out.println("testTools="+str);
  
  		System.out.println();
  
  		// Ex12_8에 적용된 모든 애너테이션을 가져온다.
  		Annotation[] annoArr = cls.getAnnotations();
  
  		for(Annotation a : annoArr)
  			System.out.println(a);
  	} // main의 끝
  }
  
  // @InitParam
  @Retention(RetentionPolicy.RUNTIME)  // 실행 시에 사용가능하도록 지정 
  @interface TestInfo {
  	int       count()	  	default 1;
  	String    testedBy();
  	String[]  testTools() 	default "JUnit";
  	TestType  testType()    default TestType.FIRST;
  	DateTime  testDate();
  }
  
  @Retention(RetentionPolicy.RUNTIME)  // 실행 시에 사용가능하도록 지정
  @interface DateTime {
  	String yymmdd();
  	String hhmmss();
  }
  
  enum TestType { FIRST, FINAL }

🌞12장 연습문제

🏅12챕터 연습문제

Uploaded by N2T