public class 제품<T, M> {
    private T 종류;
    private M 모델;

    public T get종류() { return 종류; }

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

    public M get모델() {
        return 모델;
    }

    public void set모델(M 모델) {
        this.모델 = 모델;
    }
}


class Tv{}

public class Course<T> {
    private String 수강코스명;
    private T[] 수강인원;

     //외부에서 수강코스명과 인원수를 결정해서 만들어냄
    public Course(String 수강코스명, int capacity) {
        this.수강코스명 = 수강코스명;
        //T가 결정이 안된상태에서 배열을 생성할수 없다.
        //수강인원 = new T[capacity]    (x)
        수강인원 = (T[]) (new Object[capacity]);
    }

    public String get수강코스명() { return 수강코스명; }
    public T[] get수강인원() { return 수강인원; }

    public void add(T t) {
        for (int i = 0; i < 수강인원.length; i++) {
            if (수강인원[i] == null) {
                수강인원[i] = t;
                break;
            }
        }
    }
}

public class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() { return name; }

    @Override
    public String toString() {
        return name;
    }
}

public class Student extends Person {

    public Student(String name) {
        super(name);
    }
}

public class HighStudent extends Student {

    public HighStudent(String name) {
        super(name);
    }
}

public class Worker extends Person {
    public Worker(String name) {
        super(name);
    }
}

public class WildCardExample {
    // 수강코스의  코슴이름과  수강중인 사람들을 보여주는 메서드들     * 메서드 타입 파라미터가 다름 *
    static void registerCourse(Course<?> course) {
        System.out.println("registerCourse()메서드의 [ " + course.get수강코스명() + " ]  수강생: " + Arrays.toString(course.get수강인원()));

    }

    // Student 상위 타입을 제한
    static void registerCourseStudent(Course<? extends Student> course) {
        System.out.println("registerCourseStudent()메서드의 [ " + course.get수강코스명() + " ] 수강생: " + Arrays.toString(course.get수강인원()));
    }

    // Worker 하위 타입을 제한
    static void registerCourseWorker(Course<? super Worker> course) {
        System.out.println("registerCourseWorker()메서드의 [ " + course.get수강코스명() + " ] 수강생: " + Arrays.toString(course.get수강인원()));
    }


    public static void main(String[] args) {

        Course<Person> personCourse = new Course<Person>("사람이면 가능한 과정", 5);
        personCourse.add(new Person("일반인"));
        personCourse.add(new Worker("직장인"));
        personCourse.add(new Student("학생"));
        personCourse.add(new HighStudent("고등학생"));

        Course<Worker> workerCourse = new Course<>("직장인 과정", 5);
        workerCourse.add(new Worker("직장인"));
        workerCourse.add(new Worker("직장인"));
        //workerCourse.add(new Student("학생"));      불가능


        Course<Student> studentCourse = new Course<>("학생 과정", 5);
        studentCourse.add(new HighStudent("고등학생"));
        studentCourse.add(new Student("학생"));
        //studentCourse.add(new Person("일반인"));      불가능

        Course<HighStudent> highStudentCourse = new Course<>("고등학생 과정", 5);
        highStudentCourse.add(new HighStudent("고등학생"));
        //highStudentCourse.add(new Student("학생")); 불가능

        registerCourse(personCourse);
        registerCourse(workerCourse);
        registerCourse(studentCourse);
        registerCourse(highStudentCourse);

        //상위 타입을 제한했으므로 하위타입인  highStudentCourse 와 studentCourse 사용가능
//        registerCourseStudent(personCourse);  불가능
//        registerCourseStudent(workerCourse);  불가능
        registerCourseStudent(studentCourse);
        registerCourseStudent(highStudentCourse);

        //하위 타입을 제한했으므로 상위타입인  PersonCourse 와 workerCourse 사용가능
        registerCourseWorker(personCourse);
        registerCourseWorker(workerCourse);
//        registerCourseWorker(studentCourse);       불가능
//        registerCourseWorker(highStudentCourse);   불가능


    }
}

public class GenericMethod {
    static class Box<T> {    //box 클래스
        private T t;
        public T getT() { return t; }
        public void setT(T t) { this.t = t; }
    }
    static class Util {     // 박스를 이용해 제네릭 메소드가 있는 Util클래스
        public static <T> Box<T> boxing(T t) {
            Box<T> box = new Box<T>();
            box.setT(t);
            return box;
        }
    }
    public static void main(String[] args) {
        //1번 구체적 타입 명시              <Integer>boxing(100)  구체적타입 Integer 명시
        Box<Integer> box1 = Util.<Integer>boxing(100);
        int intValue = box1.getT();
        System.out.println(intValue);

        //2번 매개값을 보고 구체적 타입 추정.   홍길동 = String 타입
        Box<String> box2 = Util.boxing("홍길동");
        String strValue = box2.getT();
        System.out.println("strValue = " + strValue);

    }
}