Java开发基础初级复习/专升本复习（自用）

JAVA历史&&基础
Java已由单纯的语言成长为通用的平台技术标准了

java平台：
Sun公司发布的3个java平台技术标准：javaSE、javaEE、javaME
javaSE：平台标准版。包含了运行java应用所需要的基础环境和核心类库
javaEE：java平台企业版。
javaME：微型版。/嵌入式。

java语言特点：简单、安全、面向对象、多线程、跨平台
java三大基本特征（特性）：封装、继承、多态
java面向对象的四个基本特征：抽象、封装、继承、多态

面向对象：
目的：
封装：提高代码的安全性。
继承：提高代码的复用性。
多态：提高代码的扩展性。

跨平台：
java的字节码跨平台。不是JVM跨平台

安全：
java不支持指针。

多线程：
使程序更便携简单

JDK、JRE、JVM：
JDK：java开发工具包
JRE：java运行环境
JVM：虚拟机

JDK包含JRE，JRE包含JVM

关于编辑编译：
编辑：在特定的编辑器里面进行代码的编写 编写好后生成的是.java源文件

编译：通过javac对源文件进行编译。执行时候的语句是javac .java 在编译的时候也进行了语法的监测和检查。编译段的实质就是检查一下有没有出现语法错误。检查无误后编译后生成.class文件。.class文件是字节码文件。

注意：是语法 不是语义
例题如下：

执行：通过java Test对其进行执行。执行的时候是JDK中的一个工具来对字节码文件进行执行。具体怎么执行或是解析，由JVM负责。

JVM对文件进行解释，将文件解释成一系列的二进制码，并将这些码提交给操作系统（OS），操作系统进行二进制码的执行。

注意：JDK执行的时候是字节码文件。底层执行的是二进制码，要是有题目说执行二进制码文件，是错误的。

关于java javac javap：
javac用来编译.java文件
java用来执行.class文件
javap用于帮助开发者深入了解 Java 编译器的机制

语法基础
Main方法：
一个应用程序必须要有一个主方法，也只能有一个主方法
任何java程序都必须以类的形式出现
注意：
main方法有自己固定格式：public static void main（String[] args){}
而且程序中是可以有别的成员方法名字叫做main，只要方法的其他成分不和主方法一样就行。如果写了其他名字同为main的方法，就相当于重载了

注释：
单行注释：//
多行注释：/* * /
文档注释：/** */
单行注释可以被嵌套在其他两个注释里，但其他两个注释不能互相嵌套，也不能嵌套自己

变量的定义以及规则：
变量需要声明和赋值之后才能使用。变量有自己的作用域

变量名字可以用中文但最好不要用中文
常量名字可以不大写 但最好大写
一条语句中可以声明多个同类型的变量

成员变量就是实例变量：若没有初始化，系统会帮着初始化，所以不是一定要初始化的。
成员变量包括：实例成员变量+类成员变量

静态变量：又称为类变量。当静态变量所在的类被调用时，类变量会随着类的加载而一起加载

变量的类型决定变量所占的内存空间以及能参与的运算，修饰符决定变量拥有的权限

java中的命名规则：

包名
包名应该小写。
如果有多个单词，单词之间用.隔开，每隔开一次就相当于向下继续创建了一个“文件夹”。
前缀最好用com，edu，gov，mil，net，org等顶级域名之一

类和接口的命名：
类和接口名称最好是名词。
可以是大小写混合的，但每个内部单词的首字母应该大写。
最好避免缩写。

方法的命名：
首字母小写，随后的每个单词首字母大写
最好用动词

变量名命名：
以小写字母开头，随后的单词首字母大写。
数字不能开头
只有_$这两个特殊符号可以用

常量词命名：
最好大写，有多个单词也最好用_分隔开

注意：最好不代表一定，只是一个习惯

数据类型

基本数据类型有8种：byte（1）、short（2）、int（4）、long（8）、float（4）、double（8）、char（2）、boolean（1）。如果分类的话分成字节型、整形、浮点型、布尔型。

引用数据类型有3种：数组、接口、类
A a=new A（）； a虽说是A的对象，但其实是个引用类型的引用变量

整形 int：
通常用十进制表示，也有十六进制八进制表示的时候。数值范围-2³¹~2³¹-1.正数超范围会溢出成负数。负数超范围会溢出成正数。

int类型的数据转变成字符串类型：Integer.parseInt（string）
String类型的字符串转变成int：String.valueOf（i）

		int a=1;
		int b=2;
		String string="abc";
		
		System.out.println(a+b+string);//3abc
		System.out.println(a+b+"3");//33
		
		System.out.println(1+2+string);//3abc
		System.out.println(string+1+2);//abc12
		System.out.println(string+(1+2));//abc3

长整型long：
数值范围-2⁶³~2⁶³-1。定义变量的时候需要在后面加上L或l 。

浮点数 flout&double：
一般默认的浮点类型是double。float类型的数据定义的时候需要在后面加上F或f。

字符型char：
字符类型本质上是一个16位无符号整数。Unicode是通用的定长字符集。所有字符都是16位。一个char类型变量只能存一个字符。
注意：char ch=‘人’ 是可以的 中文占2个字节 ch变量占2个字节

布尔类型boolean：
一般用于程序的流程控制

数据转换
类型转换分为自动类型转换（隐式）和强制类型转换

自动类型转换：小类型转大类型 精度变大
强制类型转换：大类型转小类型 精度变小

自动转换的要求：
二者的类型要互相兼容。目标类型要大于源类型，也就是只能往大了转。double可以转成int。

数值在运算的时候会发生自动类型转换。
byte、char、short参与运算的时候先转成int在进行运算。

强制类型会使数据失去精确度

高→低：强制类型
double b=2.3;
int a=(int)b;
其中a会变成2 但b还是2.3
低→高：自动转换 （类型提升也属于自动转换）：自动转换的阶梯 字节—整数—浮点

算数运算符

运算符的优先级：
单目>强制类型>算数>位运算>关系>逻辑>三目>赋值
单目：
+（正） -（负）！（非）~（取反） ++（自增） - -（自减）

算数：
*、%、 /、 +、 -

/：只有在两边都是整数的时候才舍去小数
%：结果的正负和被除数的正负一致

位运算：
<< （左移 ）>>（有符号右移 ）>>>（无符号右移）
左移一位相当原数×2 右移一位相当原数÷2

逻辑：
&（短路与）、^、|（短路或）、&&、||
&：当左边是false ，结果就直接false ，不会对右边进行运算
|：当左边是true，结果就直接true，不会对右边进行运算
&&：当左边是false ，还需要继续对右边进行运算
||：当左边是true，还需要继续对右边进行运算
^：比较两边的数一不一样。一样就false，不一样就true。

在算术运算中的^是对两边的数的二进制码进行对比，然后把对比后的结果再转成数字

注意
在算数运算中也会有 & | ^ ，当符号左右连接的是布尔类型的运算符，就是逻辑运算符。当左右连接的是具体的数字，就是位运算符

三目运算符：相当于if/else结构。

程序的结构：

选择结构+循环结构

选择：if、if else、if else if | | switch
if的（）里加的是布尔表达式：逻辑式和关系式
逻辑式是由逻辑符号构成的，关系式是由关系符号构成的

switch的（）里加的是整形表达式
关于switch：
switch后面的数据类型只能是byte、char、int、short、String
要用字符串的话只能是String，不能是StringBuffer或StringBuilder
break的作用是防止代码的“穿透”，也就是“连襟”
Default相当于try catch 中的finally，用来“兜底”。
Switch能解决的if都能解决，但if能解决的switch不一定，因为switch的（）中只能加等值。等值即非条件表达式

case在用的时候 如果是字符串 就“”：双引号 如果是字符 就’’单引号

循环：
循环的要素：循环条件和循环体
种类：for | | while | | do while

当循环数量固定的时候，常用for循环
for循环的四个组成部分：参数初始化，条件判断，循环操作，更新循环变量

while 和 do while都能用for来代替。do while无论如何都会执行一次。
do{}while(); 结构中，后面有一个；
while和do while都是满足条件时进行循环。

break和continue和return：
break跳到当前循环块外面一层的下一句。终止循环。

continue：中止本次循环，接着开启下一次循环
continue只能用在循环结构中.

return：
结束当前的方法

在for循环中，continue使程序跳到迭代部分，然后判断循环条件。
while循环中，continue执行完后程序将直接判断循环条件

一维数组
数组应用于批量数据存在的情况。数组是由相同数据类型的数组元素组成的集合。数组元素的类型是唯一的，一个数组里面只能存储一种数据类型的数据
数组的声明：(以int型为例)
int []a;

数组声明了不代表能用。要有了内存空间，即new了之后才能用。
数组名表示的是首元素的地址.

Arr1代表的是arr1数组的首元素的地址，Arr2代表的是arr2数组的首元素的地址。所以==比较的是元素的地址的值

静态初始化（一般用于数组内数据确定的情况）
a=new int[]{1，2，3，4};
或直接
int []a={1，2，3，4}；

动态初始化（一般用于数组内数据不完全确定的情况）
只指定数组的长度，由系统为每个数组元素指定初始值或者人为的为特定的数组元素赋值。
int[] a=new int[8]; //这里a数组里的每一个元素的值就都是0了

int[] a=new int[8];
a[0]=1;a[1]=2;a[2]=3;//这里a数组除了下标为012的元素，其他的元素初值都是0

而int[] a=new int[8]{1，2，3，4，5，6，7，8}就不对了 不能初始化的时候又静态赋初值又指定长度

数组的操作：
数组的复制+增删改查

数组复制：
类型[] newArray=Arrays.copyof{类型[] original,int newLength};

copyOf（）方法，该方法有两个参数：第一个参数是源数组，第二个是副本数组的长度，如果长度大于源数组长度，就截取。如果小于，就用0或null进行填充

数组的扩容也是通过自身对自身的复制实现的

数组的遍历
遍历：可以用for循环、增强for循环、逆向遍历的方式对数组进行遍历

数组的排序：
冒泡：

public static void MaoPao(int arr[]) {
    
    
	for(int i=1;i<arr.length;i++) {
    
    
		for(int j=0;j<arr.length-i;j++) {
    
    
			
			if(arr[j]>arr[j+1]) {
    
    
				int t=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=t;
			}
		}
	}
	
	for(int i=0;i<arr.length;i++) {
    
    
		System.out.print(arr[i]+"\t");
	}
}

选择：

public static void ZhiJie(int arr[]) {
    
    
		for(int i=0;i<arr.length-1;i++) {
    
    
			for(int j=i+1;j<arr.length;j++) {
    
    
				if(arr[i]>arr[j]) {
    
    
					int t=arr[i];
					arr[i]=arr[j];
					arr[j]=t;
				}
			}
		}
		
		for(int i=0;i<arr.length;i++) {
    
    
			System.out.print(arr[i]+"\t");
		}
	}

数组的增删改查
增：（根据下标来增）

public static void insert(int arr[],int index,int x) {
    
    
	int pos=index;
	
	MaoPao(arr);
	
	for(int i=arr.length-2;i>=pos;i--) {
    
    //注意这里是2  <length即<=length-1
		arr[i+1]=arr[i];
	}
	arr[pos]=x;
	
	for(int i=0;i<arr.length;i++) {
    
    
		System.out.print(arr[i]+"\t");
	}
}

删：（根据下标来删）

public static void delete(int arr[],int index) {
    
    
	int pos=index;
	
	MaoPao(arr);
	
	for(int i=pos;i<arr.length-1;i++) {
    
    
		arr[i]=arr[i+1];
	}
	arr[arr.length-1]=0;
	
	for(int i=0;i<arr.length;i++) {
    
    
		System.out.print(arr[i]+"\t");
	}
	
}

改：（根据下标来改）

public static void selectOne(int arr[],int index) {
    
    
	int num=0;
	for(int i=0;i<arr.length;i++) {
    
    
		if(i==index) {
    
    
			num=arr[i];
		}
	}
	System.out.println("对应下标"+index+"找到的值是："+num);
}

查：（根据下标查值&根据值查下标）

public static void selectTwo(int arr[],int num) {
    
    
	int pos=0;
	for(int i=0;i<arr.length;i++) {
    
    
		if(arr[i]==num) {
    
    
			pos=i;
		}
	}
	System.out.println("数值"+num+"对应的下标是："+pos);
}

再正规一点可以加入判断下标是否越界

public static void check(int arr[],int index) {
    
    
	
	if(index<0 && index>=arr.length) {
    
    
		
		System.out.println("下标越界");
		
	}
}

二维数组：
二维数组本质上也是一维数组。数组中存放数组就变成了二维数组。

二维数组的定义：
声明数组，分配空间
int[][] arr=new int[3][5];

声明数组，先分配行，再分配列
int[][] arr=new int[3][];
arr[0]=new int[3];
arr[1]=new int[4];
arr[2]=new int[5];

声明数组，分配空间，赋初值
int[][] arr={ {123},{4567},{8888}}

数组只声明不赋值，相当于这个数组不存在。即使将数组内的每个值都赋值为null，这个数组也是存在的。

再重申一下：int 是基本数据类型。int[] 是引用类型

结构化程序设计

方法：
方法定义的五个要素：修饰符、返回值类型、方法名、参数列表、方法体
public void Method_1（int num）{}
修饰符不是方法中必须的。不写系统会默认成default。
返回值类型必须声明。如果不返回任何结果就声明成void

方法的调用：
系统会在栈空间中为方法分配临时存储空间，并为方法里面的形参和局部变量分配空间

关于栈堆的内存机制：
方法定义后，计算机会在内存的栈里开辟一块区域专门给这个方法，这个方法里的形参，局部变量，都放在这块区域内。如果是基本数据类型，就是直接的值传递

如果是引用数据类型，比如数组，就会先在堆内开辟一个空间，用来存放这个数组的全部，每个元素的地址和数值。然后会把数组的首元素的地址放到栈里面【毕竟也是方法中定义出来的一个变量，局部变量是要存在栈内的，所以就会给首地址开辟个空间】

如果引用类型的数据做了形参，比如在main方法里是个实际的局部变量，但在getMaxNum方法里面被当成形参用了，就要将该数据的地址的副本传过去，也就是上图的那个

整个程序结束后，调用的方法结束后，在栈内的当时开辟的属于某个方法的空间就要从栈内出去，方法里面的变量的值参数的值都出去。而堆中存放的东西将会被java内的垃圾收集机制清理掉

方法

构造方法：
作用：初始化对象。构造方法被调用的时候就是给对象中的成员变量赋初始值的过程。即使没有人为的设定初始值系统也会赋予默认的初值。
构造方法的名字必须和类名一致 。方法的头部没有返回值的类型修饰。因为该方法的作用就是赋值&初始化，不需要什么返回值。（）内的形参列表视情况而定。

构造方法的第一句就是super，如果没有的话就是隐藏起来了。而且super必须放在第一位

在同一个类里面，方法之间的调用用this关键字，构造方法可以调用构造方法

成员方法：
和main方法平级。权限修饰符+返回值类型+方法名字+形参列表+方法体
public int method_1(){}。

定义各种方法的目的：提高代码的复用性

方法的重载：方法名相同,只需要形参列表里面的东西不一样就行。

重载的作用：让类以统一的方式处理不同类型的数据的一种手段

例如：
原方法：public int method_1(){}
重载的各种形式：
①public int method_1(int a){}
②public int method_1(int a,int b){}
③public int method_1(int a,double b){}
④public int method_1(double b,int a){}
⑤public int method_1(String str,char ch,float f.....){}
等等诸如此类的 都算做重载

不一样是指：参数的个数不同，参数个数相同了那就参数类型不同比如②和③，参数类型相同了那就在（）里面的位置需要不同 比如③和④。

此外：
当重载的方法里面的参数可以进行类型转换的时候，像上图那种。在调用的时候先走参数类型为int 的，没有int的再走long ，没有long再走float ，最后的选择是double

方法的重写：
方法的重写是指将方法体的内容进行改变。一般多用于子类重写父类的构造方法。子类要进行重写的话，访问的权限需要大于父类方法的权限。
例如：
原方法：

public int method_1(int a){
    
    
	System.out.println("Hello world");
}

重写后：

public int method_1(int a){
    
    
	a=8;  
	System.out.println("a is "+a);
}

方法的调用：
通过子类的构造方法去调用父类里面的方法或者权限大的成员变量时，用super。
构造方法之间的相互调用this同一个类里面的方法之间相互调用，用this

访问修饰符：
访问修饰符是修饰java中类、属性、方法的访问可见范围的

要是提到缺省，那就是default。默认的什么都不写，也是相当于被default修饰。

关键字
关键字和权限字不冲突，一般都紧跟在权限的后面

final
final可以修饰类，修饰类的话该类不能被继承
final可以修饰方法，修饰方法的话该方法不能被重写
final可以修饰变量，修饰变量的话变量值不能被修改

static
static可以修饰变量：修饰的变量叫做静态变量。在一个类里面，静态的成员变量可以被任意一个位置调用

static可以修饰方法：修饰的方法叫做静态方法。静态方法里面可以定义自己的局部变量，静态非静态都可以。但如果要调用外部成员变量，该成员变量必须是静态的。

注意：static修饰的方法不能被重写。当子类去继承父类的某个static方法的时候，就算子类重写了调用的也是父类的static方法。

静态方法和static修饰的代码块会在类被调用的时候就会随着类的加载一起执行。而且不管这个类被调用多少次，他们只加载一次。

static不可以修饰主类，只可以修饰内部类,但一般不用它修饰

abstract：抽象
abstract修饰方法就变成了抽象方法。
抽象方法除了能存在于抽象类里面还可以存在于接口中。
抽象方法没有方法体：

public abstract void Method_1();

abstract修饰的类叫做抽象类。
抽象类有自己的构造方法。系统会自己生成。
抽象类中可以有抽象方法也可以没有。抽象类中可以有普通类有的一切。
抽象类不能被实例化。抽象类必须要有子类继承并重写自己本身的所有的抽象方法。
抽象类不能被final修饰。被final修饰的类不能有子类继承，但抽象类需要被继承。

interface：接口：
接口是相当于一种特殊的抽象类。
接口只能被实例化，不能被继承。
接口中的方法只能是抽象方法，但方法不用abstract修饰。
接口中的变量只能是常量，固定格式也只能是public static final xxx;而且一定要赋值。
接口实现类要实现接口中的所有方法。
一个普通的类可以实现多种接口，而且接口本身可以继承接口。

接口不能new它的实例类 是能new它实现类的实例类。接口在实现的时候可以强制类型转换。
如，A是接口，B是实现类。
A a=new B（）；//a是接口的类型，但形态是实现类的形态
B b=(B) a; //将a强制类型转换后的类型赋予b

抽象和接口的区别：
①：抽象类只能被继承。接口只能被实例化。
②：抽象类里面可以有普通的成员变量。接口里不能。
③：抽象类中方法的修饰符可以是public protected 。接口中的修饰符可以是public和默认缺省
④：一个类可以有多个接口，但只能有一个抽象类
⑤：抽象类中可以有构造方法。接口中没有构造方法。

java三大特性：
接口：
上面已描述的差不多了。
封装：
将数据和对数据操作的方法都放在一个类里面。

多态：
多态是一种特性。通俗点，就是一个东西可以定义成多种形态，那么这个东西就具有多态性。
一个接口可以有好多实现类----接口有多态性。
父类可以有很多的子类----继承也有多态性。

多态分为
编译时多态、运行时多态

编译多态：在代码被执行的时候，能明确的知道接下来执行的是哪个或哪块具体的代码
如，方法的重载，就是编译时多态。重载的方法每一个的参数列表都不相同。所以根据特定的参数就可以知道执行的是哪个方法。

运行时多态： 代码在执行的时候不知道接下来执行的是哪个或哪块具体的代码。
比如

Father f=new Son();
f.toString();

这里可能无法百分百的确定f调用的是子类的还是父类的toString方法。只有被编译后出了结果才知道。这就是运行时多态了

垃圾回收机制：
GC是垃圾回收机制。程序产生的代码由系统自动回收，程序员不能调用
比如，原本是S s=new S(), 然后通过s再调用方法 但是在调用方法的时候直接通过new S().xxx方法，这样就只是在堆内开辟了一个地址空间，并没有引用类型的数据引用它，也就是在栈里没有开辟一个变量的空间，没有一个明确的源头指向这个堆中对应的地址，下次再用的时候就找不到了。这就相当于一个垃圾数据。当它不再被调用的时候，这个地址所代表的东西就会被系统自动回收。

内部类：
成员内部类。静态内部类。局部内部类。匿名内部类。
内部类：一个类写在了另一个类的内部

public class NeiBuLei_2 {
    
    
	static int a=1;
	int b=2;
	public class Inner{
    
    
		public void InnerMethod1() {
    
    
			System.out.println(a);
			System.out.println(b);
		}
	}
}

静态内部类：内部类用static修饰。
静态内部类不能访问外部类的非静态成员，只能访问外部类的静态成员。

public class NeiBuLei_2 {
    
    
	static int a=1;
	int b=2;
	
	static class Inner{
    
    
		public void InnerMethod() {
    
    
//			System.out.println(b);//这里没办法访问b
			System.out.println(a);//可以访问a 因为a是静态的
		}
	}
}

局部内部类：写在方法里面,或者代码块里面的类。
如果要访问外部方法里的变量，只能是访问被final修饰的变量。
如果要访问外部类里的变量，随意访问。

public class NeiBuLei_2 {
    
    

	static int a=1;
	int b=2;
	public void Method_1() {
    
    
		final int c=3;
		class Inner {
    
    
			public void InnerMethod() {
    
    
				System.out.println(c);
				System.out.println(b);
			}
		}
	}
}

匿名内部类：
没有类名，没有构造方法。直接new出来。相当于安卓中的监听。

public class NeiBuLei_2 {
    
    

	static int a=1;
	int b=2;
	public void Method_1() {
    
    
		new Inner（） {
    
    
				System.out.println(a);
			}
		}
	}
}

包

除了数据库用的sql包，集合和日期用的util包，以及net包。剩下的大部分常用的类都是属于lang包，比如接口、String、Math、Object、线程、异常等等。

先看lang包下的东西：
String类
String类是由final修饰的。不可被继承。
但是内部的方法是可以重写的，比如经常说的重写toString方法。
一般用String类来定义字符串的类型.。而字符串的底层其实是由char类型的数组组成的。

	String str_a="efgh";
	String str_b="efgh";
	String str_1=new String("abcd");
	String str_2=new String("abcd");

String类型的对象new一个就在堆中开辟一个空间，不管值相不相同，她们的地址是不同的。
String类型的字符串的值会放在常量池里面，如果多个字符串引用同一个值，那就共享同一个存在于常量池中的那个字符串值的地址

		String str_a="efgh";
		String str_b="efgh";
		str_a=str_a+"123";
		System.out.println(str_a);//efgh123
		System.out.println(str_b);//efgh

即使str_a=str_a+“123”，也不改变str_a原本引用的“efgh”本身，只是创建了一个新的地址用来存“efgh123”而已

String中常用的API：
charAt()：获得字符串中某个字符。
length():获得字符串的长度
trim():去掉字符串两端的空白
toLoweCase():将字符转换成小写
toUpperCase():将字符串转换为大写
indexOf():查找某个子串在字符串中第一次出现的位置
lastIndexOf():查找某个字串在字符串最后一次出现的位置
endsWith():判断是否以指定的字符串结束
startsWith():判断是否以指定的字符串开始
subString（开始的下标，结束的下标）：截取字符串中的某一段，截取的时候包括开始下标的字符，但不包括结束下标的字符
subString(开始的下标)：一直从开始的下标截取到最后，包括开始的下标
toCharArray（）：将字符串变成字符数组

注意
String类定义的字符串是不能在自己本身的字符串上进行修改操作的。如果要改变一个String类型变量的值，会创建出新的对象，然后让该变量指向新的对象。
用方法对字符串进行修改，修改后的结果也是一个副本。比如 subString方法截取的字符串，本身是没有被截掉的，生成的结果是截掉后的字符串的副本。

StringBuffer类和StringBuilder类的对象是可以改变自身值的
StringBuffer是线程安全的，效率比较低。StringBulider是线程不安全的，效率比较高。
两者常用的方法：
append();在字符串的末尾追加子串
insert();在字符串的某个位置插入字串
delete();删除字符串中的某段
toString();转换成字符串文本

Object类：
object类是所有类的子类。
常用方法：
toString（）
equals（）用来比较两个对象是否相等。比较对象有两种方法：引用相等&对象相等。比较引用相等用"==“，即比较对象引用的地址是否相等。比较对象的内容是否相等用"xxx.equals();”。
hashCode()
将当前在堆里面的对象的地址转换成一个整数。但这个整数比较特殊，不是内存地址。
instanceof（）
判断一个引用类型的变量所指向的对象的类型是不是某个类型

Math类：
Math类也是final修饰的。不能继承。
一般用到的方法：Math.random()。范围是[0.0,1.0)

如：
求[1,10]之间的随机数:Math.random()*10+1

包装类

异常类：异常的处理
异常也是一种对象。
一个程序出现错误的时候，他可能的情况有三种：语法错误，运行时错误，逻辑错误。
java的异常机制主要依赖于try，catch，finally，throw，throws这五个关键字。
java异常处理的三个关键字：try-catch-finally
java异常结构中定义有Throwable类，Exception和Error都是它的子类。
异常分为执行异常（Runtime Exception）和检查异常（Checked Exception）两种。Error常表示java运行时环境出现的错误

非检查异常
即执行异常，即运行时异常，java编辑器允许程序不对他们做出处理。也就是不用try-catch。
如：
NullPointerException：空指针
ArrayIndexOutOfBoundsException：下标越界
ClassCastException：类型强转错误
NumberFormatException：字符串转数值异常
IndexOutOfBoundsException：索引超范围

检查异常
非运行时异常。必须要用try-catch捕捉

异常的处理主要包括捕获异常、程序流程的跳转和异常处理语句。
一个异常对象需要经历抛出、捕获、处理三个过程。

异常处理的目的并不是为了避免发生异常，而是在异常发生的时候避免程序和异常的终止，设法将损失降低到最小。

try-catch-finally：异常的积极处理：
try块中多方throw语句和可能抛出异常的方法的调用。异常的捕获里可以没有catch和finally。但要有try。catch在被省略之后，如果产生了异常，会调用程序内部的缺省的处理异常的机制将异常捕获并处理

每个try语句块都可以伴随多个catch语句块。每个catch语句块的排列顺序应该是从异常小的类型到异常大的类型，即子类到父类的顺序。java语言规定，每个catch语句块都应该与一个try语句块相对应。

不管try-catch执不执行，finally一定执行。
Finally块可以防止资源的泄露
在try中 即使出现了return 也会执行finally，除非是system.exit。直接退出虚拟机。

throws抛出异常：异常的消极处理，放在方法头处，可以抛出多个异常，多个异常之间用，隔开
throw抛出异常放在try中，每抛出一个就要写一个。
自定义的异常要用throw抛。系统自定义的异常也可以用throw抛。

自定义异常
自定义的异常类也要继承Throwable。

Exception常用的API：
printStackTrace（）输出执行的堆栈信息
getMessage（）得到有关异常的信息
getCause（）检索导致异常的原因

util包下的常见类
Date类

Date d=new Date();
System.out.println(d);//获得系统的当前时间
System.out.println(d.getTime());//获得1970年距今的毫秒数

Calendar类
Calendar类是个抽象类，是系统时间的抽象表示

DateFormat类
DateFormat抽象类大部情况下是对日期进行格式的转化处理
一般用的是SimpleDateFormat实现类来处理问题

String d="2021-1-2";
SimpleDateFormat fmt=new SimpleDateFormat("yyyy-MM-dd");
Date date=fmt.parse(d);//将字符串型日期转成日期型
System.out.println(date);
System.out.println(fmt.format(date));//将日期型日期转成字符串类型日期

集合类：
集合又称作容器。也算是一个对象。集合被用于获取、存储、操纵和传输聚合的数据。
数组可以存储一些特定类型的数据。集合可以存储对象。
JDK提供的两个特定容器——集合（Collection）和Map。

Collection：
是一个接口。子接口有List和set
Collection中的方法有：
add（）；contains（）；size（）；clear（）；isEmpty（）；
addAll（）；containsAll（）；
set：不能包含重复元素，不保证元素的顺序
实现类有：HashSet、TreeSet、LinkedHashSet
HashSet：性能最好，但不保证迭代时候的顺序
TreeSet：将元素值按顺序排列，但速度差
LinkedHashSet：链表的形式存储

List：有序的Collection，允许有重复的元素
实现类：ArrayList、LinkedList、Vector
ArrayList在添加元素和删除元素的时候效率比LinkedList低。但查找元素的时候效率高。（看名字可以将LinkedList和链表联系起来）
ArrayList实现了可变大小的数组。允许所有的元素添加进来，包括null。
LinkedList可以根据索引来随机访问集合元素

Map：
Map用于保存具有映射关系的数据。key和value都可以是任何引用类型的数据。Map的key不允许重复。如果把Map中的key都放在一起，他们就组成了一个set集合，所有的key都没有顺序，key和key之间不能重复。
Map还提供了一个Entry内部类来封装key-value
Hashtable继承Map接口。不允许出现null作为key或者value。
HashMap和Hashtable类似。HashMap非同步，允许null。但HashMap中的key不能重复，所以HashMap里最多只有一个key-value对的key为null。
Hashtable线程安全，HashMap线程不安全