JAVA 06

118 阅读 0 评论 78 点赞

我是靠谱客的博主大方老鼠，这篇文章主要介绍JAVA 06，现在分享给大家，希望可以做个参考。

多态的形成有三个条件:

1,继承(不一定)

2,重写

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

数组是不是类?

复制代码

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

多态的类型

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

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

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

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

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

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

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

2,直接覆盖移位

复制代码

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

3,使用arraycopy方法

复制代码

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

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

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

匿名对象: new 类名();

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

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

使用场景

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

好处:节约栈的内存,

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

每次匿名对象的地址空间都是不同的
即使对一个匿名对象的属性进行赋值，下一个匿名对象的各种属性值还是默认初始化的值

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

链表: 是一种数据结构

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

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

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

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

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

单向链表的代码实现:

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
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;
    }
}

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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));
        }

    }
}