JAVA 06

多态的形成有三个条件:

1,继承(不一定)

2,重写

3,父类对象指向子类引用

---

数组是不是类?

Arrays是数组的工具类, 数组是Object类的子类
在jvm的角度看数组是类,数组能调用方法,jvm解析数组时生成一个数组的类
从编译角度来看,不是类,没有类名,没有结构

多态的类型

第一种多态(向上转型): 可以自动转 (小转大)

父类  父类对象 = new 子类();

第二种多态形式(向下转型 ):强制转型

发生向下转型的前提是先发生先发生向上转型,才能通过强制转为子类对象

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

---

删除数组下标为index位置元素时移位的方法

1,新建数组,把元素移到新数组中

2,直接覆盖移位

for(int i=index;i<arr.length-2,i++){
   arr[i+1]=arr[i+2]
}

3,使用arraycopy方法

System.arraycopy(array,index+1, array,index,arr.length-index);

---

在Object类中toString方法的源码是这样定义的

 会默认返回:全类名(包名+类名)+@+哈希值的十六进制

---

匿名对象: new 类名();   

调用方法时 :new 类名().方法名();

和正常有名字的对象的功能一致,依然可以调用属性和方法,

使用场景

多数时用在传参,实参,多数配合构造器使用

好处:节约栈的内存,

每次调用的匿名对象都是新分配的，具有默认初始化值的对象。

1. 每次匿名对象的地址空间都是不同的

2. 即使对一个匿名对象的属性进行赋值，下一个匿名对象的各种属性值还是默认初始化的值

如果写一个循环，不停的输出匿名对象的属性值，即不停的new Desk()，是不会出现堆溢出的情况，证明每次new了新的对象，一旦调用结束都会立即回收空间，所以不会导致堆栈溢出的空间。

---

链表: 是一种数据结构

在内存中,数组和链表都是最基本的数据结构,是线性表

线性表:线性的结构,是一个含有n>=0个结点的有限的序列

有且只有一个开始结点,也是有且只有下一个结点

单向链表:在维护一个结点的自身的值的同时,维护下一个值的指向

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

单向链表的代码实现:

package com.jsoft.afternoon.test;

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

    private Integer data;
    private Node 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;
    }

    public Node() {
    }

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

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

package com.jsoft.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;
        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 com.jsoft.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(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));
        }

    }
}

学习心情:

微笑面对生活!