// 제네릭(Generic) - 사용 전
package com.eomcs.generic.ex01;

public class Exam0110 {
  
  // 제네릭 문법이 없다면 각 타입의 객체를 저장하기 위해 
  // 다음과 같이 각 타입에 대한 클래스를 정의해야 한다.
  //
  static class MemberBox {
    Member value;
    
    public void set(Member value) {
      this.value = value;
    }
    
    public Member get() {
      return value;
    }
  }
  
  static class StringBox {
    String value;
    
    public void set(String value) {
      this.value = value;
    }
    
    public String get() {
      return value;
    }
  }
  
  static class IntegerBox {
    Integer value;
    
    public void set(Integer value) {
      this.value = value;
    }
    
    public Integer get() {
      return value;
    }
  }
  
  public static void main(String[] args) {
    
    // Member 객체를 저장하려면 MemberBox를 사용해야 한다.
    MemberBox box1 = new MemberBox();
    box1.set(new Member("홍길동", 20)); // 값 저장
    Member m = box1.get(); // 값 꺼내기
    System.out.println(m);
    
    // String 객체를 저장하려면 StringBox를 사용해야 한다.
    StringBox box2 = new StringBox();
    box2.set(new String("Hello"));
    String str = box2.get();
    System.out.println(str);
    
    // Integer 객체는 IntegerBox를 사용해서 저장한다.
    IntegerBox box3 = new IntegerBox();
    box3.set(100); // auto-boxing ==> Integer.valueOf(100)
    int i = box3.get(); // auto-unboxing ==> box3.get().intValue() 
    System.out.println(i);
    
    // 해결책?
    // => 다양한 타입의 객체를 저장할 수 있도록 다형성의 다형적 변수 특징을 이용하여 
    //    값을 저장하는 인스턴스 변수를 Object 타입으로 정의한다.
  }
}

// 제네릭(Generic) - 사용 전: 다형적 변수 활용
package com.eomcs.generic.ex01;

public class Exam0111 {
  
  // 다양한 객체를 저장하는 Box를 만들기 위해 
  // 인스턴스의 변수 타입을 Object로 선언한다.
  // => 그러면 다음과 같이 한 개의 Box 클래스만 정의하면 된다.
  //
  static class ObjectBox {
    Object value;
    
    public void set(Object value) {
      this.value = value;
    }
    
    public Object get() {
      return value;
    }
  }
  
  public static void main(String[] args) {
    
    ObjectBox box1 = new ObjectBox();
    box1.set(new Member("홍길동", 20)); // 값 저장
    Member m = (Member) box1.get(); // 값을 꺼낼 때 형변환해야 한다.
    System.out.println(m);
    
    ObjectBox box2 = new ObjectBox();
    box2.set(new String("Hello"));
    String str = (String) box2.get(); // 값을 꺼낼 때 원래의 타입으로 형변환 한다.
    System.out.println(str);
    
    ObjectBox box3 = new ObjectBox();
    box3.set(100); // auto-boxing ==> Integer.valueOf(100)
    int i = (int) box3.get(); // 값을 꺼낼 때 primitive date type을 지정하면 
                              // 자동으로 auto-unboxing으로 바꾼다.
    System.out.println(i);
    
    // 객체의 타입 별로 Box 클래스를 구분해서 쓰지 않으니 코딩이 편하다. 
    // 단 값을 꺼낼 때 원래의 타입으로 바꾸기 위해 형변환(type casting) 해야 하는 불편함이 있다.
    //
    
    // Member 객체를 저장하기 위해 다음과 같이 Box를 준비했다고 가정하자!
    ObjectBox box2 = new ObjectBox();
    
    // 원래는 다음과 같이 Member 객체를 넣으려고 box2을 준비한 것이다.
    box1.set(new Member("홍길동", 20));
    
    // 원래의 목적과 다르게 다음과 같이 Member가 아닌 String 객체를 넣어도 막을 방법이 없다.  
    box1.set(new String("Helllo"));  
    // set()의 파라미터 타입이 모든 자바 객체를 받을 수 있는 Object이기 때문이다.
      
  }
}

public class Exam0113 {

  // Box 클래스에서 다룰 객체의 타입을 파라미터로 받는다.
  static class Box<T> {
    T value;

    public void set(T value) {
      this.value = value;
    }

    public T get() {
      return value;
    }
  }

  public static void main(String[] args) {

    // 제네릭을 사용하여 정의된 클래스를 사용할 경우에는 
    // 클래스의 레퍼런스를 정의할 때 어떤 타입의 값을 다룰 것인지 제한을 걸어야 한다.
    // 즉 지정해야 한다.
    Box<Member> box1;

    // 인스턴스를 생성할 때도 어떤 타입의 값을 다룰 것인지 지정해야 한다.
    box1= new Box<Member>();

    // 객체를 생성할 때 타입 지정을 생략할 수 있다.
    box1 = new Box<>();

    // <> 빼면 경고가 뜨며, 내부적으로는 Object를 타입으로 지정한 것으로 다룬다.
    // 즉 다음 코드는 box1 = new Box<Object>() 와 같다.
    // 
    //box1 = new Box(); // 경고!

    // 메서드를 사용할 때 그 타입 전용 클래스인 것처럼 쓰면 된다.
    box1.set(new Member("홍길동", 20));

    // 따라서 다음과 같이 값을 꺼낼 때도 따로 형변환 할 필요가 없다.
    Member m = box1.get();
    System.out.println(m);

    // 제네릭의 특징
    // => 지정한 타입 전용 클래스로 동작한다.
    // => 그래서 타입이 아닌 경우 메서드를 호출할 수 없다.
    //
    //box1.set(new String("Hello!")); // 컴파일 오류!

    // 결론:
    // => 제네릭 문법을 사용하면 Object 타입을 사용하는 것 보다 편리하다.
    // => 각 타입 별로 클래스를 따로 정의한듯한 효과가 있다.
  }
}

// 클래스명 옆에 다루고자 하는 타입의 이름을 지정한다.
ArrayList<Member> list = new ArrayList<Member>();
list.add(new Member("홍길동", 20));
//list.add(new String("Hello"));

Member member = list.get(0);
System.out.println(member.name);

// 만약 제네릭이라는 문법이 없다면?
// 1) 값을 꺼낼 때 마다 형변환을 해야 한다.
//    예) Member member = (Member) list.get(0);
//
// 2) 형변환하기 싫다면 값의 종류별로 ArrayList를 만들어야 한다.
//    예) class MemberArrayList {...}
//
// 제네릭 문법이 존재하므로,
// => 한 개의 클래스로 형변환 없이 특정 타입 전용 클래스로 만들 수 있다.

public class Exam0130 {
  // 자바에서 제안하는 "타입 파라미터"의 이름으로 정의한다면,
  static class A2<T,S,U> {
    T v1;
    S v2;
    U v3;
  }
  
  public static void main(String[] args) {
    A<String,Integer,Member> obj = new A<>();
    
    obj.v1 = new String("Hello");
    obj.v2 = new Integer(100);
    obj.v3 = new Member("홍길동", 20);
  }
}

ArrayList<Member> list = new ArrayList<Member>();

ArrayList<Member> list2 = new ArrayList</*Member*/>(); // OK!
ArrayList<Member> list3;
list3 = new ArrayList<>(); // OK!

//ArrayList<> list4; // 컴파일 오류!

  public static void main(String[] args) {
    // => 제네릭의 타입을 지정하지 않으면, 
    //    다음과 같이 다양한 종류의 ArrayList를 파라미터로 넘길 수 있다.

    m1(new ArrayList()); // OK
    m1(new ArrayList<A>()); // OK
    m1(new ArrayList<B1>()); // OK
    m1(new ArrayList<B2>()); // OK
    m1(new ArrayList<C>()); // OK
    System.out.println("실행 완료!");
  }

  // 제네릭의 타입을 지정하지 않으면 
  // 위와 같이 특정 타입으로 제한하는 문법이 무용지물이 된다.
  // 따라서 제네릭으로 선언된 클래스를 사용할 때는 반드시 타입 파라미터 값을 지정하라!
  static void m1(ArrayList list) {
    list.add(new Object());
    list.add(new A());
    list.add(new B1());
    list.add(new B2());
    list.add(new C());

    System.out.println(list.get(0));
    System.out.println(list.get(1));
    System.out.println(list.get(2));
    System.out.println(list.get(3));
    System.out.println(list.get(4));
  }

  static void m1(ArrayList<?> list) {
    /* 
    list.add(new Object());
    list.add(new A());
    list.add(new B1());
    list.add(new B2());
    list.add(new C());
     */
	
    Object obj1 = list.get(0);

    // 다음의 경우도 마찬가지로 get()의 리턴 타입이 무엇인지 결정할 수 없기 때문에 
    // 컴파일 해 줄수 없다. 그래서 컴파일 오류가 발생한다. 
    //A obj2 = list.get(1); // 컴파일 오류!

    // println()의 파라미터 타입이 Object 이기 때문에 다음 코드는 오류가 아니다.
    System.out.println(list.get(0));
    System.out.println(list.get(1));
    System.out.println(list.get(2));
    System.out.println(list.get(3));
    System.out.println(list.get(4));
  }

package com.eomcs.generic.ex01;

import java.util.ArrayList;

public class Exam0223 {

  static class A {}
  static class B1 extends A {}
  static class B2 extends A {}
  static class C extends B1 {}

  public static void main(String[] args) {
    // m1(ArrayList<B1>)
    // => B1 타입에 대해서만 ArrayList 객체를 파라미터로 넘길 수 있다.
    // => B1의 하위 타입은 불가능
    //
    ArrayList list = new ArrayList(); // 모든 타입의 객체를 다 저장할 수 있다.
    list.add(new B1());
    list.add(new String());
    list.add(new java.util.Date());
    list.add(new StringBuffer());

    m1(list); // 컴파일 오류는 아니지만, 타입을 지정하지 않는 것은 바람직하지 않다.
    // 왜?
    //  => 타입을 지정하지 않은 ArrayList에는 B1이 아닌 다른 타입의 객체가 들어갈 수 있다.
    //  => 그런데 m1()에서는 B1만 들어있을 것이라 확신하고, ArrayList를 사용할 것이다.
    //  => 그래서 m1()을 실행하는 중에 get()을 호출할 때 형변환 문제가 발생한다.

    //m1(new ArrayList<Object>()); // 컴파일 오류!
    //m1(new ArrayList<A>()); // 컴파일 오류!
    //m1(new ArrayList<B1>()); // OK!
    //m1(new ArrayList<B2>()); // 컴파일 오류!
    //m1(new ArrayList<C>()); // 컴파일 오류!
  }

  static void m1(ArrayList<B1> list) {
    // 컴파일러는 파라미터로 넘어온 ArrayList가  어떤 타입이든 간에 
    // 문법적으로 B1 타입의 값만 다룬다.

    //list.add(new Object()); // 컴파일 오류!
    //list.add(new A()); // 컴파일 오류!
    list.add(new B1());
    //list.add(new B2()); // 컴파일 오류!
    list.add(new C());

    // list에 B1 타입이 아닌 다른 타입을 저장할 때는 아무런 문제가 발생하지 않았지만,
    // ArrayList에서 값을 꺼낼 때 메서드에서 지정한 <B1> 타입이 아니면 ClassCastException 발생!
    for(int i = 0; i < list.size(); i++) {
      B1 temp = list.get(i);
      System.out.println(temp);
    }
  }
}

package com.eomcs.generic.ex01;

import java.util.ArrayList;

public class Exam0224 {

  static class A {}
  static class B1 extends A {}
  static class B2 extends A {}
  static class C extends B1 {}

  public static void main(String[] args) {
    // m1(ArrayList<? extends B1>)
    // => A 타입 및 그 하위 타입에 대해서 ArrayList 객체를 파라미터로 넘길 수 있다.
    //
    //m1(new ArrayList<Object>()); // 컴파일 오류!
    //m1(new ArrayList<A>()); // 컴파일 오류!
    m1(new ArrayList<B1>()); 
    //m1(new ArrayList<B2>()); // 컴파일 오류!
    m1(new ArrayList<C>()); 
  }

  static void m1(ArrayList<? extends B1> list) {
    // 파라미터로 받은 ArrayList가 구체적으로 어떤 타입의 값을 다루는 것인지 
    // 결정되지 않았기 때문에 컴파일러는 다음 코드가 옳은지 검사할 수 없다.
    // 그래서 컴파일 오류가 발생한다.
    //list.add(new B1()); // 컴파일 오류!

    Object obj1 = list.get(0);
    B1 obj2 = list.get(0);
    //C obj3 = list.get(0); // 컴파일 오류!
  }
}

public class Exam0231 {

  static class A {}
  static class B1 extends A {}
  static class B2 extends A {}
  static class C extends B1 {}

  public static void main(String[] args) {

    ArrayList<B1> list1 = new ArrayList<>();

    // ArrayList의 항목 타입을 B1으로 지정했기 때문에  
    // ArrayList의 메서드 파라미터나 리턴 타입은 B1으로 설정된다.

    // => add(B1)
    //list1.add(new Object()); // 컴파일 오류!
    //list1.add(new String()); // 컴파일 오류!
    //list1.add(new Integer(100)); // 컴파일 오류!
    //list1.add(new Member("홍길동", 20)); // 컴파일 오류!
    //list1.add(new A()); // 컴파일 오류!
    list1.add(new B1());
    //list1.add(new B2()); // 컴파일 오류!
    list1.add(new C());

    System.out.println("종료!");
  }
}

public class Exam0310 {
  public static void main(String[] args) {
    // 제네릭 정보가 필요한 클래스를 사용할 때는 
    // 어떤 클래스를 다룰 것인지 타입이름을 알려줘야 한다.
    // 그런데 다음 코드처럼 "key 값으로 어떤 클래스를 사용할 것이고"
    // "value 값으로 어떤 클래스를 사용할 것인지" 알려주지 않으면
    // 컴파일러가 경고를 띄운다. 물론 경고시 무시해도 실행에 문제가 없다.
    // Object 타입으로 지정하더라도 클래스 이름을 명시하는 것이 좋다.
    HashMap map = new HashMap(); // Object key, Object value를 다룬다.
    map.put("aaa", "문자열");
    map.put(new Integer(100), new Member("홍길동", 20));

    // 위와 같이 제네릭 정보를 넘기지 않는 것 보다,
    // 차라리 다음과 같이 명확하게 Object 타입을 지정하는 것이 좋다. 
    // => 어떤 타입의 key와 어떤 타입의 value를 저장할 것인지
    //    다른 개발자에게 명확하게 알려주는 효과가 있기 때문에 다음을 권장한다.
    HashMap<Object,Object> map2 = new HashMap<>();
    map2.put("aaa", "문자열");
    map2.put(new Integer(100), new Member("홍길동", 20));

    // key: String
    // value: Member
    HashMap<String,Member> map3 = new HashMap<>();
    //map3.put("aaa", "문자열"); // 컴파일 오류!
    //map3.put(new Integer(100), new Member("홍길동", 20)); // 컴파일 오류!
    map3.put("aaa", new Member("홍길동", 20)); // OK!

    // 제네릭을 지정하면 값을 꺼낼 때 형변환할 필요가 없다.
    Member m = map3.get("aaa"); // OK!

  }

public class Exam0120 {

  // 제네릭의 타입을 지정할 때 수퍼 클래스를 지정하면 그 타입 및 서브 타입만 가능하다.
  // => 다음 클래스의 타입 파라미터에는 
  //    Manager 나 그 하위 클래스만 지정할 수 있다. 
  //
  static class ArrayList<T extends Manager> {
    T[] arr;
    int index = 0;

    @SuppressWarnings("unchecked")
    public ArrayList(Class<?> clazz) {
      this.arr = (T[])Array.newInstance(clazz, 10);
    }

    public void add(T v) {
      arr[index++] = v;
    }

    public T get(int index) {
      return arr[index];
    }
  }

  public static void main(String[] args) {

    //ArrayList<Member> obj = new ArrayList<>(Member.class); // 컴파일 오류!
    //ArrayList<Teacher> obj = new ArrayList<>(Teacher.class); // 컴파일 오류!
    //ArrayList<Student> obj = new ArrayList<>(Student.class); // 컴파일 오류!

    ArrayList<Manager> obj = new ArrayList<>(Manager.class); // OK!
    //ArrayList<Administrator> obj = new ArrayList<>(Administrator.class); // OK!

    obj.add(new Manager());
    obj.add(new Administrator());

    System.out.println(obj.get(0));
    System.out.println(obj.get(1));
  }