## 과제 : 인터페이스를 사용하여 ArrayList와 LinkedList 추상화하기

목표 : `MyList<T>`라는 이름의 인터페이스를 만들어 이전에 작성한 `MyArrayList`와 `MyLinkedList` 두 클래스를 추상화한다.

요구사항 : 다음 요구사항을 만족하는 `MyList` 인터페이스를 구현하고, `MyArrayList`와 `MyLinkedList` 두 클래스가 이 인터페이스를 상속받아 동작했을 때 문제 없이 돌아가도록한다.

- `MyList<T>`는 다음과 같은 추상 메서드를 가지고 있다.
- `void add(T data)`: 리스트의 끝에 새로운 요소를 추가한다.
- `void remove(int index)`: 지정된 인덱스의 요소를 삭제하고, 삭제된 요소의 데이터를 반환한다.
- `T get(int index)`: 지정된 인덱스의 요소 데이터를 반환한다.
- `int size()`: 리스트의 크기(요소 수)를 반환한다.

## 과제 : 인터페이스를 사용하여 ArrayList와 LinkedList 추상화하기 모범답안

public interface MyList<T> {
    void add(T data);
    void remove(int index);
    T get(int index);
    int size();
}

public class MyArrayList<T> implements MyList<T> {
    private T[] array;
    private int size;

    public MyArrayList() {
        array = (T[]) new Object[10];
        size = 0;
    }

    @Override
    public void add(T value) {
        if (size >= array.length) {
            T[] newArray = (T[]) new Object[array.length * 2];
            System.arraycopy(array, 0, newArray, 0, array.length);
            array = newArray;
        }
        array[size++] = value;
    }

    @Override
    public T get(int index) {
        return array[index];
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public void remove(int index) {
        System.arraycopy(array, index + 1, array, index, size - index - 1);
        size--;
    }
}

public class MyLinkedList<T> implements MyList<T> {
    public static class Node<T> {
        T data;
        Node<T> next;

        public Node(T data) {
            this.data = data;
        }
    }

    private Node<T> head;
    private int size;

    @Override
    public void add(T value) {
        Node newNode = new Node(value);
        if (head == null) {
            head = newNode;
        } else {
            Node last = head;
            while (last.next != null) {
                last = last.next;
            }
            last.next = newNode;
        }
        size++;
    }

    @Override
    public T get(int index) {
        Node<T> node = head;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node.data;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public void remove(int index) {
        if (index == 0) {
            head = head.next;
        } else {
            Node<T> node = head;
            for (int i = 0; i < index - 1; i++) {
                node = node.next;
            }
            node.next = node.next.next;
        }
        size--;
    }
}