Java技术总结（基础篇）

仅对部分java基础内容做了简单整理，若有笔误或错误出现，欢迎大家指教。

一、JavaSE

1.Java分为三个体系：

• JavaSE→java平台标准版
• JavaEE→java平台企业版
• JavaME→java平台微型版

2.Java编程语言主要特性：

• 面向对象
• 分布式
• 简单化
• 多线程
• 安全
• 跨平台移植性

3.JVM、JRE、JDK

• JVM：Java虚拟机(主要用于与操作系统进行交互)
• JRE:Java运行时环境(包含了JVM，Java提供的核心类库)
• JDK:Java开发工具包(包含了JRE，Java开发工具集)

4.JDK包结构

• ①为了便于使用和维护，JDK类库按照包结构划分，不同功能的类划分在不同的包中。
• ②java.lang→Java程序的基础类，如字符串、多线程等该包中的类使用的比较频繁，不需要导包，可以直接使用。
• ③java.util→常用的工具类，如集合、随机产生器、日历等。
• ④java.io→文件操作，输入/输出操作。
• ⑤java.math→数学运算相关的操作。
• ⑥java.sql→数据库访问。

5.标识符命名规范：

• ①由26个英文字母大小写，0~9，_或$组成。
• ②数字不能开头。
• ③不能包含空格。
• ④java严格区分大小写。
• ⑤不能使用关键字，可以包含关键字。
• ⑥尽量"见名知意"。

6.变量名命名规范：

• ①长度不能超过255个字符
• ②※变量名在有效范围内必须是唯一的(声明变量)
• ③多单词组成时，第一单词首字母小写，从第二个单词开始，每个单词首字母大写

7.运算符：

• ①算数运算符：+, -, *, /, %, ++, –
• ②关系运算符：>, <, ==, <=, >=, !=
• ③逻辑运算符：&, |, &&, ||, !, ^
• ④赋值运算符：=, *=, /=, +=, -=, %=
• ⑤三元运算符：(条件表达式)?表达式1(true):表达式2(false);
• ⑥位运算符

8.基本数据类型（4类/8种）

• ①整数类型：byte(8位), short(16位), int(位32/默认), long(64位)
• ②浮点型：float(32位), double(64位/默认)
• ③布尔型：boolean(true/false)
• ④字符型：char(char c = ‘a’????

9.类型转换（自动类型转换/强制类型转换）

1.自动类型转换：
byte/short/char→int→long→float→double
备注：其中byte、short、char三者之间不能直接相互转换

2.强制类型转换（是自动类型转换的逆过程）：

• 布尔型不能进行类型转换
• 精度损失
• 内存溢出

10.循环结构

①while循环
while(条件表达式){
循环体；
}

②do_while循环
do{
循环体;
}while(条件表达式)；

③for循环
for(初始化;条件表达式;更新){
循环体
}

④嵌套循环

• 外层循环控制行数，内层循环控制每行的个数
• 内层循环是外层循环的循环体

⑤关键字break/continue

• break:跳出，结束
• continue:跳过，越过

11.数组

（1）数组的作用：用于批量保存一类数据，数组是引用数据类型之一。

（2）数组的注意：

• 无论是动态初始化还是静态初始化，必须为数组指明长度
• 数组为每个元素的位置提供了一个索引值(下标、下脚标)，索引值从0开始到数组的长度-1结束
• 获取数组长度的属性:length

（3）数组的初始化操作
①动态初始化：数组的初始化和赋值操作分开进行

int[] arr = new int[3];
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;

②静态初始化：数组的初始化和赋值同时进行

int[] arr1 = new int[]{1,2,3};

③简单数组

int[] arr2 = {1,2,3};

（4）获取数组中元素
①根据数组元素下脚标获取

int[] arr = {1,2,3};
int a = arr[1];
System.out.println(arr[0]);
System.out.println(a);

②使用普通循环遍历数组中元素

for(int i=0; i<arr.length; i++){
	System.out.println(arr[i]);
}

③使用增强for循环遍历数组中元素

for(被遍历数组中元素的数据类型  变量名 : 被遍历的数组名){
	System.out.println(变量名);
}

（5）数组常见算法：

• 求数组元素的最大值、最小值、平均值、总和
• 数组的复制和反转
• 数组元素的排序

（6）数组的复制
①System.arrayCopy方法用于数组的复制

public static void arrayCopy(Object src, int srcPos, Object dest, int destPos, int legth){
	//arrayCopy方法中5个参数详解：
	//①src→源数组
	//②srcPos→源数组中的起始位置(索引值)
	//③dest→目标数组
	//④destPos→目标数组中的起始位置(索引值)
	//⑤legth→要复制的数组中元素的数量
}

②Arrays.copyOf（数组的扩容）
※数组的长度在创建后是不可以改变的，所谓扩容是指创建一个更大的新数组，并将原有数组的内容复制到新数组中，通过Arrays.copyOf方法实现。

Arrays.copyOf(original, newLength);
	//original→源数组
	//newLength→新数组长度
	//注意：新长度大于原长度，用默认值补充；新长度小于原长度，进行截取

（7）二维数组
二维数组中的元素是一维数组，如果想要获取二维数组中的数据，首先遍历二维数组，遍历出来的分别是二维数组中的每个一维数组，其次再分别遍历每个一维数组，获取想要的数据。

※遍历二维数组方法：

• 普通for循环遍历二维数组
• 增强for循环遍历二维数组

12.方法(函数、过程)

（1）含义：

• ①方法用于封装一段特定的逻辑功能。
• ②方法可以在程序中反复调用。
• ③方法可以减少代码的重复，便于程序维护。
• ④Java中方法不能独立存在，所有方法必须定义在类中。
• ⑤是一个类中最基本的功能单元。

（2）定义方法的五个要素：

• 修饰符
• 返回值
• 方法名
• 参数列表
• 方法体

（3）方法声明方式

修饰符  返回值类型(void,无返回值)  方法名(参数类型  参数, ...){
	执行代码;
 	return 返回值;
}

public int getNum(int a){
	//返回类型为int的值
	return a;
}

public void noResult(){
	System.out.println("返回值为'void'类型，则无需‘return’关键字且无需返回任何值");
}

（4）方法的参数列表

• ①方法的参数列表中，可以含0到多个参数，是局部变量。
• ②调用方法时，参数的类型与数量需要完全匹配。
• ③方法的参数，是指在调用时传递给方法的，需要被方法处理的数据。
• ④方法可以有参数，也可以没有参数，有参可使方法处理更加灵活。
• ⑤在定义方法时，需要声明该方法所需要的参数变量。

（5）方法的注意：

• ①※方法中可以调用其他方法，不可以在方法声明方法。
• ②"返回值类型"与"返回值"的数据类型必须保持一致。
• ③调用方法时，传递实际参数的数据类型必须与形式参数的数据类型保持一致。
• ④若声明了返回值类型，说明方法运行后有结果，若调用者需要用到该结果，可以声明一个变量接收该结果，声明变量的数据类型需要和返回值结果数据类型保持一致。
• ⑤若方法运行后不需要任何结果给调用者时，"返回值类型"处声明为void。
• ⑥若方法没有返回值，return可以省略不写。

（6）声明方法需要明确两点

• 明确方法运行结束后是否需要返回结果给调用者，如果调用者需要运行后的结果，则要明确返回值类型，且方法中必须有‘return’关键字；否则返回值类型为‘void’，且无需使用‘return’关键字。
• 明确是否有未知的数据参与运算。

（7）方法的重载
①概念：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。
②注意：

• ※必须在同一个类中。
• 方法名称必须相同。
• 参数列表必须不同(参数类型、参数的数量、参数的顺序)。
• 与返回值无关。

13.位与字节

• ①计算机中任何的计算和存储都是以二进制方式实现的。
• ②位(bit)-是计算机中最小的存储单元。
• ③字节(byte)-计算机中基本的存储单元。
• ④1byte = 8bits。

14.进制：

• ①二进制：0,1，满2进1，以0b或0B开头。
• ②十进制：0~9，满10进1。
• ③八进制：0~7，满8进1，八进制数被冠以0来开头。
• ④十六进制：0 ~ 9和A ~ F,满16进1，十六进制数被冠以0x开头(A~F，字母大小写均可)。

二、面向对象(OOP：Object Oriented Programming)

1.面向对象与面向过程

二者都是一种思想，面向对象是相对于面向过程而言的。

• 面向过程：强调的是功能行为
• 面向对象：将功能封装进对象，强调了具备功能的对象

2.类和对象是面向对象的核心概念

• 类：对一类事物的描述，具有相同属性或功能，是抽象的
• 对象：是实际存在的该类事物的每个个体，因而也称为实例

3.面向对象三大特性：

• 封装
• 继承
• 多态

4.类是对现实世界事物的抽象定义

• 属性：对应类中的成员变量
• 行为：对应类中的成员方法

5.局部变量与成员变量

局部变量：声明在方法体中的变量
成员变量：声明在类以内，方法以外的变量
①成员变量：

• 定义在类以内，在整个类中都可以被访问
• 分为类成员变量和实例成员变量，实例成员变量存在于对象所在的堆内存中
• 由默认初始化值
• 权限修饰符可以根据需要，选择任意一个

②局部变量：

• 只定义在局部范围内，如方法内
• 存在于栈内存中
• 作用的范围结束，变量空间会自动释放
• 没有默认初始化值，每次必须显示初始化
• 声明时不指定权限修饰符

6.参数值传递：

• 基本数据类型：当基本数据类型作为参数传递给方法，方法运行后值不会发生改变。
• 引用数据类型：当引用数据类型作为参数传递给方法，方法运行后值会发生改变。

public class TestOOP1 {
	public static void main(String[] args) {	
		TestOOP1 test = new TestOOP1();
		/*int aa = 10;
		int bb = 20;
		test.add(aa, bb);
		System.out.println("main方法a="+aa+",b="+bb);*/
		
		Number num = new Number();
		num.a = 10;
		num.b = 20;
		System.out.println("main调用add前：a="+num.a+",b="+num.b);//10,20
		test.add(num);
		System.out.println("main调用add后：a="+num.a+",b="+num.b);
		
		Number num1 = new Number();
		num1.a = 100;
		num1.b = 200;
		System.out.println(num1.a+","+num1.b);
		
	}
	
	//基本数据类型值传递
	public void add(int a, int b){
		a += 1; 
		b += 2;
		System.out.println("add方法a="+a+",b="+b);
	}
	
	//变量的格式：数据类型  变量名
	//Number n = new Number();
	public void add(Number n){
		System.out.println("add执行前：a="+n.a+",b="+n.b);//10,20
		n.a += 1;
		n.b += 2;
		System.out.println("add执行后：a="+n.a+",b="+n.b);//11,22
	}
}

class Number{
	int a;
	int b;
}

7.面向对象特性之一：封装

封装的理解：把该隐藏的隐藏起来，该暴露的暴露出来

（1）访问权限修饰符：

• public:共有的，用于修饰属性、方法、类，可以在任何地方访问。
• private:私有的，可用于修饰属性、方法，只能在本类中访问

（2）封装的步骤：

• 属性私有化(private)
• 提供公共方法(public)的setXxx()和getXxx()

（3）封装的目的：
Java中通过将数据声明为私有的(private)，在提供公共的方法(public)，setXxx()和getXxx()实现对属性
的初始化操作：

• 隐藏一个类中不需要对外提供的实现细节。
• 使用者只能通过实现定制好的方法来访问数据，可以方便的加入控制逻辑，限制对属性的不合理操作。
• 便于修改，增强代码的可维护性。

8.构造器

（1）类的成员：

• 属性
• 方法
• 构造器

（2）构造器：也叫构造方法，是类的成员之一

（3）构造器的格式：

访问权限修饰符  类名(参数列表){
	执行语句;
}

（4）构造器的作用：

• 创建对象。
• 为对象进行初始化。

（5）构造器的注意：

• 构造器的名称必须与类名保持一致。
• 若一个类中没有显示提供任何构造器时，系统会默认提供一个无参构造器：public Animal(){}。
• 若一个类中提供了任何构造器时，系统默认无参构造器将不再提供。
• 构造器之间可以构成重载。
• 构造器只能调用一次，并且是在创建对象时调用。

（6）构造器的重载：

• 构造的名称相同。
• 参数列表不同(参数类型、参数个数)。

（7）构造器的特征：

• 它具有与类相同的名称。
• 它不声明返回值类型。
• 不能有return返回值。

（8）构造器分类：

• 隐式无参构造器(系统默认提供)。
• 显示定义一个或多个构造器(无参、有参)。

9.this关键字

• this关键字：使用在本类中，代表当前对象，可用于调用属性、方法、**构造器。
• this可用于区分成员变量和局部变量。
• 谁让拥有this关键字的方法运行，谁就是当前对象。
• this调用本类构造器，必须写在构造器中可执行代码首行。
• 要避免递归构造器调用，一个类中至少有一个构造器不使用this调用其他构造器。

10.面向对象特性之二：继承

（1）继承：使用关键字extends→"扩展"→子类是父类的扩展；
通过继承，子类可以继承父类中所有的属性和方法(构造器除外)

（2）为什么要有继承？

• 多个类存在形同属性和行为时，将这些内容提取到一个单独类中那么多个类无需在定义这些属性和方法，只要继承那个类即可，提高代码复用性。
• 便于维护。

（3）继承的注意：

• 不能为了简化代码、获取某个功能而继承，若要完成继承两个类之间要有一定的关系。
• Java中只支持单继承，不支持多继承(一个父类可以有多个子类，一个子类只能有一个父类)。
• Java支持多层继承。

（4）关于继承的规则：

• 父类中的成员，无论是共有还是私有的，均被子类继承。
• 子类不能对继承的私有成员直接进行访问，可以通过继承的公共方法来访问。

（5）属性的特点：

• 当子类继承父类后，若子类中出现了与父类同名的属性时，创建子类对象操作该属性时，实际上调用的是子类的属性值，若需要访问父类的属性时，使用super关键字。
• 当子类继承父类后，子类可以继承父类中所有的属性，包括私有的，但是因为private修饰符的作用，子类无法直接访问父类中属性值，若需要访问父类的私有属性，需要父类提供set/get方法。

（6）关键字：super

• 用法和this关键字一模一样。
• this:使用在本类中，代表当前对象。
• super:使用在子类中，代表父类对象。

（7）方法的特点：
①方法的重写(方法覆盖OverRide):

• 若父类的方法对于子类来说不适用的情况下，子类可以对父类的方法进行重写。
• 当子类继承父类后，子类中出现了和父类中方法签名一模一样时，创建子类对象调用该方法时，实际运行的是子类的方法，如同将父类中的方法覆盖了一样。

②方法重写的规则：

• 前提：要有继承关系。
• 方法名称和参数类表必须相同。
• 返回值类型可以不同，但是有一定规则(子类重写方法的返回值类型可以是父类被重写方法返回值类型的子类)通常在应用时，方法签名一模一样。
• 子类重写方法的访问权限修饰符不能小于父类被重写方法的访问权限修饰符。

11.面向对象的特性之三：多态

（1）多态的体现：

• 方法的重写和方法的重载。
• 对象的多态性：父类的引用指向子类的对象。

（2）多态的前提：

• 必须要有继承关系。
• 要有方法的重写(为了完成虚拟方法调用)。

（3）引用数据类型之间的转换：

• 前提：要有继承关系。
• 无继承关系的引用类型间的转换是非法的。
• 向上造型：子类转父类，系统自动完成。
• 向下造型：父类转子类，需要使用强转符，容易引发类型转换异常（ClassCastException）。

（4）多态数组：数组中可以存储父类本类类型的对象以及子类类型的对象。

（5）intstanceof运算符：判断引用指向的对象是不是本类类型的对象，若是，则返回true，否则返回false。

12.访问权限修饰符：

• private: Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的属性以及方法只能被该类的对象 访问，其子类不能访问，更不能允许跨包访问。
• protected: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护访问权限”。被其修饰的属性以及方法只能被类本 身的方法及子类访问，即使子类在不同的包中也可以访问。
• default：即不加任何访问修饰符，通常称为“默认访问权限“或者“包访问权限”。该模式下，只允许在同一个包中进行访问。
• public： Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且 允许跨包访问。
  

13.static关键字

（1）static修饰符：静态的，可用于修饰属性、方法、代码块、内部类

（2）类属性、类方法的设计思想：

• 类属性：是作为该类各个对象之间共享的变量。在设计类时，分析哪些类属性不因对象的不同而改变，将这些设置为类属性。
• 类方法：如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用。

（3）static修饰的属性(类变量或静态变量)

• 静态变量随着类的加载而加载，随着类的消失而消失(生命周期最长)。
• 静态变量被所有该类对象所共享。
• 一旦某一对象对该属性值进行改变，其他对象的该属性值也会随之改变。
• ※静态变量的存在优先于对象。
• 我们可以通过"类名.类变量"的方式访问。

（4）static修饰的方法(类方法或静态方法)

• 静态方法随着类的加载而加载，随着类的消失而消失。
• 静态方法的存在优先于对象。
• 可以通过"类名.类方法"的方式调用。
• 静态方法不能使用非静态成员。
• 静态方法不能使用this和super关键字。

（5）静态代码块和非静态代码块
1.非静态代码块

• 格式：类中的一对{}。
• 在每次创建对象时执行。
• 非静态代码块优先于构造器执行。
• 非静态代码块用于为对象进行初始化操作(通常用于为共性内容进行初始化)。
• 非静态代码块可以有多个，依次向下的顺序执行。

2.静态代码块

• 格式：static{}。
• 随着类的加载而加载，并且只加载一次。
• 静态代码块的执行优先于非静态代码块。
• 静态代码块不可以调用非静态成员。
• 静态代码块可以有多个，依次向下的顺序执行。

3.为属性赋初始值的方式
①默认赋值。
②直接显示赋值。
③构造器。
④非静态代码块。
顺序：① ②④ ③
注意：②和④顺序赋值

14.final关键字

（1）最终的，可用于修饰 变量 、方法、类。

• final修饰的类不能被继承。
• final修饰的方法不能被重写。
• final修饰的变量叫做常量，一旦被赋值，值不能改变。

（2）常量：

• 常量的命名规范：所有字母都大写，多单词组成时每个单词之间有"_"分隔。
• 常量没有默认值，在使用前必须赋初始值(直接显示赋值，构造器，代码块)若使用构造器为常量赋值，必须保证所有构造器都为该常量赋值。

15.抽象类（使用关键字：abstract）

（1）抽象类：

• 格式：abstract class 类名{}。
• 拥有一个或多个抽象方法的类 必须 是 抽象类。
• 抽象类中可以有抽象方法。
• 抽象类中也可以没有抽象方法。
• ※抽象类不可以创建实例。
• 抽象类中可以声明构造器，目的：当子类继承父类后，继承父类中所有属性和方法，因此子类需要知道父类是如何为对象初始化的。

（2）抽象方法：

• 格式：访问权限修饰符 abstract 返回值类型 方法名(参数列表);
  注意：抽象方法没有方法体，所以不需要后面那对{}。
• 子类继承父类后，若重写了父类中所有的抽象方法，该类为具体类。
• 子类继承父类后，若没有重写父类中所有的抽象方法，该类必须为抽象类。

（3）注意事项：

• abstract和static不能同时使用。
• abstract和final不能同时使用。
• abstract和private不能同时使用。

16.接口（使用关键字：interface）

（1）接口的特点：

• 接口与类是平级的，使用关键字：interface，例如：public interface Fly{}。
• 可以把接口理解为特殊的抽象类，因为接口中只能定义"全局静态常量"和"抽象方法"。
• 接口中不能有变量、构造器、代码块、一般方法。
• ※接口不能创建实例。
• 接口就是用来被实现的，使用关键字：implements，例如：class Bird implements Fly{}。
• 实现接口的类称为"实现类"，实现类的功能与继承一样，实现类可以"继承"接口中的所有成员。
• 实现类实现了接口中的所有抽象方法，该类为具体类，可以创建实例。
• 实现类若没有实现接口中所有的抽象方法，那么该类必须是抽象类，不可以创建实例。
• 接口支持多实现，解决了Java中单继承的局限性。
• 接口不能继承任何类，接口可以继承借口，并且可以多继承接口。
• 一个类可以继承另一个类，同时实现多个接口，注意：先继承，后实现。

17.集合

（1）特点：就是一种容器，用于存储、获取、操作对象的容器。

（2）集合与数组的区别：
①数组：

• 长度不可变的。
• 数组中没有提供可以查看有效元素个数的办法。

②集合：

• 集合的长度是可以改变的。
• 集合中可以存储任意类型的对象。
• 集合中只能存储对象。

（3）集合框架：

• java.util.Collection:集合层次的根接口
  |- - java.util.List：有序的，并且允许重复的，List体系的集合具有索引值。
  |- - java.util.Set：无序的，不允许重复的。

（4）集合常用方法：

• add(Object obj) : 添加元素到集合中。 参数为 Object，意味着可以添加任意类型的对象 。
• size() : 获取集合中元素的个数。
• clear() : 清空集合中所有的元素。
• isEmpty() : 判断集合是否为空。
• addAll(Collection coll) : 将 coll 中所有的元素，添加到当前集合中。
• contains(Object obj) : 判断集合中是否包含某元素。 判断元素是否存在的依据是使用 equals() 方法。
• containsAll(Collection coll) : 判断 coll 中的所有元素是否包含在当前集合中。
• remove(Object obj) : 移除集合中某元素。
• removeAll(Collection coll) : 移除 coll 中所有的元素。
• retainAll(Collection coll):取交集。
• toArray() : 可以将集合转换成数组。

18.IO流

（1）IO流特点：

• I/O是Input/Output的缩写，IO技术是非常实用的技术，如读写操作、网络通讯等。
• 流：是指从源节点到目标节点的过程。
• 源节点和目标节点可以是文件、网络、键盘、显示器…
• 源节点的数据流称为输入流(用来读取数据)。
• 目标节点的数据流称为输出流(用来写入数据)。
• 文件 – 输入流 → 程序 – 输出流 → 文件。

（2）IO流的分类：

• ①按流向不同：输入流、输出流(以程序为主体)。
• ②按数据不同：字节流、字符流
• -字节流：字节流用于操作非文本文件，.jpg/.png/.mp4/.avi，(以byte为传输单位，8bit)。
• -字符流：字符流用于操作文本文件， .java/.txt，(以char为传输单位，16bit)。
• ③按角色不同：节点流、处理流。

（3）IO流的结构体系：

（4）对象流：ObjectInputStream和ObjectOutputStream

• ①作用：用于存储和读取基本数据类型数据或对象的处理流，它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
• ②对象的序列化：对象的序列化机制，允许吧内存中的Java对象转换成与平台无关的二进制流，从而允许吧这种二进制流持久的保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其他程序获取了这种二进制流，就可以恢复成原来的对象。
• ③序列化：用ObjectOutputStream类保存基本数据类型或对象的机制。
• ④反序列化：用ObjectInputStream类读取基本数据类型或对象的机制。
• ⑤对象序列化步骤：
  • a.创建节点流；
  • b.创建缓冲流，并包装对应的节点流(可选，用于提高传输效率)；
  • c.创建对象流，同时包装缓冲流；
  • d.完成对象的序列化操作；
  • e.关闭流；
  • f.需要序列化对象的类必须实现java.lang.io.Serializable接口；
  • g.提供一个*** private static final long serialVersionUID = 123L;

19.多线程

（1）含义区分：

• 程序：是为完成特定任务、用某种语言编写的一组指令的集合。即值一段静态的代码，静态对象。
• 进程：是程序的一次执行过程，或是正在运行的一个程序。
• 线程：进程可进一步划分为线程，是一个程序内部的一条执行路径。

（2）什么时候需要多线程？

• ①程序需要同时执行两个或多个任务。
• ②程序需要实现一些需要等待的任务时。
• ③需要一些后台运行的程序。

（3）使用多线程的优点：

• ①提高应用程序的相应，对图形化界面更有意义，可增强用户体验。
• ②提高计算机CPU的利用率。
• ③改善程序结构。将既长又复杂的进程分为多个线程独立运行，便于理解和修改。

（4）多线程的创建和使用：通过java.lang.Thread类来实现。
※Thread类的特性：

• 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，通常把run()方法的主体称为线程体。
• 通过该Thread对象的start()方法来调用该线程。
• ※抢占式策略系统：系统会为每个执行任务的线程分配一个很小的时间片段，当该时间片段用完之后，系统会剥夺其使用CPU的权限，交给其他线程执行任务。

（5）创建执行线程的方式之一：

• ①创建一个类继承Thread类。
• ②重写Thread类中的run()方法,同时编写线程体。
• ③创建该子类的实例。
• ④通过start()方法启动线程,默认执行run()方法。

（6）创建执行线程的方式之二：

• ①声明一个类实现Runnable接口。
• ②实现接口中的run()方法，同时编写线程执行体。
• ③创建该实现类的实例。
• ④创建Thread类的实例，将实现类的实例作为参数传递给Thread的构造器。
• ⑤调用Thread的start()方法，启动线程。

（7）线程的控制：

• ①sleep(long millis):是一个静态方法，使当前线程进入睡眠状态。
• ②join()/join(long millis):当某个线程执行中调用其他线程的join()方法时，调用线程将被阻塞，直到join()方法加入的线程执行完为止。
• ③interrupt():中断线程的阻塞状态。
• ④isAlive():判断当前线程是否处于存活状态。
• ⑤yield():暂停当前正在执行的线程，把执行机会让给优先级相同或者更高的线程若队列中没有同优先级的多线程，忽略此方法。

（8）线程的生命周期：

• ①新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态；
• ②就绪：处于新建状态的线程被start()之后，将进入线程队列等待CPU时间片段，此时它已经具备了运行的条件；
• ③运行：当就绪的线程被调度并获得处理器资源时，便进人运行状态，run()定义了线程的操作和功能；
• ④阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU资源并临时终止自己的执行，进入阻塞状态；
• ⑤死亡：线程完成了它的全部工作或线程被提前强制性的终止。