1.面向对象的语言
顶级（top-lever）
public class A{
成员级别（member-lever）
public void method(){
方法级别（method-lever）
}
}
System.out.println();只能出现在方法级别
2.变量的两种类型
（1）基本数据类型：
数值：整型、浮点
字符：char
布尔：boolean
（2）引用类型：
数组类型的引用：int[] a
类类型的引用:Node cur
接口类型的引用:interface IC{} IC c;
Java中从来没有对象类型的引用
3.引用是什么？
引用是指向/找到对象的一个线索，当引用的值是null时，表示该引用没有指向任何对象
(1)int[] a = {1,2,3};
a是一个int[] 的引用，指向的是一个int[] 的对象
(2)class A{}
class B extends class A{}
A a = new A() : a是一个A的引用，指向A的对象
大类型的引用可以指向小类型的对象，小类型的引用不可以指向大类型的对象
(3)interface IC
class C implement IC{}
IC c = new C();
（4）设计一个表现多态的，数组类型的引用？
Object [] array = new String[10];
4.变量的四种形式
（1）形参（paramters）
（2）局部变量（local variables）
（3）属性（fields）
（4）静态属性（static fields）
5.方法的调用过程？栈的作用
变量的生命周期：变量所在的内存块的存活周期
形参随着方法调用的结束而消失
6.Java中内存区域划分？
栈：形参、局部变量、普通方法
堆：属性
方法区：静态属性
调用普通方法在栈上，普通方法代码在方法区上。
7.作用域
空间上、静态的【生命周期：时间上、动态的】
（1）在内存上会为变量保留一块区域
（2）用变量名关联到该区域
意思：空间上，变量名与该区域关联生效的范围
8.定义类
（1）构造方法（注意默认无参构造）
（2）this的使用
调用其他的构造方法（方法签名：方法名+参数列表）、代表指向本对象的引用（访问本对象的属性、方法）
（3）构造对象的语法
Node node = new Node（1）
对象的生命周期：
- new代表：（1）为对象计算内存大小（2）申请空间（3）初始化
- 调用构造方法/构造代码块/构造方法对属性初始化
- 代表对象拥有完整的生命周期
- 没有引用指向该对象，到对象正在被垃圾回收阶段
9.static
- static只能出现在成员级别；static和对象解绑
- 静态方法可以在主方法中直接使用，与对象解绑。如果是普通方法，首先创建一个对象，用对象去调用方法。
静态属性：属性存在对象的堆上，静态属性存在类（方法区上）
静态方法：不能直接访问属性，不能直接调用普通方法
10.访问限定符
public：都可以（顶级、成员级别）
protected:同一包下，以及不同包下它的子类
default：在同一个包下（顶级）
private：只有自己有权限
11.继承
- class 类名 extends 父类（单继承）
- 对象的内存布局：子类会继承父类的所有属性，但是可能没有权限访问
- super关键字
（1）调用父类的构造方法
（2）去访问被隐藏父类的属性，去调用被覆写的父类方法
12.关于类的加载与对象的实例化
（1）类的加载？（Node类的加载）
从硬盘上找到Node.class，解析该文件内容，生成Node类，把Node类的信息存在内存的方法上
（2）什么情况下触发类的加载，并且该类不在内存中？
按需加载（懒加载过程）
1）实例化该类的一个对象
2）使用类的静态属性或者静态方法
3）用到子类必须先要有父类
(3)类加载过程中有什么重要的原则？
静态属性的初始化问题：按照代码的书写顺序执行
静态属性定义是初始化
静态代码块
（4）对象的构造/实例化 new Node
规则：
（1）优先初始化父类的属性
（2）按照下面的顺序执行初始化
- 按照代码的书写顺序，执行定义时和构造代码块
- 在去执行构造方法
class Parent {
static {
System.out.println("A");
}
static {
System.out.println("B");
}
}
public class LoadOrder extends Parent {
private static int initB() {
System.out.println(1);
return 0;
}
static int a = initA();
static {
System.out.println(2);
}
static int b = initB();
private static int initA() {
System.out.println(3);
return 0;
}
private static int initC() {
System.out.println(5);
return 0;
}
static {
System.out.println(4);
}
public static void main(String[] args) {
// 不会再触发类的加载，因为已经在内存中了
LoadOrder.a = 0;
}
}
//执行顺序为：A，B，3,2，1,4
13.abstract关键字有什么作用？
（1）修饰类，该类是抽象类，无法实例化类，等着被继承
（2）修饰方法，该方法是抽象方法，没有被实现的方法
包含抽象方法的必须是抽象类，抽象类不一定包含抽象方法
14.final关键字有什么作用？
（1）修饰变量，该变量只能初始化一次，且无法修改、定义时初始化
（2）修饰类，表示该类无法被继承
（3）修饰方法，该方法无法被覆写
final类与final方法完全独立
15.方法重载与方法覆写
重载：方法名相同，参数列表不同
覆写：发生在子类继承父类或者类实现接口中，方法名与参数列表相同，方法的返回类型比父类的返回类型小，子类访问修饰限定符只能比父类的访问修饰符更大。
16.引用=对象；
（1）引用只能指向对象，或者什么都不指向
（2）数组引用、类类型引用、接口类型引用
（3）对象：数组对象、非抽象类类型对象
class A extends P implements I{
}
I i = new A();
P p = new A();
A a = new A();
P method(){
return new P();
return new A();
}
//返回P类型的引用，可以指向P/A类型的对象
17.链表逆置
首先定义一个结果链表，遍历链表每一个结点，把每个结点头插到一个结果链表上
public Node reverse(Node head) {
Node result = null;
Node cur = head;
while (cur != null){
Node next = cur.next;
cur.next=result;
result = cur;
cur= next;
}
return result;
}
18.合并两个有序列表
首先当考虑链表为空的情况，其次分别遍历两个链表，取值比较小的结点尾插到新链表，把剩余链表接到新链表后面。
public Node Orderly(Node head1,Node head2){
if(head1 == null){
return head2;
}
if(head2 == null){
return head1;
}
Node cur1 = head1;
Node cur2 = head2;
Node result = null;
Node last = null;
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;
cur2 = cur2.next;
}
}
if(cur1!=null){
last.next = cur1;
}
if(cur2!=null){
last.next = cur2;
}
return result;
}
19.练习
1.执行顺序
class HelloA {
//构造方法
public HelloA(){
System.out.println("1Hello A!父类构造方法");
}
//非静态代码块
{
System.out.println("2i'm A class.父类非静态代码块");
}
//静态代码块
static{
System.out.println("3static A 父类静态代码块");
}
}
class HelloB extends HelloA {
//构造方法
public HelloB(){
System.out.println("4Hello B! 构造方法");
}
//非静态代码块
{
System.out.println("5i'm B class.非静态代码块");
}
//静态代码块
static{
System.out.println("6static B 静态代码块");
}
}
public class HelloC {
public static void main(String[] args) {
System.out.println("7---start---");
new HelloB();
new HelloB();
System.out.println("8---end---");
}
}
执行顺序为：
7—start—
3static A 父类静态代码块
6static B 静态代码块
2i’m A class.父类非静态代码块
1Hello A!父类构造方法
5i’m B class.非静态代码块
4Hello B! 构造方法
2i’m A class.父类非静态代码块
1Hello A!父类构造方法
5i’m B class.非静态代码块
4Hello B! 构造方法
8—end—
2.执行顺序
public class HelloA {
public HelloA() {
System.out.println("Hello A!父类构造方法");
}
{
System.out.println("i'm A class.父类非静态代码块");
}
static {
System.out.println("static A 父类静态代码块");
}
}
public class HelloB extends HelloA {
public HelloB() {
System.out.println("Hello B! 构造方法");
}
{
System.out.println("i'm B class.非静态代码块");
}
static {
System.out.println("static B 静态代码块");
}
public static void main(String[] args) {
System.out.println("---start---");
new HelloB();
new HelloB();
System.out.println("---end---");
}
}
执行结果为：
static A 父类静态代码块
static B 静态代码块
—start—
i’m A class.父类非静态代码块
Hello A!父类构造方法
i’m B class.非静态代码块
Hello B! 构造方法
i’m A class.父类非静态代码块
Hello A!父类构造方法
i’m B class.非静态代码块
Hello B! 构造方法
—end—
来源：https://blog.csdn.net/weixin_43256788/article/details/99676335