1.열거형(enum)

• 서로 연관된 상수들의 집합
• 주로 몇 가지 한정된 변하지 않는 데이터를 다루는데 사용
• 여러 상수들 편리하게 선언 및 관리 가능
• 상수명 중복 피하고 타입에 대한 안정성 보장

enum  Scale {Good, Neutral, Bad}

public class Main{
  public static void main(String[] args){
    Scale scale= Scale.Good;
    switch(scale){
      case Good:
        System.out.println("좋음");
        break;
      case Neutral:
        System.out.println("중립");
        break;
      case Bad:
        System.out.println("나쁨");
        break;
      }
    }
  }  
---------------
좋음

2.제네릭

• 데이터 타입을 일반화한다는 것을 의미
• <>안에 들어갈 타입 지정
• 외부 사용자에 의해 지정되는 것을 의미

2-1.장점

1. 잘못된 타입이 들어올 수 있는 것을 컴파일 단계에서 방지
2. 클래스 외부에서 타입을 지정하므로 별도 타입 체크 및 변환 필요 없음 (관리 용이)
3. 비슷한 기능을 지원하는 경우 코드 재사용성 향상

2-2.제네릭 사용 방법

• 일반적인 제네릭 타입

타입	설명
<T>	Type
<E>	Element
<K>	Key
<V>	Value
<N>	Number

1)클래스 및 인터페이스 선언

public class ClassName<T>{...}
public interface Interface<T>{...}

-----
* 제네릭 타입 두 개 생성(예-HashMap)
public className <T,K> {...}
public interface Interface<T,K>{...}

데이터 타입 외부 지정

2)제네릭 클래스

• 제네릭이 사용된 클래스를 의미
• 클래스 변수에는 타입 매개변수 사용 불가(private 이외 불가)

  class Entry<T>{
    private T team1; // 가능
    static T team2; // 불가능

• 제네릭스 내 extends ClassName 또는 &을 사용해 제네릭스 제한 가능

• 제네릭스 예)

class ClassName<E>{
    private E element; // 제네릭 타입 변수
    void set(E element){  // 제네릭 파라미터 메소드
        this.element = element;
    }
    E get(){// 제네릭 타입 반환 메소드
        return element;
    }
}
public class Main{
    public static void main(String[] args) {
        ClassName<String> a = new ClassValue<String>();
        ClassName<Integer> b = new ClassValue<Integer>();

        a.set("10");
        b.set(10);

        System.out.println("a data : "+a.get());
        //반환된 변수 타입 출력
        System.out.println("a E type : "+a.get().getClass().getName() );

        System.out.println();
        System.out.println("b data : "+b.get());
        //반환된 변수 타입 출력
        System.out.println("b E type : "+b.get().getClass().getName() );
    }

}
------------------------------------------
(출력 결과)
a data : 10
a E Type : java.lang.String

b data : 10
b E Type : java.lnag.Integer

• a객체 ClassName의 E 제네릭 타입은 String으로 모두 변환
• b객체 ClassName의 E 제네릭 타입은 Integer로 모두 변환

3) 제네릭 메소드

• 메소드에 한정한 제네릭 사용하기

• 선언 방법

public <T> T genericMethod(T o){ // 제네릭 메소드
  ...
}

[접근 제어자] <제네릭타입> [반환타입] [메소드명]([제네릭타입] [파라미터]){
  // 텍스트
}  
* 클래스와는 다르게 반환 타입 이전에 <> 제네릭 타입 선언

• 선언하기

class ClassName<E>{
    private E element; // 제네릭 타입 변수
    void set(E element){  // 제네릭 파라미터 메소드
        this.element = element;
    }
    E get(){// 제네릭 타입 반환 메소드
        return element;
    }
    <T> T genericMethod(T o){  // 제네릭 메소드
        return o;
    }
}
public class Main{
    public static void main(String[] args) {
        ClassName<String> a = new ClassValue<String>();
        ClassName<Integer> b = new ClassValue<Integer>();

        a.set("10");
        b.set(10);

        System.out.println("a data : "+a.get());
        //반환된 변수 타입 출력
        System.out.println("a E type : "+a.get().getClass().getName() );

        System.out.println();
        System.out.println("b data : "+b.get());
        //반환된 변수 타입 출력
        System.out.println("b E type : "+b.get().getClass().getName() );

        //제네릭 메소드 Integer
        System.out.println("<T> returnType : "+a.genericMethod(3).getClass().getName());
        //제네릭 메소드 String
        System.out.println("<T> returnType : "+a.genericMethod("ABCD").getClass().getName());
        //제네릭 메소드 ClassName b
        System.out.println("<T> returnType : "+a.genericMethod(b).getClass().getName());
    }

}
------------------------------------------------
(출력)
a data : 10
a E Type : java.lang.String

b data : 10
b E Type : java.lang.Integer

<T> returnType : java.lang.Integer
<T> returnType : java.lang.String
<T> returnType : ClassName

• 클래스에서 지정한 제네릭 유형과 별도로 메소드에서 독립적인 제네릭 유형 선언해 사용 가능

4) 와일드 카드

• 어떤 타입으로든 대체될 수 있는 타입의 파라미터

• ?기호로 사용하며 일반적으로 extends와 super 키워드 조합해 사용

  <? extends T> // 상한 제한 - T와 그 이하 클래스 타입만 파라미터 가능
  
   <? super T> // 하한 제한 - T와 그 이상 클래스 타입만 파라미터 가능