JAVA知识笔记

基本介绍

特性与优势

• 面向对象
• 可移植性
• 高性能（即使编译）
• 分布式
• 动态性（反射机制）
• 多线程（多个任务同时执行）
• 安全性
• 健壮性
• 简单性

JAVA三大版本

• javaSE：标准版本（桌面程序，控制台开发）
• javaME：嵌入式开发 （手机，小家电）
• javaEE：E企业级开发 （web端，服务器端）

JDK,JRE,JDK

​ jre是java基本的一个运行环境，jdk包含有jre的运行环境的同时还有一些开发工具。是开发工具包

java程序运行机制

• 编译型 -将编程语言编译成机器可运行的语言
• 解释型 -走一步解释一步，运行一段编译一段

java先将javac进行编译形成一个.class文件，再对class文件进行解释给操作系统平台

语法基础

注释

• 单行注释 (//)
• 多行注释 (/* xxxxx */)
• 文档注释 (/** *xx *xx */)

javaDoc

生成说明文档

• @author
• @Version
• @Since
• @param
• @return
• @throws

#生成程序帮助文档
javadoc -enconding UTF-8 charset UTF-8 文件名

标识符

• 标识符应该以字母(a-z)，美元符号($)，或者下划线(_)开始
• 字母大小写敏感
• 不可使用关键字来命名

数据类型

强类型语言

变量的使用要严格符合规定（符合数据类型定义），所有变量必须先定义后使用

• 安全性提高
• 运行速度下降

java数据类型分为两类

基本数据类型（8个）

数值类型

整数类型

• byte 1个字节 -128-127
• short 2个字节 -32768-32767
• int 4个字节 -2147483648-2147483647
• long 8个字节 -9223372036854775808-9223372036854775807 （数字后加L表示，50L）

浮点类型

• float 4个字节 （数字加F表示，50.1F）
• double 8个字节

字符串类型

• char 2个字节

boolean布尔类型：1个字节，只有true与false

引用类型

类

接口

数组

类型转换

低到高转换顺序

byte,short,char-->int-->long->float-->double

注意

1. 布尔值不能转换
2. 不想同的数据类型不能转换
3. 高精度转低精度时，需要强制转换
4. 转换可能会出现精度丢失或内存溢出等问题
5. 低转高自动转换

什么是字节

• 位（bit）：是计算机 内部存储 的最小单位，11001100是一个八位二进制数字
• 字节（byte）：是计算机中 数据处理 的基本单位，习惯用大写B来表示。
• 1B （byte，字节）=8bit位
• 字符；是指计算机中使用的字母、数字、字和符号

java进制数表示

• 二进制 0b
• 十进制
• 八进制 0 (int i2=010 (8))
• 十六进制 0x （int i3=0x10 (16) )

数据类型拓展

浮点数不可以用于比较

浮点数是有限的数值，比较的结果离散的，会进行舍入操作，有舍入误差，数值接近但不等于

比较浮点数可以使用 BigDecimal

所有的字符本质还是数字

可以对字符 char类型进行int的强制转换，转换得出的结果对应Unicode编码中的编码

变量

定义

• 可以变化的量
• java是一种强类型语言，每个变量都必须声明其类型
• java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

注意事项

• 每个变量都有类型，可为基本类型或应用类型
• 变量名为合法标志符
• 声明是一个完整的语句，以分号 ; 结束

常量

• 使用 final 来定义
• 初始化后值不能改变，值不会变动

变量名命名规则

• 变量，方法，类名：见名知意
• 类成员变量：首字母小写和驼峰原则：lastName
• 局部变量名：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首 字母大写 和驼峰
• 方法名：首字母小写和驼峰

变量作用域

• 类变量 （static（静态）修饰）
• 实例变量（在类下，从属于对象）
• 局部变量（在方法内，在方法里有效，必须声明和初始化值）

变量默认值

• 基本数据类型默认值为0 或0.0
• 布尔值的默认值为false
• 除了基本数据类型，其余都是null

运算符

• 算术运算符
• 赋值运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 条件运算符
• 扩展运算符

自增符

• i++:执行代码后，先赋值，后自增
• ++i:执行代码前，先自增，后赋值

幂运算

使用java工具 Math.pow(3,2) 3的2次方

逻辑运算&和&&区别

• &逻辑运算，两个都为真才为真，&两边都会执行
• &&短路运算，两个都为真才为真，前端为false，后端不执行

位运算

• 用二进制运算，效率高，常用于算法之中

System.out.print(2<<3);
//结果位8
/*
<< *2
>> /2

0000 0000 0
0000 0001 1
0000 0010 2
0000 0100 4
0000 1000 8
0001 0000 16
*/

String + 号拼接问题

int a=10;
int b=20;
System.out.println(""+a+b);
//结果位1020，""先将a和b转换位字符串，再拼接
System.out.println(a+b+"");
//结果为30，先将a+b运算，再转换为字符串拼接

三元运算符号

/*
x ? y : z
如果x为真，结果为y,否则为z
*/

流程结构

顺序结构

• java基本的结构就是顺序结构，按照顺序一句一句执行
• 从上到下顺序进行，任何一个算法都离不开的基本结构

选择结构

if选择

• if单选结构
• if双选结构
• if多选结构
• 嵌套的if结构
• switch多选择结构

switch选择

• jdk支持了Stirng类型
• 缺少break，出现case穿透现象
• default

循环结构

• while
• do....while
• for

for循环

• for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构
• for循环执行的次数在执行前就确定的。

//for循环多个参数定义
for(int i=0;j=array.length-1,i<array.length;i++,j--){
    //循环体
}

九九乘法表

for(int j=1;j<=9;j++){
    for(int i=1;i<=j;i++){
        //"\t"table空格
        System.out.print(j+"*"+i+"="+(j*i)+"\t");
    }
    System.out.println();
}

break和continue

• break在任何循环语句的主体部分，均可用break控制循环的流程
• break用于强制退出循环，不执行循环中剩余的语句
• continue语句用在循环语句体中，用于终止某次循环过程，接着进行下次循环的判定
• continue通过 outer标签 跳转到外层指定层级的循环
• goto关键字是java的一个保留字，但并未在语言中正式使用，但能使用break和continue看到相应的影子

方法

定义

java方法是语句的集合，用特定的代码片段完成特定功能。

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用

设计原则

方法本意是功能块，是实现某个功能的语句块和集合，设计时最好保持方法的原子性，就是一个方法只完成一个功能 ,利于后期扩展。

方法组成

方法包含一个方法头和一个方法体

• 修饰符：可选，告诉编译器如何调用该方法，定义该方法的访问类型
• 返回值类型：放回值的类型，没有放回值则用void
• 方法名：方法的实际名字，方法名和参数表共同构成方法签名
• 参数类型：可选，参数是一个占位符号，当方法被调用时，传递值给参数。可分为 形式参数 :在方法被调用时用于接收外界输入数据。 实参: 调用方法时实际传给方法的数据
• 方法体：方法体包含具体的语句，定义该方法的功能。

/* 修饰符 返回值类型 方法名(参数类型，参数名){
	方法体
	return 返回值;
}

方法的调用

• 静态方法：static修饰的方法，可直接通过类名来调用
• 非静态方法：需要实列化（new）类来调用方法
• 形参和实参：形参参数的名，实参传递的数据，两者类型需要相同
• 值传递和应用传递
• this关键字

方法的重载

重载：在一个类中，相同的函数名，但形参不同的函数

重载的规则

• 方法名称必须相同
• 参数列表必须不同（个数，类型，参数排列顺序等）
• 方法的返回类型可以相同也可以不相同
• 仅仅返回类型不同，不可以重载方法

可变参数

• JDK 1.5开始，java支持传递同类型的可变参数给一个方法
• 在方法声明中，在指定参数类型后加一个省略号(...)
• 一个方法只可以有一个可变参数，必须在方法的最后一个参数。

public void test1(int...a){
  }

命令行传参数

通过命令行给main方法传递参数

public static void main(String [] args){    for(int i=0;i<args.length;i++){        System.out.println(args[i])    }}

命令行传参

#先编译#javac 文件名javac hello.java#java 文件 参数java hello hello1 world

递归

定义

• 方法自身调用自己
• 递归的能力在于在有限的语句来定义对象的无限集合。

递归结构

• 递归头：什么时候不调用自身方法，若没有将会死循环
• 递归体：什么时候需要调用自身方法

数组

定义

• 数组是相同类型数据的有序集合
• 按照一定先后次序排列组合而成
• 每一个数组称作一个数组元素，每个数组元素可以通过小标来访问它们
• 通过索引进行访问，即下标一般从“0”开始

java简单内存分析

java内存

堆

• 存放new对象和数组
• 可以被所有的线程共享，不会存放别的对象引用

栈

• 存放基本变量类型（会包含这个基本类型的具体数值）
• 引用对象的变量（会存放这个引用在堆里面的具体地址）

方法区

• 可以被所有的线程共享
• 包含所有的class和static变量

数组的特征

• 数组长度是确定的，一旦被创建，大小不可以改变。
• 其元素的数据类型必须相同，不允许有混合类型
• 数组元素可以是任何数据类型，包括基本数据类型和引用数据类型
• 数组变量属于引用类型，数组也可以看成是对象，数组中的元素相当于其中的成员变量
• 数组本身就是对象，java中对象是在堆中，因此数组本身是在堆中

多维数组

多维数组就是数组的元素中还是数组。

//二维数组int[][] arr = new int[11][11];int [][] array={{2,3},{4,5}};

Arrays类

• 数组的工具类，java.util.Arrays
• Arrays类中的方法都是static修饰的静态方法，使用是可以直接使用类名调用

具有以下功能

• 给数组赋值:通过fill方法
• 对数组排序:通过sort方法，升序
• 比较数组:通过equals方法比较数组中的元素是否相等
• 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法的操作

排序方法

八大排序方法

内部排序

插入排序

直接插入排序

希尔排序

选择排序

简单选择排序

堆排序

交换排序

冒泡排序

快速排序

归并排序

基数排序

外部排序

冒泡排序

• 比较数组中两个相邻元素的大小，如果第一个元素比，第二个元素大，则交换他们的位置
• 每一次比较，都会产生出一个最大，或者最小的数字
• 下一轮可以减少一次排序
• 依次循环比较
• 嵌套循环，时间复杂度为O(n^2)

//临时变量int temp=0//外层循环，判断需要循环多少次for(int i=0;i<array.length-1;i++){    //标志位    boolean flag=false;    //内层比较大小,比较完的可以不用再进行比较    for(int j=0;j<array.length-1-i;j++){        if(array[j]>array[j+1]){            temp=array[j];            array[j]=array[j+1];            array[j+1]=temp;            flag=true;        }      }    if(flag==false){        break;    }}return array;

稀疏数组

• 当一个数组中大部份元素的值相时，可以使用稀疏数组保存，节省空间
• 记录数组一共有几行几列，有多少个不同的值
• 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

//创建一个二维数组 11*11 记录棋盘棋子信息 0:没有棋子 1：黑棋 2:白棋        int [][] array1=new int[11][11];        array1[1][2]=1;        array1[2][3]=2;        //输出原始数组        System.out.println("原始数组");        for (int[] ints:array1){            for (int anInt:ints){                System.out.print(anInt+"\t");            }            System.out.println();        }        System.out.println("=========");        //转换位稀疏数组保存        //获取有效值的个数        int sum=0;        for (int i=0;i<11;i++){            for (int j=0;j<11;j++){                if (array1[i][j]!=0){                    sum++;                }            }        }        System.out.println("稀疏数组");        System.out.println("有效值的个数"+sum);        //创建一个稀疏数组        int[][] array2=new int[sum+1][3];        array2[0][0]=11;        array2[0][1]=11;        array2[0][2]=sum;        //遍历二维数组，将非零的值，存放稀疏数组中        int count=0;        for (int i = 0; i < array1.length; i++) {            for (int j=0;j<array1[i].length;j++){                if (array1[i][j]!=0){                    count++;                    array2[count][0]=i;                    array2[count][1]=j;                    array2[count][2]=array1[i][j];                }            }        }        //输出        for (int i = 0; i < array2.length; i++) {            System.out.println(array2[i][0]+"\t"                    +array2[i][1]+"\t"                    +array2[i][2]+"\t");        }        //还原稀疏        //读取稀疏数组        int[][] array3=new int[array2[0][0]][array2[0][1]];        //给其中的元素还原它的值        for (int i = 1; i < array2.length; i++) {            array3[array2[i][0]][array2[i][1]]=array2[i][2];        }        System.out.println("=========");        //打印        System.out.println("输出还原数组");        for (int[] ints:array3){            for (int anInt:ints){                System.out.print(anInt+"\t");            }            System.out.println();        }    }

面向对象编程

面向过程思想

• 步骤清晰，
• 面对过程适合处理一些简单问题

面向对象思想

• 物以类聚，分类的思维模式，思考问题首先需要那些分类，然后对这些分类进行单独思考，最后，对某个分类下的细节进行面向过程的思考。
• 适合处理复杂问题，需要多人协作处理问题

对于复杂的事物，从宏观上把握、合理分析，需要使用面向对象的思路分析整个系统。但是具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

• 面向对象编程（Object-Oriented Programming，oop）
• 面向对象的本质是：以类的方式组织代码，以对象的方式组织（封装）数据
• 抽象：把对象中所共有的东西抽取出来，形成大家所共有的东西
• 从认识的角度考虑是，先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
• 从代码运行考虑是现有类后有对象。类是对象的模板

三大特性

• 封装：把数据包装起来，定义私有属性，通过set，get暴露出来给方法调用
• 继承：子类继承父类所有的属性
• 多态：同一个事物，会有多种形态，同一个对象有不同的表现形式

类与对象的关系

• 类是一种抽象的数据类型，它是对某一事物整体描述/定义，但是不能代表某一个具体的事物。
• 类是抽象的，只有在实例化（new）的时候，才成为对象
• 类实例化后，返回一个自己的对象
• student对象就是一个student类的具体实例

创建与实例化对象

• 使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化，以及对类的构造器的调用

构造器

• 类中的构造器也称为构造方法，是进行创建对象的时候必须调用的。有以下特点

1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void
3. 定义有参构造器时，需要显示定义无参构造器

封装

​ 程序设计追求”高内聚，低耦合“。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

封装（数据的隐藏）

• 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问。
• 属性私有化，get/set表示

继承

• 继承的本质是对某一批类的抽象
• extends的意思是 ”扩展“ 的意思，子类是父类的扩展
• JAVA中只有单继承，没有多继承
• 继承是类和类之间的一种关系。除此外类和类之间还有依赖关系、组合、聚合。
• 子类和父类之间，应该是”is a“关系

instanceof

判断是否为继承关系，返回true和false

super与this关键字

• super关键字的作用是调用父类中的构造器，且在代码的首行
• this关键字是调用类自身的构造器，且在代码的首行
• super和this不能同时调用构造方法

方法的重写

• 重写是方法的重写，和属性无关
• 静态方法不能被重写
• 重写发生在继承当中，子类重写父类中的方法
• 方法名相同，参数列表相同
• 修饰符范围可以扩大，但不能缩小：Public>Protected>Default>Private
• 抛出的异常：范围可以缩小，但不能扩大；ClassNotFoundEXception -->Exception(大)

多态

同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态的存在条件

• 有继承关系
• 子类重写父类的方法
• 父类引用指向子类的对象

多态注意事项

• 多态是方法的多态，属性没有多态

• 父类和子类，继承关系，方法需要重写

• 父类引用指向子类 Father f1=new Son();

理解

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性是对象多种表现形式的体现。

现实中，比如我们按下 F1 键这个动作：

• 如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
• 如果当前在 Word 下弹出的就是 Word 帮助；
• 在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

多态的优点

• 消除类型之间的耦合关系
• 可替换性
• 可扩充性
• 接口性
• 灵活性
• 简化性

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象：Parent p = new Child();

类型转换

父类需要调用子类的方法需要进行强制类型转换

由父类转换成子类，由高转低，需要强制类型转换

由子类转成父类，由低转高，不需要强类型转换，会丢失精度，失去子类的方法

抽象类

• abstract修饰符可以用来修饰类或者修饰方法，如果方法即为抽象方法，修饰类，即为抽象类

• 抽象类中可以没有抽象方法，但是有抽象方法的类必须为抽象类

• 抽象类，不能实例化（new）来创建，它是通过子类来继承的

• 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

• 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

特点

• 不能实例化（new）抽象类，只能继承，靠子类去实现它：约束
• 抽象类中可以写普通方法
• 抽象方法必须在抽象类中

接口

• 接口就是规范，定义的是一组规则，体现了现实世界中，“如果你是...则必须能...”的思想，如果你是汽车，则必须能跑，如果你是好人，必须做好事等。
• 接口的本质是契约，就像法律一样，我们必须遵守
• OOP的精髓，是对对象的抽象，能体现这一点的就是接口。
• 接口的关键字是interface

作用

• 约束
• 定义一些方法，让不同的人实现
• 可以实现多个，必须重写接口中的方法

内部类

内部类就是在一个类中定义一个类，比如在A类中定义了一个B类，那么B类相对A类来说就是内部类，反之为外部类。

可获取外部内中的私有属性和私有方法

可以分为：

• 成员内部类
• 静态内部类
• 局部内部类：方法里定义类
• 匿名内部类

异常

定义

• 异常指，程序运行中出现不期而至的各种状况，如找不到文件、网络连接失败、非法参数等
• 异常发生在程序运行期间，它影响正常的程序执行流程

分类

• 检查性异常：最有代表的是用户输入错误或问题引起的异常，这是程序无法预见的。
• 运行时异常：运行时异常是可能被程序员比避免的异常。与检查时相反，运行时异常可在编译时被忽略
• 错误ERROR：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，他们在编译也检查不到。

异常体系

• java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为异常的超类
• 在javaAPI中定义了许多异常类，主要分为 错误ERROR和 异常Exception

ERROR

• Error类对象由java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
• java虚拟机运行错误，当JVM不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError 。这些异常发生时，java虚拟机，一般会选择线终止
• 虚拟机试图执行应用时，如类定义错误、链接错误。这些错误是不可查的，因为它们在应用程序控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
• StackOverFlow ：栈溢出
• OutOfMemory：内存溢出

Exception

在Exception分支中有一个重要子类，RuntimeException（运行时异常）

运行时异常

一般是指我们开发中，编译运行程序后，遇到在控制台所发生的异常，一般有：

• ArrayIndexOutOfBoundsException（数组下标越界）
• NullPointerException（空指针异常）
• ArithmeticException （算术异常）
• MissingResourceException （丢失资源）
• ClassNotFoundException （找不到类）

这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度避免这类异常

非运行时异常（一般异常）

checked exceptions，非运行时异常 （编译异常）：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。通俗的话说就是在写代码时出现红线，需要try catch或者throws时出现的异常。

运行和非运行的区别

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

Error和Exception区别

Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应尽可能的去处理这些异常。

处理机制

• 抛出异常：throw、throws
• 捕获异常：try、catch、finally
• 常用关键字：try、catch、finally、finally、throw、throws

自定义异常

步骤

1. 创建自定义异常类，继承Exception类
2. 在方法中通过throw关键字抛出异常对象
3. 如果在当前抛出异常的方法中处理异常，可以使用trycatch语句捕获并处理；否则在方法声明处通过throws指明抛出给方法调用者的异常，继续执行下一步
4. 在出现异常方法的调用者中捕获并处理异常

常用类

Object类

• hashcode（）
• toString（）
• clone（）
• getClass（）
• notify（）
• wait（）
• equals（）

Math类

• 常见数学运算

Random类

• 生成随机数

File类

• 创建文件
• 查看文件
• 修改文件
• 删除文件

包装类

• 自动装箱和拆箱

Date类

• Date
• SimpleDateFormat（yyy-MM-dd:HH:mm:ss）

String

• 字符串内容不可以改变 final，操作量少

StringBuffer

• 字符长内容可以改变 append（）
• 多线程，数据量较大时,效率低，安全

StringBuilder

• 字符串内容可以改变
• 单线程，数据量较大，效率高，不安全

集合框架

Collection

List（有序可重复）

ArrayList（数组）

add（）

remove（）

contains（）

size（）

LinkedList （链表）

getFirst（）

getLast（）

removeFirst（）

addFirst（）

Vector（迭代器）

Stack（栈）

Set（无序不可重复）

HashSet

TreeSet

Map

HashMap

TreeMap

IO流

字节流

• 输出：OutputStream
• 输入：InputStream

字符流

• Reader
• Wirter

节点流

• CharArrayReader，Writer，inputStream，outputStream
• StringReader，Writer
• pipe（管道流）PipedOutputStream

处理流

buffer

bufferInputStream

bufferOutputStream

bufferReader

bufferwirter

data

DataInputStream

DataOutPUtStream

转换流

InputstreamReader

OutputStreamWriter

filter （四个）

object (四个)

print

PrintWirter

printStream

序列化 反序列化 Serializable transient（透明）

多线程

• 进程和线程
• run（），start（）

线程创建的方式

• Thread start0，本地方法，java无权调用，交给底层的C处理 private native void start0（）；
• Runnable 函数式接口 lambda
• Callable 可以有返回值

静态代理

• new Thread（Runnable）.start（）

Lambda表达式

• 函数式编程
• 避免内部类定义过多

线程状态

• 新建状态：生成线程对象，并没有调用start（）方法
• 就绪状态：线程调用start（）方法后，进入就绪状态， 线程位于可运行线程池中，等待被调度
• 运行状态：线程获得cpu使用权，执行代码块
• 阻塞：因某种原因放弃了cpu的使用权，让出了cpu，暂时停止运行。直到线程进入到就绪状态，后被调度再次运行
  • 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
  • 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
  • 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。
• 死亡：线程执行run（）方法结束，或因异常退出run（）方法，线程运行状体结束。

线程常用方法

• sleep
• join
• yield
• isLive
• start
• setPriority
• interrupt

线程同步

• 多个对象操作同一个资源，并发
• 队列+锁

Synchronized

• 同步方法 弊端：锁太多
• 同步代码块（常用）
• 第一个线程进来拿到锁，后面就要排队，直到这个人释放锁，后面拿到锁才能进去
• 死锁 互斥，请求保持，不剥夺条件，循环等待条件

Lock（优先级高）

• ReentrantLock lock，trylock，unlock

线程通信

• 缓冲区：消息队列
• 标志位： 红绿灯
• wait（）
• notifyAll（） 唤醒

线程池

• 池化技术
• 池的大小
• 最大连接数目
• 保持时间

网络编程

• ip
• 端口
• Socket编程
• TCP 三次握手，四次挥手，面想连接
• UDP 无连接，Packet
• URL
• Tomcat
• 聊天通信
• 文件上传

注解和放射

注解

• 元注解
• 内置注解
• 自定义注解
• 放射注解

反射

• Class newInstance（）
• 类加载机制
• Method invoke，存在重载，也需要写参数的类型
• Field set
• Construct
• 破坏私有关键字
• 性能分析
• 放射获得注释，泛型