复习:
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调用父类构造方法的位置无关