2022-7-25 第一小组 甘源册 学习笔记
知识点掌握情况
多态（了解） 链表（理解）
学习心情（心路历程）
今天的多态太抽象了，很难理解，向下转型 是父类转换成子类，向上转型是子类实例化的对象是父类。我是这么理解的，也不知道对不对。
1.多态
1.1第一种多态的形式（向上转型）
-
父类（Father） 父类对象名（father）=new 子类构造器（Son）
-
特点：可以自动转换
-
编译看左边
- 父类的对象名调用不了子类独有的方法，属性
-
运行看右边
- 在运行时可以把对象名的类当成子类。例如：子类重写了父类的方法，father调用这个方法时会执行重写过的方法。
-
多态形成的三个条件
- 有继承
- 有重写
- 有父类对象指向子类引用
1.2第二种多态的形式
- 父类（Father） 父类对象名（father）=new 子类构造器（Son）
- 子类（Son） 子类对象名（son）=new 子类构造器（Son）
- son=（Son）father
- 前提：要先发生向上转型，才能通过强转再转成子类类型。
1.3 Object
//(无敌法)
public Object show(Object...objects){
//传入参数是什么都行
//返回值是什么都行
return 1;
}
1.4匿名对象
- 语法：（new 构造器）一个整体，是对象，能调用属性和方法
- 专精对象
- 作用（好处）：可以节约资源(但是不要强行的用)，用完之后会立即被垃圾回收
- 功能：与正常对象的功能没有任何区别。
- 开发场景：多数情况下是用来传实参，并配合构造器使用。
1.5拓展
- 数组是类（从JVM的角度，能调方法）——在JVM生成数组的时候会生成一个数组，解析数组
- 站在编译角度，不是类，没有类名，没有结构
2.链表
在内存中，数组和链表都是最基本的数据结构，表或线性表。
线性表，线性结构，他是一个含有n>=0个节点的有序列表。有且只有一个上一个结点，有且只有一个下一个结点。
结点类
package com.gyc.afternoon.test;
public class Node {
private Node pre;
private Node next;
private Integer data;
public Node() {
}
public Node(Node next, Integer data) {
this.next = next;
this.data = data;
}
public Node(Node pre, Node next, Integer data) {
this.pre = pre;
this.next = next;
this.data = data;
}
public Node getPre() {
return pre;
}
public void setPre(Node pre) {
this.pre = pre;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public Integer getData() {
return data;
}
public void setData(Integer data) {
this.data = data;
}
@Override
public String toString() {
return "Node{" +
" 下一个:" + next +
", 值为:" + data +
'}';
}
}
单链表
package com.gyc.afternoon.test;
public class SuperLinked {
//链表的长度
private Integer size = 0;
//链表的第一个结点
private Node first;
//链表的最后一个结点
private Node last;
public Integer getSize() {
return size;
}
public void setSize(Integer size) {
this.size = size;
}
public Node getFirst() {
return first;
}
public void setFirst(Node first) {
this.first = first;
}
public Node getLast() {
return last;
}
public void setLast(Node last) {
this.last = last;
}
public SuperLinked() {
}
//把数字添加到链表的尾部
public boolean add(Integer data) {
//把传入的数据构建成一个结点
Node node = new Node(null, data);
//如果链表是空的,我就是第一个结点
if (first == null) {
first = node;
} else {
//如果链表不是空,那我就是最后一个结点
//我应该是在原来的last结点的后面
//我是原来last结点的下一个
last.setNext(node);
}
last = node;
size++;
return true;
}
//查询
public Node getNode(int index) {
if (index < 0) {
index = 0;
}
if (index >= size - 1) {
index = size - 1;
}
Node cursor = first;
for (Integer i = 0; i < index; i++) {
cursor = cursor.getNext();
}
return cursor;
}
//指定位置添加
public void addNode(int index, Integer integer) {
Node cursor = getNode(index);
Node node = new Node(null, integer);
if (cursor == null) {
System.out.println("链表为空");
} else if (cursor.getNext() == null) {
cursor.setNext(node);
} else {
Node node1 = cursor.getNext();
cursor.setNext(node);
node.setNext(node1);
}
size++;
}
//修改
public void update(int index, Integer integer) {
if (index < 0) {
index = 0;
}
if (index >= size - 1) {
index = size - 1;
}
Node cursor = first;
for (Integer i = 0; i < index - 1; i++) {
cursor = cursor.getNext();
}
Node node = new Node(null, integer);
Node node1 = cursor.getNext();
cursor.setNext(node);
node.setNext(node1.getNext());
}
//指定位置删除
public void delete(int index) {
if (index < 0) {
index = 0;
}
if (index >= size - 1) {
index = size - 1;
}
Node cursor = first;
for (Integer i = 0; i < index - 1; i++) {
cursor = cursor.getNext();
}
cursor.setNext(cursor.getNext().getNext());
size--;
}
//尾部删除
public Boolean deleteLast() {
if (size < 0) {
return false;
}
if (size < 2) {
first = null;
last = null;
return false;
}
if (last != null) {
getNode(size - 2).setNext(null);
last = getNode(size - 2);
size--;
return true;
}
return false;
}
//头部删除
public Boolean deleteFirst() {
if (size < 0) {
return false;
}
if (size < 2) {
first = null;
last = null;
return false;
}
while (first != null) {
first = first.getNext();
size--;
return true;
}
return false;
}
}
- 双向链表：在维护一个结点的自身的值同时还要维护它的上一个和下一个值的指向。
双链表
package com.gyc.afternoon.test;
public class SuperTwoLinked {
private Node first;
private Node last;
private Integer size = 0;
public Node getFirst() {
return first;
}
public void setFirst(Node first) {
this.first = first;
}
public Node getLast() {
return last;
}
public void setLast(Node last) {
this.last = last;
}
public Integer getSize() {
return size;
}
public void setSize(Integer size) {
this.size = size;
}
//添加
public void add(Integer a) {
Node node = new Node(null, null, a);
if (first == null) {
first = node;
} else {
last.setNext(node);
node.setPre(last);
}
last = node;
size++;
}
//指定位置添加
public void add(Integer a, Integer index) {
Node node = getNode(index);
Node node1 = new Node(null, null, a);
if (node == null) {
System.out.println("链表不存在");
return;
}
if (node.getNext() != null) {
Node node2 = node.getNext();
node.setNext(node1);
node1.setPre(node);
node.setNext(node2);
node2.setPre(node1);
} else {
node.setNext(node1);
node1.setPre(node);
}
size++;
}
//指定位置修改
public void update(Integer a, Integer index) {
Node node = getNode(index - 1);
Node node2 = getNode(index);
Node node1 = new Node(null, null, a);
if (node != null) {
if (node.getNext() == null) {
add(a);
} else {
if (node2.getNext() == null) {
node.setNext(node1);
node1.setPre(node);
} else {
node.setNext(node1);
node1.setPre(node);
node1.setNext(node2.getNext());
node2.setPre(node1);
}
}
} else {
System.out.println("链表不存在");
}
}
//指定位置查询
public Node getNode(Integer index) {
if (index < 0) {
size = 0;
}
if (index > size - 1) {
size = 0;
}
Node cursor = first;
for (Integer i = 0; i < index; i++) {
cursor = cursor.getNext();
}
return cursor;
}
//指定位置删除
public void remove(Integer index) {
Node node = getNode(index - 1);
if (node == null) {
System.out.println("链表错误");
return;
}
Node node1 = node.getNext().getNext();
node.setNext(node.getNext().getNext());
node1.setPre(node);
size--;
}
//尾部删除
public void removeLast() {
getNode(size - 2).setNext(null);
last = getNode(size - 2);
last.setPre(getNode(size - 2));
}
//头部删除
public void removeFirst() {
first.getNext().setPre(first);
first = first.getNext();
}
}
- 链表（LinkList）
- 优点：易于修改（新增和删除）
- 缺点：不利于查询。
- 超级数组（ArrayList）
- 优点：方便查询。
- 缺点：空间复杂度高。
关键字
- instanceof
- 判断某一个对象是否是某一个类的实例
- 返回值是布尔类型
异常
- 类型转换异常：ClassCastException
算法
队列
package queue;
import LB.LinkList;
import java.util.Iterator;
public class Queue {
private Node head;
private Node last;
private Integer N=1;
public Queue() {
this.head = null;
this.last = null;
}
public Queue(Node head, Node last, Integer n) {
this.head = null;
this.last = null;
N = n;
}
public Node getHead() {
return head;
}
public void setHead(Node head) {
this.head = head;
}
public Node getLast() {
return last;
}
public void setLast(Node last) {
this.last = last;
}
public Integer getN() {
return N;
}
public void setN(Integer n) {
N = n;
}
public void bl(){
if (head==null){
System.out.println(last);
}else {
System.out.println(head);
}
}
public void add(String t){
Node tNode = new Node(t, null,null);
if (head==null){
head=tNode;
return;
}
Node cursor=head;
while (cursor.next!=null){
cursor=cursor.next;
}
cursor.next=tNode;
tNode.pre=cursor;
last=tNode;
N++;
}
public String dequeue(){
Node cursor=last;
while (cursor.pre!=head){
cursor=cursor.pre;
}
Node newNode=cursor.pre;
cursor.pre=null;
head=cursor;
N--;
return newNode.item;
}
public Integer size(){
return N;
}
public Boolean isEmoly(){
if (N>0){
return false;
}
return true;
}
public void ds(){
if (head==null){
Node node=last;
for (Integer i = 0; i < size(); i++) {
System.out.print("第"+(i+1)+"个值为"+node.item);
node=node.pre;
}
}else{
Node node=head;
for (Integer i = 0; i < size(); i++) {
System.out.print("第"+(i+1)+"个值为"+node.item);
node=node.next;
}
}
}
}
class Node {
String item;
Node next;
Node pre;
public Node(String item, Node next, Node pre) {
this.item = item;
this.next = next;
this.pre = pre;
}
@Override
public String toString() {
return "Node" +
" " + next +
" 值为：" + item
;
}
}
测试
package queue;
public class Demo {
public static void main(String[] args) {
Queue queue = new Queue();
queue.add("a");
queue.add("b");
queue.add("c");
queue.add("d");
System.out.println("------------");
System.out.println("剩余元素的个数"+queue.getN());
queue.ds();
System.out.println();
System.out.println("------------");
System.out.println("出列的元素是"+queue.dequeue());
System.out.println("出列的元素是"+queue.dequeue());
System.out.println("剩余元素的个数"+queue.getN());
System.out.println("------------");
queue.ds();
}
}
浙公网安备 33010602011771号