public class ArrayList<E> {
    static final int DEFAULT_CAPACITY = 3;
    Object[] elementData;
    int size = 0;
    
    public ArrayList() {
        if (initialCapacity <= DEFAULT_CAPACITY) {
            elementDAta = new Object 
        }
    }
    
    public ArrayList(int initialCapacity) {
        if (initialCapacity <= DEFAULT_CAPACITY) {
            elementData = new Object[DEFAULT_CAPACITY];
        } else {
            elementData = new Object[initialCapacity];
        }
    }
    
    public boolean add(E e) {
        if (size == elementData.length)
            grow():
        elementData[size++] = e;
        return true;
    }
    
    private void grow() {
        int newCapacity = elementData.length + (elementData.length >> 1);
    }
    
    public void add(int index, E element) {
        if(size == elementData.length) {
            grow();
        }
        if (index <= 0 || index > size) {
            throw new ArrayIndexOutOfBoundsException("인덱스가 유효하지 않습니다.");
        }
        for (int i = size; i > index; i--) {
            elementData[i] = elementData[i - 1];
        }
        elementData[index] = element;
        size++;
    }
    
    // suppress: 참다, 억누르다.
    @SuppressWarning("unchecked")
    public E get(int index) {
        if(index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException("인덱스가 유효하지 않습니다.");
        }
        return (E) elementData[index];
    }
    
    @SuppressWarning("unchecked")
    public E set(int index, E element) {
        if (index <0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException("인덱스가 유효하지 않습니다.");
        }
        Object old = elementData[index];
        elementData[index] = element;
        return (E) old;
    }
    
    @SuppressWarning("unchecked")
    public E remove(int index) {
        Object old = elementData[index];
        
        System.arraycopy(
            elementData, // 복사 대상
            index + 1, // 복사할 항목의 시작 인덱스
            elementData, // 목적지
            index, // 복사 목적지 인덱스
            this.size - (index + 1) // 복사할 항목의 개수
            );
        size--;
        elementData[size] = null;
        return (E) old;
    }
    
    public int size() {
        return this.size();
    }
    
    public Object[] toArray() {
        Object[] arr = Arrays.copyOf(elementData, this.size);
        return arr;
    }
    
    @SuppressWarning("unchecked")
    public E[] toArray(E[] arr) {
        if (arr.length < this.size) {
            return (E[]) Arrays.copyOf(this.elementData, this.size, arr.getClass());
        }
        System.arraycopy(this.elementData, 0, arr, 0, this.size);
        return arr;
    }
}

public class BoardHandler {

  ArrayList<Board> boardList = new ArrayList<>();

  public void add() {
    System.out.println("[게시물 등록]");

    Board board = new Board();
    board.setNo(Prompt.inputInt("번호? "));
    board.setTitle(Prompt.inputString("제목? "));
    board.setContent(Prompt.inputString("내용? "));
    board.setWriter(Prompt.inputString("작성자? "));
    board.setRegisteredDate(new Date(System.currentTimeMillis()));
    board.setViewCount(0);

    boardList.add(board);

    System.out.println("게시글을 등록하였습니다.");
  }
}

public void detail() {
    System.out.println("[게시물 상세보기]");
    int no = Prompt.input("번호? ");
    Board board = findByNo(no);
    
    if (board == null) {
        System.out.println("해당 번호의 게시물이 없습니다.");
        return;
    }
    
    board.setViewCount(board.getViewCount() + 1);

    System.out.printf("제목: %s\n", board.getTitle());
    System.out.printf("내용: %s\n", board.getContent());
    System.out.printf("작성자: %s\n", board.getWriter());
    System.out.printf("등록일: %s\n", board.getRegisteredDate());
    System.out.printf("조회수: %d\n", board.getViewCount());
}

private Board findByNo(int no) {
    for (int i = 0; i < boardList.size(); i++) {
        Board board = boardList.get(i);
        if (board.getNo() == no) {
            return board;
        }
        return null;
    }
}

public void update() {
    System.out.println("[게시물 변경]");
    int no = Prompt.inputInt("번호? ");
    Board board = findByNo(no);
    
    if(board == null) {
        System.out.println("해당 번호의 게시글이 없습니다.");
        return;
    }
    
    String title = Prompt.inputString(
    	String.format("제목(%s)? ", board.getTitle()));
    String content = Prompt.inputString(
    	String.format("내용(%s)? ", board.getContent()));
    String content = Prompt.inputString(
    	String.format("작성자(%s)? ", board.getWriter()));
    
    String response = Prompt.inputString("정말 변경하시겠습니까?(y/N)");
    if (!response.equalsIgnoreCase("y")) {
        System.out.println("게시글 변경을 취소하였습니다.");
        return;
    }
    
    board.setTitle(title);
    board.setContent(content);
    board.setWriter(writer);
    System.out.println("게시글을 변경하였습니다.");
}

private int indexOf(int no) {
    for (int i = 0; i < boardList.size(); i++) {
        Board board = boardList.get(i);
        if (board.getNo() == no) {
            return i;
        }
    }
    return -1;
}

public void delete() {
    System.out.println("[게시물 삭제]");
    int no = Prompt.inputInt("번호? ");
    int index = indexOf(no);
    
    if (index == -1) {
        System.out.println("해당 번호의 게시물이 없습니다.");
        return;
    }
    
    String response = Prompt.inputString("정말 삭제하시겠습니까?(y/N)");
    if (!response.equalsIgnoreCase("y")) {
        System.out.println("게시물 삭제를 취소하였습니다.");
        return;
    }
    boardList.remove(index);
    System.out.println("게시물을 삭제하였습니다.");
}

// 제네릭(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); 
    int i = (int) box3.get(); 
    System.out.println(i);
    
    // Member 객체를 저장하기 위해 다음과 같이 Box를 준비했다고 가정하자!
    ObjectBox box2 = new ObjectBox();
    
    
    // 원래의 목적과 다르게 다음과 같이 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<>();

    // => 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: Object
    // key: Object
    HashMap map = new HashMap();
    map.put("aaa", "문자열");
    map.put(new Integer(100), new Member("홍길동", 20));
	
    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!

  }

//             Member

//          /     |       \

//     Teacher  Student  Manager

//                          |

//                     Administrator

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));
  }