2022-07-25 第二组 刘禹彤 学习笔记

打卡第十五天

 

 

 

###学习笔记

1.面向对象之多态

• 多态形成的3个条件：

1.有继承

2.有重写

3.有父类对象指向子类引用

• 1.第一种多态形式：（向上转型）

父类 父类对象 = new 子类（）

2.第二种多态形式：（向下转型）

发生向下转型的前提：要先发生向上转型，才能通过强转再转成子类类型

2.匿名对象

• 语法：new 类名（）
• 功能：1.和正常名字的对象的功能是相同的

2.依然具备了调用属性，方法的功能

• 使用对象：多数是用在传参，实参，多数情况下会配合构造器使用
• 好处：节约资源

3.链表

• 是一个数据结构
• 在内存中，数组和链表都是最基本的数据结构，表，或者线性表

1. 线性表：线性结构，他是一个含有n>=0的节点的有限序列

2. 有且只有一个上一个节点，而且有且只有一个下一个节点：有头有尾的一条线

单向链表;在维护一个节点的自身的值的同时，还要维护他的下一个值的指向

双向链表：在维护一个结点的自身的同时，还要维护它的上一个和下一个维护的指向

###学习心得

今天学习了面向对象的多态性，链表，以及将超级数组的案例进行了完善，感觉今天学习的东西有点抽象，不是很好理解

###掌握程度：一般

###案例

package c.test;

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 boolean add(int index,Integer data) {
        Node node = getNode(index);
        Node newNode = new Node(data,null);
        if(node != null){
//            Node next = node.getNext();
//            newNode.setNext(next);
            newNode.setNext(node.getNext());
            node.setNext(newNode);
        } else {
            // 如果要插入的位置是null，只有一种情况，就是整个链表都是空
            first = newNode;
            last = newNode;
        }
        size++;
        return true;

    }

    // 默认删除头部的数据
    public boolean removeFirst() {
        if(size < 0){
            return false;
        }
        if(first != null){
            first = first.getNext();
            size--;
        }
        return true;
    }

    // 删除尾部的数据
    public boolean removeLast(){
        if(size <= 0){
            return false;
        }
        if(size == 1){
            first = null;
            last = null;
            size--;
            return true;
        }
        if(last != null){
            last = getNode(size - 2);
            last.setNext(null);
            size --;
        }
        return true;
    }

    public boolean remove(int index) {
        if(size < 0){
            return false;
        }
        if(size == 1){
            first = null;
            last = null;
            size--;
            return true;
        }else {
            Node node = getNode(index - 1);
            node.setNext(node.getNext().getNext());
        }
        size--;
        return true;
    }

    // 修改指定下标位置的元素
    public boolean set(int index,Integer data){
        Node node = getNode(index);
        node.setData(data);
        return true;
    }

    // 根据下标获取指定的数据
    public Integer get(int index) {
        return getNode(index).getData();
    }

    // 获取链表的长度
    public int size() {
        return size;
    }

    // 根据下标获取指定的结点
    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;
    }
}

package c.test;
public class Demo {

    public static void main(String[] args) {
        SuperLinked superLinked = new SuperLinked();
        superLinked.add(1);
        superLinked.add(2);
        superLinked.add(3);
        superLinked.add(100);
        superLinked.add(0,-100);
        superLinked.removeFirst();
        superLinked.removeLast();

        superLinked.remove(2);

        for (int i = 0; i < superLinked.size(); i++) {
            System.out.println(superLinked.get(i));
        }

    }
}

 

###运行结果