java学习总结

intelliJ IDEA [ɪn’telɪdʒeɪ][aɪ’diːə] 
mysql账号初始密码：root@localhost: V30+l1;tPqrI
1、java数据类型：
基本数据类型：
整数类：byte、short、int、long
字符类：char
浮点类：double、float
逻辑类：boolean
引用数据类型：
类class、接口interface、数组、枚举、注解
基本数据类型所对应的引用类型：
(8bit) byte ------ Byte
(16bit) short ------ Short
(32bit) int ------ Integer
(64bit) long ------ Long
(16bit) char ------ Character
(32bit) float ------ Float
(64bit) double ------ Double
(8bit) boolean ------ Boolean

2、常量的定义：
在定义变量的类型前面加final关键字，eg：final int aIntData = 1；
为什么final修饰的map、list可以修改数据，而final修饰String类型变量则不能修改数据呢？
①对List或map的add或put操作，没有修改地址。而对字符串的修改，是整个地址都要指向一个不同的字符串了。
②final 只是表示地址不可以修改，
如果你先写final   Map  map =new  HashMap(); ，
再写 map =new  HashMap(); 同样会报错 
③map和list是在栈中存储地址，final的意思是地址不能改，但是地址指向的内容当然可以改。
String本身就代表内容，是个值，所以不能改了

3、java运算符的优先级

4、数组：
声明格式：数组元素类型 数组名[ ]; 数组元素类型[ ] 数组名;使用new来为数组分配内存，创建数组之后系统自动为元素赋初值
int num[]; double[] total; num = new int[10];

5、java的基本语法
(1)程序结构：由不同的包组成，包由.java文件组成，每个.java文件有且只能有一个和文件同名的公共类/接口。
package con.example.application; //包声明：每个文件至多一句，声明类所在的包
import java.util.ArrayList; //import声明：文件中所引入的外部类声明
import java.util.list;
public class MyClass{ //公共类/外部类/接口：每个文件只能有一个公共类，类名必须和文件名一致。所有内部类、成员、方法、java代码的整个逻辑都写在公共类内。
public static void main (String []args){ //程序入口：java程序的入口方法，形式固定这样写

}

};
(2)标志符和关键字
• 标志符
▪ 在java语言中，用来标志类名、对象名、变量名、方法名、类型名、数组名、包名的有效字符序列，称为“标识符”；
▪ 标识符由字母、下划线、数字、美元符号组成，且第一个字符不能是数字；
▪ java语言区分大小写；
▪ 公司的命名规则：类名首字母大写，变量名用驼峰标志法，常量全大写，多个单词之间用“_”隔开，包名全小写。
· 标志符
▪ 在java语言中，有一些专门的词汇已经被赋予了特殊的含义，不能在使用这些词汇来命名标识符，这些专有的词汇称为“关键字”
(3)匿名内部类和Lamda表达式
两种高级的“语法糖”
匿名内部类：是一个表达式，用“;”结束；匿名类的语法就类似于调用一个类的构建函数，还包含了一个代码块，在代码块中完成类的定义；一个没有名字的类，是内部类的简化写法。
匿名类表达式包含以下部分：
①操作符：new
②一个要实现的接口或要继承的类
③一对括号，如果是匿名子类，与实例化普通类的语法类似，如果有构造参数，要带上构造参数；如果是实现一个接口，只需要一对括号即可
④一段被“{}”括起来类声明主体
⑤末尾的“；”（因为匿名类的声明是一个表达式，是语句的一部分，因此要以分号结尾）
⑥匿名内部类是局部内部类的更深入一步
⑦假如只创建某类的一个对象时，就不必将该类进行命名
⑧匿名内部类的前提是存在一个类或者接口，且匿名内部类是写在方法中的
⑨只针对重写一个方法时使用，需要重写多个方法时不建议使用
⑩匿名内部类的本质是继承该类或者实现接口的子类匿名对象
格式：
new 类名或者接口名() {
重写方法();
}

6、Java关键字：https://blog.csdn.net/z1web/article/details/89068217

private 一种访问控制方式：私用模式
protected 一种访问控制方式：保护模式
public 一种访问控制方式：共用模式
abstract 表明类或者成员方法具有抽象属性
class 类
extends 表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变
implements 表明一个类实现了给定的接口
interface 接口
native 用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new 用来创建新实例对象
static 表明具有静态属性
strictfp 用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
synchronized 表明一段代码需要同步执行
transient 声明不用序列化的成员域
volatile 表明两个或者多个变量必须同步地发生变化
被volatile修饰的变量能够保证每个线程能够获取该变量的最新值，从而避免出现数据脏读的现象。
break 提前跳出一个块
continue 回到一个块的开始处
return 从成员方法中返回数据
do 用在do-while循环结构中
while 用在循环结构中 
if 条件语句的引导词
else 用在条件语句中，表明当条件不成立时的分支
for 一种循环结构的引导词
instanceof 用来测试一个对象是否是指定类型的实例对象
switch 分支语句结构的引导词
case 用在switch语句之中，表示其中的一个分支
default 默认，例如，用在switch语句中，表明一个默认的分支
try 尝试一个可能抛出异常的程序块
catch 用在异常处理中，用来捕捉异常
throw 抛出一个异常
throws 声明在当前定义的成员方法中所有需要抛出的异常
import 表明要访问指定的类或包
package 包
boolean 基本数据类型之一，布尔类型
byte 基本数据类型之一，字节类型
char 基本数据类型之一，字符类型
double 基本数据类型之一，双精度浮点数类型
float 基本数据类型之一，单精度浮点数类型
int 基本数据类型之一，整数类型
long 基本数据类型之一，长整数类型
short 基本数据类型之一,短整数类型
null 空
true 正确
false 错误
super 表明当前对象的父类型的引用或者父类型的构造方法
this 指向当前实例对象的引用
void 声明当前成员方法没有返回值
goto 保留关键字，没有具体含义
const 保留关键字，没有具体含义

7、华为Java编程规则
包名称小写以.号隔开，自研代码以com.huawei开头，包名允许有数字
方法名称小驼峰
常量名称、枚举值全大写下划线分割

8、Java常用的集合

Collection：
List：List
> ArrayList：实现了长度可变的数组，在内存中分配连续的空间，遍历元素和随机访问元素的效率比较高；
List<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();
数据类型必须是引用数据类型，不能是基本数据类型

> LinkedList：采用链表存储方式，插入、删除元素时效率比较高；

以下情况使用 ArrayList :
• 频繁访问列表中的某一个元素；
• 只需要在列表末尾进行添加和删除元素操作。
以下情况使用 LinkedList :
• 需要通过循环迭代来访问列表中的某些元素；
• 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

Set：Set
> HashSet：底层是哈希表实现的，完全就是对HashMap的包装
①不能保证元素的排列顺序，元素是无序的；
②集合元素可以是null，但只能放入一个null；
③当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据hashCode值来决定该对象在HashSet中存储位置；
④因为底层是HashMap，而存储的又是Key，所有没有get()方法，只能通过遍历获取。
使用场景：
需要使用集合保存一组对象时，且要求对象不重复，并且对存取速度快的场景。
> TreeSet：底层是基于TreeMap实现的，而TreeMap是基于红黑树（二叉树）数据结构实现的。存储规则：左小右大
①TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态，不允许放入null值；
②TreeSet支持两种排序方式，自然排序和定制排序，其中自然排序为默认的排序方式。

collection类型的forEach方法：
taskMap.values().forEach(task->executor.scheduleWithFixedDelay(task,0,1,TimeUnit.MILLISECONDS));
taskMap.values()：返回map集合中所有的Value到一个Collection集合
task：为临时变量，类型为taskMap.values()里的元素，forEach里的Consumer实际是一个Lambda Function，并且可以访问函数体外定义的变量。

Map：Map<Integer, String>
> HashMap：
HashMap采用Entry数组来存储key-value对，每一个键值对组成了一个Entry实体，Entry类实际上是一个单向的链表结构，它具有Next指针，可以连接下一个Entry实体，依次来解决Hash冲突的问题，因为HashMap是按照Key的hash值来计算Entry在HashMap中存储的位置的，如果hash值相同，而key内容不相等，那么就用链表来解决这种hash冲突。
1. hashmap底层是以数组方式进行存储。将key-value对作为数组中的一个元素进行存储。
2. key-value都是Map.Entry中的属性。其中将key的值进行hash之后进行存储，即每一个key都是计算hash值，然后再存储。每一个Hash值对应一个数组下标，数组下标是根据hash值和数组长度计算得来。
3. 由于不同的key有可能hash值相同，即该位置的数组中的元素出现两个，对于这种情况，hashmap采用链表形式进行存储。

①数组存储方式key-value对;
②允许null作为key和value，key不可以重复，value可以重复；
③不保证元素迭代顺序是按照插入时的顺序，即不记录插入的顺序；
④key的hash值是先计算key的hashcode值，然后再进行计算，每次容量扩容会重新计算所以key的hash值，会消耗资源。
> TreeMap：
①基于红黑二叉树的NavigableMap的实现；
②不允许null，key不可以重复，value允许重复；
③存入TreeMap的元素应当实现Comparable接口或者实现Comparator接口，会按照排序后的顺序迭代元素。

map.containskey：判断是否有key
迭代器Iterator：Iterator iterator = list.iterator();
iterator.hasNext()：判断当前序列中是否还有元素存在，返回boolean，并没有指向的移动，不影响整体的遍历
iterator.next()：第一次调用时，返回序列中的第一个元素，并指向下一个元素，会影响整体遍历的执行
iterator.remove()：将迭代器返回的元素删除

9、java static关键字：
static的作用：方便在没有创建对象的情况下来进行调用
java运行时的数据区：

静态变量存在方法区，并且是被所有线程所共享的。
堆区:
1、存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
2、jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身
栈区:
1、每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中
2、每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。
3、栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
方法区:
1、又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。
2、方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量
10、java的多线程：
在 Java 语言中，线程是一种特殊的对象，它必须由 Thread 类或其子（孙）类来创建。通常有两种方法来创建线程：其一，使用型构为 Thread(Runnable) 的构造子类将一个实现了 Runnable 接口的对象包装成一个线程，其二，从 Thread 类派生出子类并重写 run 方法，使用该子类创建的对象即为线程。值得注意的是 Thread 类已经实现了 Runnable 接口，因此，任何一个线程均有它的 run 方法，而 run 方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java 语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为 synchronized）。

11、面向对象程序设计3个主要特征
封装性（encapsulation）：封装是一种信息隐蔽技术，它体现于类的说明，是对象的重要特性。封装使数据和加工该数据的方法（函数）封装为一个整体，以实现独立性很强的模块，使得用户只能见到对象的外特性（对象能接受哪些消息，具有哪些处理能力），而对象的内特性（保存内部状态的私有数据和实现加工能力的算法）对用户是隐蔽的。封装的目的在于把对象的设计者和对象的使用者分开，使用者不必知晓其行为实现的细节，只须用设计者提供的消息来访问该对象。
继承性：继承性是子类共享其父类数据和方法的机制。它由类的派生功能体现。一个类直接继承其他类的全部描述，同时可修改和扩充。继承具有传递性。继承分为单继承（一个子类有一父类）和多重继承（一个类有多个父类）。类的对象是各自封闭的，如果没继承性机制，则类的对象中的数据、方法就会出现大量重复。继承不仅支持系统的可重用性，而且还促进系统的可扩充性。
多态性：对象根据所接收的消息而做出动作。同一消息被不同的对象接受时可产生完全不同的行动，这种现象称为多态性。利用多态性用户可发送一个通用的信息，而将所有的实现细节都留给接受消息的对象自行决定，如是，同一消息即可调用不同的方法。例如：同样是 run 方法，飞鸟调用时是飞，野兽调用时是奔跑。多态性的实现受到继承性的支持，利用类继承的层次关系，把具有通用功能的协议存放在类层次中尽可能高的地方，而将实现这一功能的不同方法置于较低层次，这样，在这些低层次上生成的对象就能给通用消息以不同的响应。在 OOPL 中可通过在派生类中重定义基类函数（定义为重载函数或虚函数）来实现多态性。

12、源文件的声明规则
> 一个源文件中只能有一个public类；
> 一个源文件可以有多个非public类；
> 源文件的名称应该和public类名保持一致；
> 如果一个类定义在某一个包中，那么package语句应该放在源文件的首行；
> 如果源文件中包含import语句，则应该放在package语句和类定义之间，如果没有package语句，则应该放在源文件的最前面；
> import和package语句对源文件中定义的所有类都有效，在同一源文件中不能给不同的类不同的包声明。

13、成员变量个类变量的区别
由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。
不同的对象的实例变量将被分配不同的内存空间， 如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量，也就是说对象共享类变量。
成员变量和类变量的区别：
   1、两个变量的生命周期不同
      成员变量随着对象的创建而存在，随着对象的回收而释放。
      静态变量随着类的加载而存在，随着类的消失而消失。
   2、调用方式不同
      成员变量只能被对象调用。
      静态变量可以被对象调用，还可以被类名调用。
   3、别名不同
      成员变量也称为实例变量。
      静态变量也称为类变量。
   4、数据存储位置不同
      成员变量存储在堆内存的对象中，所以也叫对象的特有数据。
      静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。
static 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。
特点：
   1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
   2、被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。
   3、静态随着类的加载而加载。而且优先于对象存在。

14、java自动类型转换
转换的优先级：byte、short、char->int->long->float->double
必须满足转换前的数据类型的位数要低于转换后的数据类型的位数

15、java访问控制修饰符

> default：在同一包内可见，不使用任何修饰符，使用对象：类、接口、变量、方法；
> public：对所有类可见，使用对象：类、接口、变量、方法；
> private：对同一类可见，使用对象：变量、方法，不能修饰外部类；
> protected：对同一包内的类和所有子类可见，使用对象：变量、方法，不能修饰外部类；若子类和基类不在同一包中，那么在子类中，子类实例可以访问从其基类继承而来的protected方法，而不能访问基类实例的protected。

使用默认访问修饰符（不使用任何修饰符）声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final，而接口里的方法默认情况下访问权限为 public。

16、instanceof运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或者接口类型）；
格式：（object reference variable）instanceof（class/interface type）
如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。
String name = “James”;
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

17、java增强型for循环
java5引入了一种主要用于数组的增强型for循环
for(声明语句 ：表达式)
{
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等；
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

18、java的StringBuffer和StringBuilder类
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

19、java继承关键字
extends和implements来实现继承：
extends：java类的继承是单一继承，一个子类只能拥有一个父类，所以extends只能继承一个类
implements：使用这个关键字可以变相的使java具有多继承的特性，使用的范畴为类继承接口的情况，可以同时继承多个接口，接口和接口之前使用“，”分隔。

20、构造器
子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

21、java在编译阶段，只是检查参数的引用类型，在运行时，java虚拟机（JVM）指定对象的类型并且运行该对象的方法；

22、虚函数：java中其实没有虚函数的概念，它的普通函数就相当于C++的虚函数，动态绑定是java的默认行为，如果java中不希望某一个函数具有虚函数特性，可以加上final关键字变成非虚函数。

23、java接口（interface）
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
接口与类的区别：
> 接口不能用于实例化对象。
> 接口没有构造方法。
> 接口中所有的方法必须是抽象方法。
> 接口不能包含成员变量，除了 static 和 final 变量。
> 接口不是被类继承了，而是要被类实现。
> 接口支持多继承。
接口特性
> 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
> 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
> 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
抽象类和接口的区别
> 1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行；
> 2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的；
> 3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法；
> 4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
注：JDK 1.8 以后，接口里可以有静态方法和方法体了。
重写接口中声明的方法时，需要注意以下规则：
> 类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常；
> 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型；
> 如果实现接口的类是抽象类，那么就没必要实现该接口的方法。
在实现接口的时候，也要注意一些规则：
> 一个类可以同时实现多个接口；
> 一个类只能继承一个类，但是能实现多个接口；
> 一个接口能继承另一个接口，这和类之间的继承比较相似。

24、java servlet
Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。

25、java volatile关键字：保证可变量的可见性，如果被volatile变量修饰的变量的值发生了变化，其他线程立马可见，避免出现脏读的现象

26、java ScheduledExecutorService
ScheduledExecutorService接口是java线程池中最重要的几个接口之一，他除了支持原生的线程池功能之外还支持定时处理任务的功能，在JDK中为他提供了一个默认的实现类

27、java synchronized关键字
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；当有一个线程在访问对象中被关键字synchronized
   修饰的同步代码块时，其他试图访问该对象的线程将会阻塞，synchronized只锁定对象
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

28、java静态内部类
在外部类中调用内部类的属性和方法：
1、可以通过静态内部类的类名来调用静态内部类的静态属性（外部类名.静态内部类.属性）
2、可以通过静态内部类的全类名来调用静态内部类的静态方法（外部类名.静态内部类名.方法）
3、不能通过类静态内部类的全类名来调用内部类的非静态属性和方法
4、可以通过创建内部类实例来调用静态内部类的非静态属性和方法
在静态内部类中调用外部类的属性和方法：
1、可以直接调用外部类的静态属性
2、可以直接调用外部类的静态方法
3、直接调用外部类的非静态属性出错编译出错
4、直接调用外部类的非静态方法时编译出错
5、可以通过创建外部类实例来调用外部类的非静态属性
6、可以通过创建外部类实例来调用外部类的非静态方法
总结：
1、静态内部类中可以写哪些内容
1）匿名代码块
2）静态代码块
3）静态变量和非静态变量
4）静态方法和非静态方法
注意：不能在静态内部类中写抽象方法
2、外部类如何调用静态内部类中的属性和方法
1）外部类可以通过创建静态内部类实例的方法来调用静态内部类的非静态属性和方法
2）外部类可以直接通过“ 外部类.内部类.属性（方法）” 的方式直接调用静态内部类中的静态属性和方法
3、静态内部类如何调用外部类的属性和方法
1）静态内部类可以直接调用外部类的静态属性和方法
2）静态内部类可以通过创建外部类实例的方法调用外部类的非静态属性和方法
4、如何创建静态内部类实例
1）在非外部类中：外部类名.内部类名 name = new 外部类名.内部类名();
2）在外部类中：内部类名 name = new 内部类名();

29、java instanceof 关键字
instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

30、java CollectionUtils 工具类

31、java 并发编程
semaphore的使用：
tryAcquire：无参方法tryAcquire（）的作用是尝试的获得1个许可，如果获取不到则返回false，该方法通常与if语句结合使用，其具有无阻塞的特点。无阻塞的特点可以使线程不至于在同步处一直持续等待的状态，如果if语句判断不成立则线程会继续走else语句，程序会继续向下运行。

32、java try finally
1、不管有没有异常，finally中的代码都会执行
2、当try、catch中有return时，finally中的代码依然会继续执行
3、finally是在return后面的表达式运算之后执行的，此时并没有返回运算之后的值，而是把值保存起来，不管finally对该值做任何的改变，返回的值都不会改变，依然返回保存起来的值。也就是说方法的返回值是在finally运算之前就确定了的。
4、finally代码中最好不要包含return，程序会提前退出，也就是说返回的值不是try或catch中的值

33、java block
34、java HttpServletRequest
HttpServletRequest对象代表客户端的请求，当客户端通过HTTP协议访问服务器时，HTTP请求头中的所有信息都封装在这个对象中，通过这个对象提供的方法，可以获得客户端请求的所有信息。

35、java Properties
Properties（Java.util.Properties），该类主要用于读取Java的配置文件，不同的编程语言有自己所支持的配置文件，配置文件中很多变量是经常改变的，为了方便用户的配置，能让用户够脱离程序本身去修改相关的变量设置。就像在Java中，其配置文件常为.properties文件，是以键值对的形式进行参数配置的。

36、java ScheduledExecutorService
ScheduledExecutorService：是基于线程池设计的定时任务类，每个调度任务都会分配到线程池中的一个线程去执行，也就是说，任务是并发执行，互不影响。
需要注意，只有当调度任务来的时候，ScheduledExecutorService才会真正启动一个线程，其余时间ScheduledExecutorService都是出于轮询任务的状态。
newScheduledThreadPool ： 计划线程池，支持定时及周期性任务执行
轮询（Polling）是一种CPU决策如何提供周边设备服务的方式，又称“程控输入输出”（Programmed I/O）。轮询法的概念是：由CPU定时发出询问，依序询问每一个周边设备是否需要其服务，有即给予服务，服务结束后再问下一个周边，接着不断周而复始。
接口scheduleWithFixedDelay原型及参数说明：按指定频率周期执行某个任务。创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟，如果任务的执行时间超过了延迟时间（delay），下一个任务则会在（当前任务执行所需时间+delay）后执行。
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
long initialDelay,
long delay,
TimeUnit unit);
command：执行线程
initialDelay：初始化延时
delay：前一次执行结束到下一次执行开始的间隔时间（间隔执行延迟时间）
unit：计时单位

37、java @Produces注解
注解@Produces 用于定义方法的响应实体的数据类型，可以定义一个或多个，同时可以为每种类型定义质量因素（qualityfactor）。质量因素是取值范围从0到1的小数值。如果不定义质量因素，那么该类型的质量因素默认为1
@Produces(MediaType.APPLICATION_JSON)：媒体类型为JSON

38、java发送http请求的两种方式：HTTPClient和CloseableHttpClient
39、javax.ws.rs restful开发
@Path注解位置 类注解 方法注解
①标注class时：表明该类是个资源类，凡是资源类必须使用该注解
②标注method时：表示具体的请求资源的路径
@GET @POST @PUT @DELETE 注解位置 方法注解
指明接收HTTP请求的方式属于get,post,put,delete中的哪一种，具体指定请求方式，是由客户端发起请求时指定
@Consumes 注解位置 方法注解
指定HTTP请求的MIME类型 默认是*/* 表示任意的MIME类型 该注解支持多个值设定 可以使用MediaType来指定MIME类型
MediaType的类型大致有
application/xml
application/atom+xml
application/json
application/svg+xml
application/x-www-form-urlencoded
application/octet-stream
multipart/form-data
text/plain
text/xml
text/html
@Produces 注解位置 方法注解
指定HTTP响应的MIME类型 默认是*/* 表示任意的MIME类型 同Consumes使用MediaType来指定MIME类型
@PathParam 注解位置 参数注解
配合@Path进行使用 可以获取URI中指定规则的参数
@QueryParam 注解位置 参数注解
用于获取GET请求中的查询参数 实际上是url拼接在?后面的参数
@FormDataParam 注解位置 参数注解
用于获取POST请求且以form(MIME类型为multipart/form-data)方式提交的表单的参数 通常是在上传文件的时候
@HeaderParam 注解位置 参数注解
用于获取HTTP请求头中的参数值
@CookieParam 注解位置 参数注解
用于获取HTTP请求cookie中的参数值
@Context注解：将各种有用的资源（如HTTP标头）注入到端点中，@Context注释是一个通用注释，它注入以下对象的实例：
> HttpHeaders- > HTTP标头参数和值
> UriInfo- >捕获路径变量和查询参数
> SecurityContext- >提供对请求的安全性相关信息的访问
> ResourceContext- >提供对资源类实例的访问
> 请求 ->前提条件请求处理
> 应用程序 ， 配置和提供程序 ->提供有关JAX-RS应用程序环境的信息
> HttpServletRequest- >提供对HttpServletRequest实例的访问
> HttpServletResponse- >提供对HttpServletResponse实例的访问
> ServletConfig- >提供对ServletConfig的访问
> ServletContext- >提供对ServletContext的访问
Jetty 是一个开源的servlet容器，它为基于Java的web容器，例如JSP和servlet提供运行环境。Jetty是使用Java语言编写的，它的API以一组JAR包的形式发布。开发人员可以将Jetty容器实例化成一个对象，可以迅速为一些独立运行（stand-alone）的Java应用提供网络和web连接。
javax.ws.rs webservice注解：
@javax.ws.rs.GET
表示此方法响应一个HTTP GET请求。
@javax.ws.rs.POST
表示此方法响应一个HTTP POST请求。
@javax.ws.rs.PUT
通常用来更新数据。
@javax.ws.rs.DELETE
通常用来删除数据。
@javax.ws.rs.Produces
设置Http返回报文，报文体的内容类型。
取值为 javax.ws.rs.core.MediaType.XXX。常用的有：
MediaType.APPLICATION_JSON
MediaType.TEXT_PLAIN

40、java泛型编程
T与T的用法：
T是Type的首字母缩写； T 表示“返回值”是一个泛型，传递什么类型，就返回什么类型；而单独的“T”表示限制传递的参数类型。
T的用法：
T表示返回值T是泛型，T只是一个占位符，用来告诉编译器，这个东西先给我留着，等我编译的时候再告诉你是什么类型。
单独T的用法：
单独的T表示限制参数的类型

41、java String类
hashCode()方法：用于返回字符串的哈希码
trim()方法：用于删除字符串头尾的空白符
split()方法：返回值是一个String[]，根据指定字符分割

42、i++ 和++i
i++和++i是有区别的,
i++是在一个先使用后加1，即先使用i的值，后让i+1
++i则是先加1后使用,即先让i+1后再使用i的新值

43、java try catch的用法
try {
// 可能出现的异常的代码
} catch （异常的类名A e）{ 可以有很多个catch
// 如果出现A类型异常则执行该处代码
} finally {
// 最终肯定必须会执行的，比如需要释放资源的代码
}
代码执行的顺序：
> 1.try内的代码从出现异常的那一行开始，中断执行
>  2.执行对应的catch块内的代码
>  3.继续执行try catch结构之后的代码
>   注意点：
>  1.如果catch内的异常类存在子父类的关系，那么子类应该在前，父类在后
>  2.如果最后中有返回语句，那么最后返回的结果肯定以最终中的返回值为准
>  3.如果最后语句中有回报，那么没有被处理的异常将会被吞掉

44、java SpringMVC https://www.cnblogs.com/jimisun/p/9720684.html
> 什么是SpringMVC？
SpringMVC就是一个严格遵循MVC设计模式的框架。说其是一个框架，那么SpringMVC框架中就应该有与Model，View，Controller相对应的组件；分别是Model模型对象，视图解析器，Controller控制器。
常用注解
@Autowired：对类成员变量、方法、以及构造函数进行标注，完成自动装配工作。通过Autowired的使用来消除set、get方法

45、java并发编程
1、原子性：即一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行
2、可见性：指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看到修改的值
3、有序性：即程序执行的顺序按照代码的先后顺序执行

46、java参数传递时按值传递还是引用传递
答：java中只有按值传递
java的数据类型：

基本数据类型的按值传递并不会改变原函数中的值；
引用数据类型的按值传递都是传递对象的地址，会对原函数中的值改变。对于对象参数，按值传递中的值的内容是对象的引用。
String每次操作完之后都会new一个新的String，StringBuffer是操作完返回自己，所有String不会改变原函数中的值，而StringBuffer会改变原函数中的值。
值传递和引用传递的区别并不是传递的内容，而是实参到底有没有被复制给形参。

47、java Spring框架
Spring就是作为容器去管理你的类，有Spring管理的类在整个服务器启动期间在内存中只生成一份；它存在的目的就是为了简化java的开发
Spring的Ioc（控制反转和依赖注入）
控制反转：就是由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。
依赖注入：组件之间的依赖关系由容器在运行期决定 ，由容器动态的将某种依赖关系注入到组件之中。

48、java反射
概念：反射是一种机制，让我们可以在运行时获取类的信息

49、事务的ACID是指什么？
原子性(Atomic)：事务中各项操作，要么全做要么全不做，任何一项操作的失败都会导致整个事务的失败；
一致性(Consistent)：事务结束后系统状态是一致的；
隔离性(Isolated)：并发执行的事务彼此无法看到对方的中间状态；
持久性(Durable)：事务完成后所做的改动都会被持久化，即使发生灾难性的失败，通过日志和同步备份可以在故障发生后重建数据。

50、java多线程
多线程的三大特性：原子性、可见性、有序性
创建线程的三种方式：
1.继承Thread（重点），重写run()方法，在main函数中，调用start()方法
2.实现Runnable接口（重点），重写run()方法，在main函数中，调用start()方法
3.实现Callable接口（了解），重写call()方法，在main函数中调用start()方法
start()方法调用后并不是立即执行多线程代码，而是使该线程变成可运行台态（Runnable），什么时候运行由操作系统决定，而run()方法是多线程程序的一个约定，
所有的多线程代码都在run方法里，实现Runnable接口的好处：可以资源共享，操作的都是同一个对象，更能体现面向对象的思维
1.避免继承的局限！因为一个类可以实现多个接口。
2.适合于资源的共享。
3.线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类。
4.增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
sleep()和wait()的区别？
答：1. sleep()睡眠时，保持对象锁，仍然占有该锁；而wait()睡眠时，释放对象锁。　
　　2. sleep()是Thread类的方法，wait()是Object的方法
　　3.wait()只能在同步方法或者同步代码块里面使用，而sleep()可以在任何地方使用
　　4.sleep只有睡够时间才能醒，wait可以随时唤醒

51、LinkedBlockingQueue：是一个单向链表实现的阻塞队列，只有next（指向下一个节点的指针），没有prev（指向前一个节点的指针）

public LinkedBlockingQueue(intcapacity)：此构造函数指定了队列的大小，初始化了last和head节点，让他们指向了一个元素为null的节点。last=head=newNode(null);
入队操作函数：
void put(E e)：
队列已满，阻塞等待；
队列未满，创建一个node节点放入队列中，如果放完以后队列还有剩余空间，继续唤醒下一个添加线程进行添加。如果放之前队列中没有元素，放完以后要唤醒消费线程进行消费。
boolean offer(E e)：
队列有可用空间，放入node节点，判断放入元素后是否还有可用空间， 如果有，唤醒下一个添加线程进行添加操作
offer仅仅对put方法改动了一点点，当队列没有可用元素的时候，不同于put方法的阻塞等待，offer方法直接方法false。
boolean offer(E e, long timeout, TimeUnit unit);
出队操作函数：
E take():
队列为空，阻塞等待;
队列不为空，从队首获取并移除一个元素，如果消费后还有元素在队列中，继续唤醒下一个消费线程进行元素移除。如果放之前队列是满元素的情况，移除完后要唤醒生产线程进行添加元素。
E poll():
poll方法去除了take方法中元素为空后阻塞等待这一步骤

52、内部类
内部类是被定义于另一个类中的类，使用内部类的主要原因：
◇ 一个内部类的对象可访问外部类的成员方法和变量，包括私有的成员。
◇ 实现事件监听器时，采用内部类、匿名类编程非常容易实现其功能。
◇ 编写事件驱动程序，内部类很方便。
因此内部类所能够应用的地方往往是在AWT的事件处理机制中。

53、Servlet
Servlet：是用java编写的服务端应用程序作用：主要用于交互式的浏览和修改数据，生成web内容，这个过程为：客户端发送请求到服务器 -> 服务器将请求信息发送至Servlet –>Servlet生成相应内容并将其传给服务器-> 服务器将响应返回给客户端。
浏览器创建一个http请求：

http请求发送到服务器
服务器找到该界面
生成http响应
http响应被发回浏览器
浏览器显示改界面