设计一个可变长的数组类,这个类底层采用数组来实现,对外提供添加对象、删除对象、查询对象、修改对象、以及 查询元素个数、清空等操作。 为了将来有良好的扩展性,我们可以事先定义一个接口,把这些功能定义好,由

不同的类去实现这个接口,以实现不同的数据结构来存储数据。下面是一个可变长数组类的简单实现，实现了上述要求的所有操作。

public class MyArrayList<E> implements MyList<E> {
    private Object[] elements;
    private int size;
    private static final int DEFAULT_CAPACITY = 10;

    public MyArrayList() {
        elements = new Object[DEFAULT_CAPACITY];
    }

    public MyArrayList(int initialCapacity) {
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
        }
        elements = new Object[initialCapacity];
    }

    public void add(E e) {
        ensureCapacity(size + 1);
        elements[size++] = e;
    }

    public void add(int index, E e) {
        rangeCheckForAdd(index);
        ensureCapacity(size + 1);
        System.arraycopy(elements, index, elements, index + 1, size - index);
        elements[index] = e;
        size++;
    }

    public E remove(int index) {
        rangeCheck(index);
        E oldValue = elementData(index);
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            System.arraycopy(elements, index + 1, elements, index, numMoved);
        }
        elements[--size] = null;
        return oldValue;
    }

    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }

    public E set(int index, E e) {
        rangeCheck(index);
        E oldValue = elementData(index);
        elements[index] = e;
        return oldValue;
    }

    public int size() {
        return size;
    }

    public void clear() {
        for (int i = 0; i < size; i++) {
            elements[i] = null;
        }
        size = 0;
    }

    private void ensureCapacity(int minCapacity) {
        if (minCapacity - elements.length > 0) {
            grow(minCapacity);
        }
    }

    private void grow(int minCapacity) {
        int oldCapacity = elements.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        if (newCapacity > Integer.MAX_VALUE - 8) {
            throw new OutOfMemoryError();
        }
        elements = Arrays.copyOf(elements, newCapacity);
    }

    @SuppressWarnings("unchecked")
    private E elementData(int index) {
        return (E) elements[index];
    }

    private void rangeCheck(int index) {
        if (index >= size) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }

    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }

    private String outOfBoundsMsg(int index) {
        return "Index: " + index + ", Size: " + size;
    }
}

注意，这里使用了一个自定义的接口 `MyList` 来定义了这个可变长数组类的操作，它的代码如下：

public interface MyList<E> {
    void add(E e);

    void add(int index, E e);

    E remove(int index);

    E get(int index);

    E set(int index, E e);

    int size();

    void clear();
}

这样定义接口的好处是，我们可以方便地替换实现类，以实现不同的数据结构来存储数据。例如，如果我们想要使用链表来实现可变长数组，只需要编写一个实现了 `MyList` 接口的链表类即可。