一、线性表（通过接口，抽象类和非抽象子类实现）

public interface MyList {

    /**
     * add方法：将一个新元素添加到线性表的尾部。
     * @param e 新元素
     */
    public void add(Object e);

    /**
     * add方法：将一个新元素插入到线性表中索引号为index的位置。
     * @param index 插入位置
     * @param e 新元素
     */
    public void add(int index, Object e);

    /**
     * clear方法：清空线性表（回到初始的缺省状态）
     */
    public void clear();

    /**
     * contains方法：判断线性表中是否包含指定元素e
     * @param e 元素
     * @return 如果包含，则返回true；否则返回false。
     */
    public boolean contains(Object e);

    /**
     * get方法：从线性表中获取索引号为index的元素。
     * @param index 元素的索引号
     * @return 元素
     */
    public Object get(int index);

    /**
     * indexOf方法：在线性表中从左往右查找指定元素e
     * @param e 指定元素
     * @return 若找到，返回元素的索引号（如果有多个元素与e匹配，则返回最左边匹配元素的索引号）；否则返回-1
     */
    public int indexOf(Object e);

    /**
     * isEmpty方法：判断线性表是否为空（即有没有任何元素）
     * @return 如果为空，则返回true；否则返回false
     */
    public boolean isEmpty();

    /**
     * lastIndexOf方法：在线性表中从右往左查找指定元素e
     * @param e 指定元素
     * @return 若找到，返回元素的索引号（如果有多个元素与e匹配，则返回最右边匹配元素的索引号）；否则返回-1
     */
    public int lastIndexOf(Object e);

    /**
     * remove方法：从线性表中删除指定元素e，若有多个元素匹配，则删除首次匹配的元素。
     * @param e 要删除的元素
     * @return 如果删除成功，则返回true；否则返回false。
     */
    public boolean remove(Object e);

    /**
     * remove方法：从线性表中删除索引号为index的元素。
     * @param index 要删除的元素的索引号
     * @return 被删除的元素
     */
    public Object remove(int index);

    /**
     * set方法：使用指定的元素e替换线性表中索引号为index的元素。
     * @param index 被替换的元素的索引号
     * @param e 新元素
     * @return 被替换的旧元素
     */
    public Object set(int index, Object e);

    /**
     * size方法：返回当前线性表的长度（元素个数）。
     * @return 线性表的长度
     */
    public int size();

}

这个接口声明了所有的方法，但是没有具体的实现。

public abstract class MyAbstractList implements MyList {
    //创建protected修饰的整型变量size为线性表的长度
   protected int size = 0;

    /**
     * 创建其无参构造
     */
   protected MyAbstractList() {}

    /**
     * 创建有参构造，使用传入的数组创建线性表，可以是一切类型的数组对象
     * @param objects 传入的数组
     */
    protected MyAbstractList(Object[] objects) {
        for(int i=0; i<objects.length; i++) {
            add(objects[i]);
        }
        size = objects.length;
    }

    /**
     * add方法：将一个新元素添加到线性表的尾部。
     * @param e 新元素
     */
    public void add(Object e) {
        add(size,e);
    }
    

    /**
     * isEmpty方法：判断线性表是否为空（即有没有任何元素）
     * @return 如果为空，则返回true；否则返回false
     */
    public boolean isEmpty() {
        if(size == 0) {
            return true;
        }else {
            return false;
        }
    }
    

    /**
     * size方法：返回当前线性表的长度（元素个数）。
     * @return 线性表的长度
     */
    public int size() {
        return size;
    }
    

    /**
     * remove方法：从线性表中删除指定元素e，若有多个元素匹配，则删除首次匹配的元素。
     * @param e 要删除的元素
     * @return 如果删除成功，则返回true；否则返回false。
     */
    public boolean remove(Object e) {
        if(indexOf(e) >= 0) {
            remove(indexOf(e));
            return true;
        }else {
            return false;
        }
    } 
}

创建一个抽象类以实现接口，因为它是一个抽象类，所以可以不用去实现接口中所有的方法，只用于实现一些公共的通用的方法，把具体有关存储的方法留给子类去实现。

public class MyArrayList extends MyAbstractList {
    public static final int CAPACITY = 100;
    Object[] data = new Object[CAPACITY];

    /**
     * 创建缺省线性表（空表）
     */
   public MyArrayList() {}

    /**
     * 创建全参构造方法，使用传入的数组创建线性表
     * @param objects 传入的数组
     */
   public MyArrayList(Object[] objects) {
       for(int i=0; i<objects.length; i++) {
           add(objects[i]);
       }
   }

    /**
     * add方法：将一个新元素插入到线性表中索引号为index的位置
     * 并将插入位置处及其后面的所有元素向右移动一个位置。
     * @param index 插入位置
     * @param e 新元素
     */
   public void add(int index, Object e) {
       for(int i=size-1; i>=index; i--) {
           data[i+1] = data[i];
       }
       data[index] = e;
       size++;
   }

    /**
     * remove方法：从线性表中删除索引号为index的元素
     * 并将后面的所有元素向左移动一个位置。
     * @param index 要删除的元素的索引号
     * @return 被删除的元素
     */
    public Object remove(int index) {
        Object e = data[index];
        for(int i=index; i<size-1; i++) {
            data[i] = data[i+1];
        }
        data[size-1] = null;
        size--;
        return e;
    }

    /**
     *set方法：使用指定的元素e替换线性表中索引号为index的元素
     *并返回被替换的那个旧元素。
     * @param index 被替换的元素的索引号
     * @param e 新元素
     * @return 被替换的旧元素
     */
    public Object set(int index, Object e) {
        Object old = data[index];
        data[index] = e;
        return old;
    }

    /**
     * 重写toString()，返回线性表中的元素。
     * 使用了StringBuffer类
     */
    @Override
    public String toString() {
        StringBuffer result = new StringBuffer("[");
        for(int i=0; i<size; i++) {
            result.append(data[i]);
            if(i<size-1)
                result.append(", ");
        }
        return result.toString() + "]";
    }

    /**
     * clear方法：清空线性表（回到初始的缺省状态）。
     */
    public void clear() {
        data = new Object[CAPACITY];
        size = 0;
    }

    /**
     * contains方法：如果线性表中包含元素e,则返回true；否则返回false。
     * @param e 元素
     * @return 如果包含，则返回true；否则返回false。
     */
    public boolean contains(Object e) {
        for(int i=0; i<size; i++) {
            if(data[i].equals(e)) {
                return true;
            }
        }
        return false;
    }

    /**
     * get方法：从线性表中获取索引号为index的元素。
     * @param index 元素的索引号
     * @return 元素
     */
   public Object get(int index) {
       return data[index];
   }

    /**
     * index方法：在线性表中从左往右查找指定元素e，若找到，则返回该元素的索引号；
     * 如果有多个元素与e匹配，则返回最左边匹配元素的索引号；
     * 如果找不到，则返回-1。
     * @param e 指定元素
     * @return 若找到，返回元素的索引号；否则返回-1
     */
    public int indexOf(Object e) {
        for(int i=0; i<size; i++) {
            if(data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * lastIndexOf方法：在线性表中反向（从右往左）查找指定元素e，若找到，则返回该元素的索引号；
     * 如果有多个元素与e匹配，则返回最右边匹配元素的索引号；
     * 如果找不到，则返回-1。
     * @param e 指定元素
     * @return 若找到，返回元素的索引号；否则返回-1
     */
    public int lastIndexOf(Object e) {
        for(int i=size-1; i>=0; i--) {
            if(data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }
}

1.是接口的具体实现类，也是MyAbstractList的子类；

2. @Override
    public String toString() {
        StringBuffer result = new StringBuffer("[");
        for(int i=0; i<size; i++) {
            result.append(data[i]);
            if(i<size-1)
                result.append(", ");
        }
        return result.toString() + "]";
    }

这里StringBuffer是引用类型，必须实例化才能使用，第一句是为了初始化起始边界，而用StringBuffer是因为数组不固定，append用以拼接字符。最后用toString()方法是为了固定其长度。

public class TestMain {
    public static void main(String[] args) {
        //创建新的字符串数组[北京, 上海, 深圳, 广州, 太原, 西安, 重庆]
        String[] s = {"北京", "上海", "深圳", "广州", "太原", "西安", "重庆"};
        //使用多态，声明接口类MyList对象list,实例化MyArrayList对象并调用其有参构造将字符串数组传入线性表中
        MyList list = new MyArrayList(s);
        //打印输出数组元素
        System.out.println(list);
        //在索引为4的位置处插入新元素"太原"并打印输出数组元素
        list.add(4, "太原");
        System.out.println(list);
        //删除索引为2处的元素并打印输出数组元素
        list.remove(2);
        System.out.println(list);
        //将数组中的元素"广州"替换为"成都"并打印输出数组元素
        list.set(2, "成都");
        System.out.println(list);
        //查询数组中是否有元素"西安"
        System.out.println(list.contains("西安"));
        //清空数组并打印输出
        list.clear();
        System.out.println(list);
    }
}

初始化数组元素，实例化线性表，并进行相关操作。