用多态来体会超级集合

本例子是在之前超级数组的基础上写的，大概就是建一个接口类，里面设定一些方法，再新建两个子类继承接口类，接口类里面有的方法子类全都要有，否则会报错。

在test测试类里面，可以用接口类指向子类，调用子类里面的东西。当需要换成其他子类的时候，只需把new后面的子类换成另一个子类就行，其他代码不用更改，这就是多态的好处。

当要调用子类独有的方法时，只能用子类new子类。

1、新建接口类，确定每个子类所要继承的东西

package com.xinzhi;

public interface Super {

    /**
     * 添加数据
     * @param data
     */
    void add(Integer data);

    // 删除数据
    void delete(int index);

    // 获取新的头
    Integer get(int index);

    // 修改数据
    void updata(int index,Integer newData);


    // 输出，遍历
    void print();

}

2、新建超级数组SuperArray，implements Super，用到接口类的方法之前都要加上@Override

package com.xinzhi;

// 包装超级数据
public class SuperArray implements Super{

    private int[] arr;
    private int currentIndex = -1;

    public SuperArray(int size){
        // 初始化，不初始化不能用
        arr = new int[size];
    }

    public SuperArray(){
        this(10); // 默认数组长度为10
    }


    // 更新数据
    @Override
    public void updata(int index,Integer newData){
        arr[index] = newData;
    }

    // 给数组增加一个元素
    @Override
    public void add(Integer data){
        currentIndex++; // currentIndex加完就需要扩容
        // 如果currentIndex的长度不超出数组的长度，就和原来的数据相等
        // currentIndex的长度超出数组的长度，就给数组扩容
        if (currentIndex >= arr.length){
            int[] temp = new int[arr.length*2]; // 扩容两倍
            for(int i = 0; i <arr.length; i++){
                temp[i] = arr[i];
            }
            arr = temp;
        }
        arr[currentIndex] = data;

    }

    // 给数组删除一个元素
    @Override
    public void delete(int index){
        if (index < 0 || index > currentIndex){
            System.out.println("您输入的下标不合法");
            return;
        }
        for(int i = index; i < currentIndex; i++){
            arr[i] = arr[i+1];
        }
        currentIndex--;
    }

    // 输出
    @Override
    public void print(){
        System.out.println("----结果----");
        for (int i = 0; i < currentIndex; i++) {
            System.out.println(arr[i]+" ");
        }
    }



    // 链表所调用的构造函数
    @Override
    public Integer get(int index){
        return arr[index];
    }
}

3、新建超级链表SuperLink implements Super

package com.xinzhi;

/**
 * @author 向雯雯
 * @data 2021年4月23日
 */
public class SuperLink implements Super{

    // 设置链表的头
    private Node head;

    /**
     * 添加数据
     * @param data
     */
    @Override
    public void add(Integer data){
        // 1、让这个node变成头
        Node newHead = new Node(data,null);
        // 2、让新的头指向旧的头
        newHead.setNext(head);
        // 3、让新的头变成头
        head = newHead;
    }

    // 删除数据
    @Override
    public void delete(int index){
        if (index == 0){
            Node node = getNode(index);
            head = node.getNext();
        }else{
            Node node = getNode(index-1);
            node.setNext(node.getNext().getNext());
        }

    }

    // 获取新的头
    @Override
    public Integer get(int index){
        return getNode(index).getData();
    }

    // 修改数据
    @Override
    public void updata(int index,Integer newData){
        Node node = getNode(index);
        node.setData(newData);
    }

    // 有两个地方使用到了这个循环，就抽离出来写个方法
    // 获取新的头,getNext是往下走的意思
    private Node getNode(int index){
        Node node = head;
        for (int i = 0; i < index; i++) {
            node = node.getNext();
        }
        return node;
    }

    // 输出，遍历
    @Override
    public void print(){
        Node node = head;
        // 如果node不等于空就打印，等于空就不打印
       while (node != null){
           System.out.println(node.getData());
           // node获取下一个数据
           node = node.getNext();
        }
    }

}

3、在Test上对数据进行测试

package com.xinzhi;

public class Test {

    public static void main(String[] args) {

        // 最后输入的顺序要倒数着来，get2就是倒数0,1，2；get0就是倒数0
        //Super s = new SuperLink();
        // 要查询数组或链表，只需要把new的对象进行修改就好了，减轻代码和工作量
        // 如果要调用子类独有的方法，就只能用子类去new子类
        Super s = new SuperArray();
        s.add(2);
        s.add(4);
        s.add(6);
        s.add(3);
        s.add(5);
        s.delete(4);
        s.updata(1,4);

        s.print();


    }
}