学习心得                                          

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

                                                       心情  

                              今天讲链表，和数组不一样，绕起来非常晕，但是后来周围人给我讲明白了


 *  多态
 *  编译看左边 运行看右边
 *  多态形成的三个条件
 *  1.有继承
 *  2.有重写
 *  3.有父类对象指向子类引用
 *
 *  第一种多态形式 (向上转型)
 *  父类 父类对象 = new 子类();
 *
 *  第二种多态形式（向下转型）
 *  子类 子类对象 = new 父类();
 *  发生向下转型的前提，要先发生向上转型，才能通过强转再转成子类类型
 *
 *  instanceof关键字：判断某一个对象是否是某一个类的实例

public class Ch01 {


    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        Animal animal1 = dog;
        Animal animal2 = cat;
//        dog = (Dog)cat;
//        dog = (Dog) new Animal();
        dog = (Dog) animal1;
        dog = (Dog) animal2;
    }
}
 

public class Ch02 {


    // 无敌方法
    public Object show(Object ... obj){


        return true;
    }


    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Person){
            Person person = (Person) obj;
        }
        return super.equals(obj);
    }


    public static void main(String[] args) {
        Object obj = new Person();
        obj = new Ch02();
        Ch02 ch02 = new Ch02();
        ch02.show("",1,'a',1.5,true,obj);
    

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

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 *   链表
 *   在内存当中，数组和链表都是最基本的数据结构，表，或者是线性表
 *   线性表，线性的结构，他是一个含有n>=0个结点的有序数列
 *   有且只有一个上一个结点，只有一个下一个结点
 *   有头有尾的一条线
 *   单向链表：在维护一个结点自身的值的同时，还要维护它下一个结点的值指向
 *   双向链表：在维护一个结点自身的值的同时，还要维护它的上一个和下一个结点的值的指向
 

 * 多态
 * 向上转型：父类对象->子类引用
 * 向下转型：子类引用->父类对象  前提，必须先发生向上转型
 *
 * instanceof：判断某一个对象是否是某一个类的实例

public class Ch01 {
    public Object show(){
        return null;
    }
}


public class ThatsAll extends Ch01{
    public Integer show(){
        return null;
    }
}
 

链表：

package afternoon.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;
        }
        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);
            node.setNext(newNode);
        }else{
            first = newNode;
            last = newNode;
        }
        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<2){
            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 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 afternoon.test;


/**
 *  单向链表
 */
public class Node {
    private Integer data;
    private Node next;


    public Node() {
    }


    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 +
                '}';
    }
}
package afternoon.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(1,100);//添加
        superLinked.removefirst();//删第一个
        superLinked.removelast();//删尾部
        superLinked.remove(2);//删除指定下标的元素
        System.out.println(superLinked.getNo

☯☯☯☯☯☯☯☯☯☯☯☯