1.JDK、JRE、JVM之间的关系

JDK：开发工具包，提供给Java程序员使用，包含JRE、以及Java c编译器等。

JRE：Java运行时环境、包含JVM、Java基础类库，是运行Java程序的环境。

JVM：Java虚拟机，运行Java代码。

2.数据类型

分为基本数据类型（8种）和引用数据类型。

局部变量使用前一定要初始化。 一个汉字占两个字节。

3.类型转换

1. 隐式转换：数据范围小的，转为数据范围大的。
2. 强制转换：可能会精度丢失。
3. 类型提升：不同的类型相互运算：数据类型小的会提升为数据类型大的。short、byte不足四字节，运算时会先转成int计算。

int->long    float->double

int转String：String.valueOf(str)    String转int: Integer.parseInt(int)

4.关系运算符

短路求值

表达式1 && 表达式2 表达式1为假不执行表达式2

表达式1 || 表达式2 表达式1为真不执行表达式2

5.位运算符

按位与 & 遇0变0 按位与 & 遇1变1 按位异或 ^ 相同为0不同为1

6.移位运算

<< 左移   >> 右移   >>> 无符号右移

1. 左移1位，相当于原数字*2，左移N位，相当于原数字*2的N次方。
2. 右移1位，相当于原数字/2，右移N位，相当于原数字/2的N次方。

7.switch语句

1. 和case依次比较，一旦有相应的匹配就执行该项下的语句，直到遇到break。
2. switch允许的类型

基本类型：byte，char，short，int。

引用类型：String常量串，枚举类型。

在java中，实参的值永远都是拷贝到形参中，形参，实参是两个实体。

8.方法重载

在java中，如果多个方法的名字下相同，参数列表不同，则称该几种方法被重载了。

1. 方法名必须相同
2. 参数列表必须不同
3. 返回值不做要求

9.数组

相同类型元素的一个集合，在内存中是一段连续的空间。

数组也是引用类型，new出来时，对象储存在堆上。

一般对象都是在堆上，当对象没有人使用时，就会被回收（gc）。

10.面向对象

面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

类是用来对一个实体（对象）进行描述的。

public修饰的类必须和文件名相同。

11.类的实例化

定义一个类相当于在计算机中定义了一种新的类型。

用类创建对象的过程成为类的实例化。

12.构造方法

名字与类名相同，创建对象时，编译器自动调用，并且在整个对象生命周期只执行一次。

1. 名字必须与类名相同
2. 无返回值
3. 可以重载

13.封装

封装：将数据和操作数据的方法有机结合，隐藏对象的属性和实现细节，仅对外提供接口来和对象进行交互。

14.访问权限限定符

访问权限用来控制方法或属性能否直接在类外使用。

default:什么都不写时的默认权限（包访问权限）

15.static

Java中，被static修饰的成员成为静态成员，其不属于某个具体的对象，是所有对象共享的。

static修饰成员变量

static修饰成员变量，称为静态成员变量，不属于某个具体对象，是所有对象共享的。

1. 不存储在某个对象的空间中，存储在方法区。
2. 可以通过对象访问，但更推荐通过类名访问。
3. 生命周期伴随类的一生（随类的加载而创建，类的卸载而销毁）。

static修饰成员方法

static修饰成员方法，成为静态成员方法。是类方法，不是某个对象持有。

1. 没有隐藏this引用，因此不能访问任何非静态成员变量。
2. 静态方法不能调用任何非静态方法（因为静态方法中调用时无法传递this引用）。
3. 不能重写，不能用于多态。

实例代码块优于构造方法执行。

先静态后实例，再构造方法。

16.继承

面向对象思想提出了继承的概念，专门用来进行共享抽取，实现代码复用。

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类找。

super：在子类方法中访问父类成员。

只能在非静态方法中使用。

子类对象构造时，需要先调用基类的构造方法，然后执行子类的构造方法。

在构造子类对象时，先要将从父类继承下来的成员初始化完整，然后再初始化子类新增的。

静态代码块先执行（只执行一次），再是实例代码块，再是父类构造方法，再是子类构造方法。

17.final关键字

1. 修饰变量或字段：表示常量，不可修改。
2. 修饰类：表示此类不能被继承。
3. 修饰方法：表示此方法不能被重写。

18.多态

去完成某个行为，不同的对象完成时，产生不同的状态。

多态实现的条件：

1. 必须在继承体系下。
2. 子类必须对父类方法进行重写。
3. 通过父类的引用调用重写的方法。

多态体现：在代码运行时，当传递的对象不同时，会调用对应类中的方法。

19.重写

基于继承，子类重写父类方法，返回值形参都不能改变。

重写规则：

1. 不能重写父类的构造方法（不能在子类中，构造出父类对象）。
2. prviate，static，final修饰的方法不能重写。
3. 子类重写方法的访问权限必须大于等于父类。

20.重载和重写的区别

1. 重载发生在同一个类中，重写依赖继承关系，子类重写父类方法。
2. 重载参数列表必须不同，返回值不做要求，重写参数列表返回值必须相同。
3. 重载访问限定符可以修改，重写子类重写方法的访问限定符权限必须大于等于父类。

静态绑定：在编译时，根据传递的参数列表就确定了具体调用哪个方法（重载）。

动态绑定：在编译时，不能确定方法的行为，等到程序运行时，才确定调用哪个类中的方法（重写）。

21.向上转型

创建一个子类对象，当做父类对象来使用（向上转型是安全的）。

缺点：不能调用到子类特有的方法。

22.抽象类

如果一个类中没有包含足够的信息描绘一个具体的对象，这样的类就是抽象类。

注意：抽象类也是类，内部也可以包含普通方法和属性，甚至构造方法（但本身不能被实例化）。

抽象类特性：

1. 抽象类不能被直接实例化。
2. 抽象方法不能是prviate的（因为要被重写）默认为public。
3. 抽象方法不能被final和static修饰（因为要被重写）。
4. 抽象类不能用final修饰，因为要被继承，并且继承的子类必须重写父类的抽象方法，否则子类也必须是抽象类，必须用abstract修饰。

23.接口

接口就是公共的行为规范标准，大家在实现时，只要符合标准，就能通用。

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

1.接口的使用

接口不能直接使用，必须有一个实现类来实现接口，实现接口中的抽象方法。

2.接口特性

1.接口是一种引用数据类型，但是不能直接new接口的对象。

2.接口中的每一个方法都是public的抽象方法。

3.接口中的方法不能在接口中实现。

4.接口中可以含有变量，但被隐式的指定为public static final修饰的。

一个类实现多个接口时，每个接口的抽象方法都要实现，否则必须为抽象类。

24.抽象类和接口的区别

1. 抽象类中可以包含普通方法和普通字段，这样的方法和字段可以被直接使用。
2. 接口的实现类必须重写所有的抽象方法。
3. 一个类可以实现多个接口，但是只能继承一个抽象类。
4. 抽象类强调所属关系，接口强调特定功能的实现。

25.equals方法

比较对象中的内容是否相同的时候，一定要重写equals方法。

26.String类

Java中没有所谓'\0'代表字符串结尾。

1. ==比较是否引用同一个对象。
2. equals方法：按字典序比较内容是否相同。
3. int compareTo 返回int，不等返回差值。

27.字符串常量池

为了使程序的运行速度更快，更加节省内存，避免1,2,3，"hello"等常量频繁使用。

1. 在JVM中字符串常量池只有一份，是全局共享的。
2. 刚开始字符串常量池是空的，随程序的不断运行，元素会越来越多。
3. 元素一部分来自运行时常量池，一部分是程序动态添加。

所有涉及修改字符串内容的操作，都是创建一个新的对象，改变的是新对象。

28.String，StringBuffer，StringBuilder的区别

1. String的内容不能修改，StringBuilder，StringBuffer的内容可以修改。
2. StringBuilder，StringBuffer大部分功能是类似的。
3. StringBuffer是线程安全的，StringBuilder是线程不安全的。

29.异常体系

在Java中，将程序执行过程发生的不正常行为成为异常。

Java中不同类型的异常，都有具体对应的类进行描述。

异常分类：

1. 编译时异常（受查异常）

在程序编译时期发生的异常（会直接飘红）。

1. 运行时异常（非受查异常）

在程序执行期间发生的异常（例如：数组越界异常，空指针异常等）。

30.异常处理的关键字：throw，try，catch，finally，throws

• throw

1. throw必须写在方法内部用于抛出一个异常
2. 如果抛出RunTime Expetion或其子类，则可以不用处理，直接交给JVM处理。
3. 如果抛出的是编译时异常，用户必须处理，否则无法通过编译。
4. 异常一旦抛出，其后的代码就不会执行。

• throws

1. throws处在方法声明参数列表之后，用于声明一个异常。
2. 方法中抛出编译时异常，用户不想处理，借助throws抛给方法的调用者处理。

即当前方法不处理异常，提醒方法的调用者处理异常。

1. 调用声明抛出异常的方法时，调用者必须处理异常，或者继续使用throws抛出。

• try-catah

1. try块内抛出异常位置之后的代码不会被执行。
2. 如果抛出的异常与catch时的异常类型不匹配，也不会被捕获。
3. try可能抛出多个异常，catch必须用多个来捕获。

• finally

finally中的代码一定会执行，一般在finally中进行一些资源清理的扫尾工作。

31.throw和throws的区别

1. throw用来抛出异常，throws用来声明异常。
2. throw必须位于方法中，throws位于方法参数列表之后。
3. throws声明一个编译时异常表示当签不处理交给方法调用者处理。throw抛出编译时异常时用户必须处理。

31.final和finally的区别

• final修饰变量表示该变量为常量不能被修改，修饰方法表示方法不能被重写，修饰类表示类不能被继承。
• finally用在异常处理中，finally中的代码一定会执行，一般在finally中进行一些资源清理的扫尾工作。

32.异常处理流程总结

• 程序先执行try中的代码。
• 如果try中的代码出现异常，就会结束try中的代码，看和catch中的异常是否匹配。
• 如果找到匹配的异常类型，就会执行catch中的代码。
• 如果没有匹配的异常类型，就会将异常向上传递到上层调用者。
• 无论是否匹配到异常，finally中的代码都会执行。
• 如果上层调用者也没处理的了异常，就继续向上传递。
• 一直到main方法也没有合适的代码处理异常，会交给JVM来处理异常，此时程序就会终止。

继承自Expection的异常默认是受查异常。

继承自RunTime Expection的异常默认是非受查异常。