20220725 第一组 于芮 面向对象之多态（第十六天）

 

小白成长记——第十六天

 

   今天主要的学习内容是面向对象的第三个特点——多态，相比较来说比前两个特点更难理解，综合性比较强，对于前两个特点——封装和继承的理解需要很深，才可以理解多态的概念，来看看今天的学习笔记吧！

多态
形成的三个条件
1.有继承
2.有重写
3.有父类对象指向子类引用

多态的形式
1.父类 父类对象=new 子类();-------向上转型
2.子类 子类对象=new 父类（）；------向下转型
发生向下转型的前提，要先发生向上转型，才能通过强转再转成子类类型

关键字instanceof：判断某一个对象是否是某一个类的实例，返回值是boolean类型

匿名对象
语法：new 类名();
功能：和正常有名字的对象的功能是相同的，依然具备了调用属性，方法的功能
使用场景：多数是在用在传参，实参，多数情况下配合构造器使用
好处：节约栈资源

链表：是一个数据结构
在内存中，数组和链表都是最基本的数据结构，
线性表，在线性结构中，他是含有大于等于零个节点
下一个连接上一个节点，有且只有一个下一个节点
单向链表：维护自身的同时，还要维护下一个节点
双向链表：维护自身的同时，还要维护上一个和下一个节点

方法的重写：重写方法的返回值可以是被重写方法的返回值的子类

   今天的主要实践是来自单链表的增加，修改，删除，查找，来看看今天的代码！

 

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，只有一种情况，就是整个链表都是空
            Node frist = 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;
    }
    //根据下标获取指定节点

    public 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 class Node {
    private Integer data;
    private  Node next;

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

    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;
    }

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