2022-07-25 第八小组 田龙月 学习笔记

单链表（每一种东西都可以是一类对象）

节点对象：数据+下一个节点。C语言的指针直接变成对象：C语言是指向下一个地址=在java中可以直接引用“对象”

链表对象：大小(存储数据的个数)+第一个节点+最后一个节点

因为我们的单链表的特点：查找不方便(没有下表)，所以只能从first开始遍历，这是我们的查找方法

其他方法：删除指定位置元素，添加元素到指定位置，添加元素到末尾，改变指定位置元素，逻辑不算太难但要注意维护first，last和size，删除时还要注意也要把需要滞空的指针域指控（不足：可能少了一些逻辑，拿到指定索引位置元素的代码比那个没有复用，写了很多遍）

点击查看节点类代码

/**
 *  单向
 */
public class Node {

    private Integer data; //数据域C
    private Node next;//指针域C

    public Integer getData() {
        return data;
    }

    public void setData(Integer data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    public Node() {
    }

    public Node(Integer data, Node next) {
        this.data = data;
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                ", next=" + next +
                '}';
    }
}

点击查看单链表代码

public class SuperLinked {
    // 链表的长度
    private int size;
    // 链表的第一个结点
    private Node first;
    // 链表的最后一个结点
    private Node last;

    // 无参构造器
    public SuperLinked() {
    }

    // 把数组添加到链表的尾部
    public boolean add(Integer data){
        // 把传入的数据构建成一个结点
        Node node = new Node(data,null);
        // 如果现在链表是空的，那我就是第一个结点
        if(first == null) {
            first = node;
        }else {
            // 如果链表不是空，那我就是最后一个结点
            // 我应该是在原来的last结点后面
            // 我是原来last结点的下一个结点
            last.setNext(node);
        }
        last = node;
        size++;
        return true;
    }
    public Integer getSize(){
        return  size;
    }

    public Integer getValue(Integer index){
        return getNode(index).getData();
    }
//获取到索引位置节点
    private Node getNode(int index){
        if(index < 0){
            index = 0;
        }
        if(index >= size - 1){
            index = size - 1;
        }
        // 找到第index个
        Node cursor = first;
        for (int i = 0; i < index; i++) {
            cursor = cursor.getNext();
        }
        return cursor;
    }
    public void add(Integer index,Integer value){
        Node node=new Node(value,null);
        if(index==0){
            node.setNext(first);
            first=node;
            size++;
        }else if (index>0&&index<size){
            Node cursor=first;
            for (int i = 1; i < index; i++) {
                cursor=cursor.getNext();
            }
            node.setNext(cursor.getNext());
            cursor.setNext(node);
            size++;
        }else {
//            System.out.println("索引位置不存在，添加到末尾");
            add(value);
        }
    }
    public void delete(){
        Node cursor=first;
        for (int i = 0; i < size-2; i++) {
            cursor=cursor.getNext();
        }
        cursor.setNext(null);
        last=cursor;
        size--;
    }
    public void delete(Integer index){
        if(index==0){
            first=first.getNext();
            size--;
        }else if (index>0&&index<size){
            Node cursor=first;
            for (int i = 1; i < index; i++) {
                cursor=cursor.getNext();
            }
            cursor.setNext(cursor.getNext().getNext());
            size--;
        }else {
            System.out.println("索引位置不存在，删除末尾");
            delete();
        }
    }
    public void change(Integer index,Integer value){
        Node cursor=first;
        for (int i = 0; i < index; i++) {
            cursor=cursor.getNext();
        }
        cursor.setData(value);
    }
}

多态

父类的方法作用于不同的子类有不同的表现状态：人可以是老人，小孩，大人(人是大类，有很多表现)（顶级类声明，new子类接受）Person person=new Chlid（）；此时person调用的变量和方法都是Chlid小孩的，但要调用Child自己有的方法必须把(Person)强制转型
动物可以是一只猫，但是当前动物只会动物和猫的共有方法，但是动物没有猫的特有方法（编译看左面，运行看右面）
多态三个条件：1有继承或实现 2有重写 3有父类对象指向子类引用
使用共有方法时，你是哪个类的实例你展示就是哪个实例重写的共有方法(未重写就是父类的方法)类的独有方法必须转型后才能使用

匿名对象（new 类名）

会在堆中占内存，但不会在栈中创建变量占内存(堆中占用的资源也会被重写)-多数用来传参(配合构造器使用)