2019-09-03-链表

最新推荐文章于 2021-10-16 13:56:37 发布

大福大福

最新推荐文章于 2021-10-16 13:56:37 发布

阅读量100

点赞数

本文链接：https://blog.csdn.net/weixin_43580746/article/details/100547069

版权

复习：

1、合并有序链表

class Node{
	int val;
	Node next=null;
	
	Node(int val){
		this.val=val;
	}
}

public static void main(String[] args){
	public Node Reverse(Node head){
		//遍历原链表，将每个结点头插到新链表中
		
		//1、先定义一个新的链表
		Node result=null;
		//2、定义一个当前结点，用来遍历原链表
		Node cur=head;
		while(cur!=null){
			Node next=cur.next;
			if(result==null){
				result=cur;
			}else{
				cur.next=result;
			}
			result=cur;
			cur=next;
		}
		
	}
}

2、逆置链表

public Node merge(Node head1,Node head2){
	if(head1==null){return head2;}
	if(head2==null){reutrn head1;}
	Node result=null;
	Node last=null;
	Node cur1=head1;
	Node cur2=head2;
	
	while(cur1!=null && cur2!=null){
		if(cur1.val<=cur2.val){
			if(result==null){
				result=cur1;
			}else{
				last.next=cur1;
			}
			last=cur1;
			cur1=cur1.next;
		}else{
			if(result==null){
				result=cur2;
			}else{
				last.next=cur2;
			}
			last=cur2;
			cur1=cur2.next;
		}
	}
	if(cur1!=null){
		last.next=cur1;
	}else{
		last.next=cur2;
	}
	return result;
}

3、类

public class A{

        // 1. 属性/静态属性

       // 2.  方法/静态方法

      // 3. 构造方法

       // 4. 内部类

       //成员级别（member-level）

      public static void main（String[] args){

              // 方法级别（method-level）

      }

}

顶级（top-level）

4、（1）static 静态修饰符只能修饰成员级别

（2）public default/package-private 修饰顶级和成员级别

（3）private/protected 修饰成员级别

5、引用和对象的生命周期

（1）引用：一直数据类型，背后含义指向一个对象。在Java语言中，98%无法直接看到对象，看到的实际是引用

（2）对象的生命周期

new 分配空间；初始化时期；活跃时期；被判定为死亡的时期

6、类的加载

（1）发生在运行期间；

（2）从磁盘上把*.class文件（类字节码文件）载入到内存中的过程；类加载器（ClassLoader）

（3）类被加载到内存的什么区域？方法区

（4）加载的是类的哪些信息？主要是方法语句数据，静态属性，元信息

（5）类的加载时机是什么？懒加载（延迟加载），需要的时候才加载

（6）那些情况下类会被用到？ new 对象；访问静态属性/方法；反射

（7）静态属性的初始化顺序：按照书写顺序（定义时初始化、静态代码块）

7、编译与运行

（1）编译期间：

做的是，将源文件（*.java）转化（编译Compile）为类字节码文件（*.class），编译期间运行的不是我们源代码，而是javac 程序，我们的源代码只是作为别人程序的一个输入而已。

（2）运行期间：

运行的是java……，运行的是我们的程序，java会启动JVM虚拟机

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

新内容：类的继承

面向对象的三大特征：

封装、继承、多态

继承：目的：代码的复用性，懒得写代码，继承要表达的是一种有关系的类

class Animal{} // 父类（parent类）、基类（base类）、超类（super类）

class Bird extends Animal{} //子类（child）、派生类（derived类）

！！！！重点：方法的覆写Override

子类重写了符类的一个方法：方法名称相同，形参列表相同，返回类型要相同（备注）

特例：允许返回值类型是符类方法返回类型的子类

List method () ；

ArrayList method extends List ();

即：访问限定符不能比父类更封闭、

注意与方法的重载（Overload）的区别：方法名称相同，形参列表不同

覆写/重写（Override）

1、一定发生在子类上的，必须实现和父类

2、方法名称 + 形参列表 + 返回值类型都相同的方法

3、针对同一行为，表现出和父类不同的方式（例子：动物的叫声）

4、访问限定符不能比父类的更加严格（封闭）

5、一般建议用 @Override 注解修饰

6、IDEA 可以用generate code 来自动生成

super 关键字（可以 this 对照看看）

1、super 用来访问父类的构造方法

2、不是代表父类对象，可以抽象的去理解，执行属性中属于父类的那部分/明确调用父类的方法

class A{
    public int a=10;
    public void print(){sout("父类的print");}
}

class B extends A{
    public int a=100;
    public void print(){sout("子类的print");}
    public void test(){super.a;super.print;}
}

1、Java中类的继承，只允许单继承（即一个类只能有一个父类，但可以有若干个子类）

2、父类和子类之间的关系，涉及到 super 关键字

（1）类加载的关系：

子类的加载必须触发父类的加载

父类的加载一定是发生在子类的加载之前的

（2）对象实例化/构造的关系

子类的对象的构造的过程会触发父类中属性的初始化过程

父类的属性初始化一定发生在子类属性的初始化之前

属性的初始化：

1、定义时初始化 + 构造代码块按书写顺序

2、构造方法

和super调用父类构造方法的位置无关