JAVA期末复习攻略2022学年酸奶公园出品

小灰灰 2024-04-01 19:45 106阅读 0赞

## **Java期末复习攻略** ##

Java期末复习攻略

第一章 Java概述

Java运行原理

1.编写

2.编译

3.运行

JDK简介

Java程序的分类

Application

Applet

Serverlets

1. Java区分大小写

第二章 基本符号

变量

实例

Java 局部变量

实例 1

实例 2

实例变量

实例

类变量（静态变量）

实例：

标识符

标识符组成

命名约定

Java的基本符号

1.注释（单行注释，多行注释，文档注释）

(1)什么是注释？请写出单行注释，多行注释，以及文档注释

2.标识符规则\_驼峰规则

(2)标识符的作用是什么，标识符的声明需要遵循哪些规则，哪些规范，标识符可以使用汉字么？

(3)将课上的代码敲两遍，体验一下标识符的声明规则和规范

1.Java的关键字保留字

(1)将文档中的关键字都手写一遍，混个脸熟

2.变量的本质\_声明格式和初始化问题

(1)变量的本质是什么？

(2)变量的要素是哪三点？

3.变量分类（局部变量，成员变量，静态变量）

(1)什么是局部变量？什么是成员变量？什么是静态变量？它们的生命周期分别是？

局部变量：

成员变量;

静态变量

4.常量和final

(1)什么是常量，什么是字面常量？什么是符号常量？

（2）变量和常量的命名规则有哪些？

5.基本数据类型介绍

(1)数据类型分为哪两大类？

(2)基本数据类型中有几大类？又细分为哪几种？分别占据的空间是多少？

3大类

数值型：

浮点型 float 4字节 double 8字节

字符型

布尔型

6.整型变量和整型常量

(1)整型分为哪几种？整型常数默认为什么类型？

(2)整型常量的表示形式有哪几种？分别是什么样的格式？

7.浮点型变量和BigDecimal的使用

(1)浮点型的表示形式有几种？分别是什么样的格式？

(2)浮点型有几种？分别精确到几位有效数字？

(3)浮点型适合金融领域么？金融领域用什么比较好？

8.字符串类型\_转义字符

(1)表示一个char类型，用单引号还是双引号？

(2)char类型占几个字节？一个汉字占几个字节？一个char变量能存储一个汉字么？

2字节 2字节 能

(3)什么是转义字符？

9.布尔型\_if语句的使用要点

(1)布尔型的值有哪些，占用多少存储空间？

(2)布尔值一般配合什么关键字一起使用？

10.运算符介绍

(1)运算符有哪些？

算数运算符

(1)算数运算符分为哪些？整型做运算，浮点数做运算，有什么需要注意的？

(2)取余操作，余数与谁的符号一致？

(3)++ – 操作在数字前后有什么区别？

赋值和赋值扩展运算符

(1)Int a =3 ，把谁赋值给了谁？

3赋值给了a

(2) A += 3 等价于什么？

关系运算符

(1)关系运算符的结果是什么？分别有哪些关系运算符，代表什么意思？

逻辑运算符\_短路运算详解

(1)逻辑运算符操作的是什么？逻辑与逻辑或的规则是什么？

(2)什么是短路与，短路或？

位运算符

(1)位运算符有哪些？分别代表什么意思？

(2)& 和 | 左右侧如果是布尔值，就是逻辑运算符，如果是数字，就是位运算符，这句话对么？

(3)怎么样计算3\*16最快？

字符串连接符

(1)字符串是基本数据类型么？什么时候加号会变成字符串连接符？

条件运算符

(1)条件运算符的格式是什么？

(2)条件运算符也成为三目运算符，三目运算也可以用什么来代替

数据类型

1、 整数数据类型

2、 小数数据类型

3、 字符数据类型

4、 布尔数据类型

数据类型转换

一、自动类型转换

首先我们要了解自动类型转换是什么，为什么要进行自动类型转换呢？

注意事项

1.在表达式中，表达式的最终结果类型由表达式的最高类型决定。

二、强制类型转换

为什么要进行强制类型转换，强制类型转换是什么？

运算符

保留字

1.定义数据类型（16）

2.用于流程控制（10）

3.用于修饰变量（常量）、方法、类（接口）和包等（16）

4.异常处理（6）

5.无意义保留字（2）

6.非关键字类型（3）

转义字符

null符号

Void符号

一、void含义

二、void的作用

注释

1、单行注释

2、多行注释

3、文档注释

Math类

Scanner类

3. Unicode 是一种字符编码

第三章 选择结构

if语句

1：if语法

2：if --- else ---

3：if-- else if-- else

4：嵌套if

Switch语句

第四章 循环结构

for循环

while循环

do while循环

continue和break

第五章 方法与重载

方法定义

方法调用

方法重载

3.与返回值、访问修饰符无关。

第六章 类与对象

面对对象

类的定义

对象的创建

方法的调用

1.调用静态方法

2非静态方法

3.方法与方法之间的调用

（1）静态方法内部调用其他方法

（2）非静态方法内部调用

给方法传递对象参数

变量的作用域

This关键字

Static关键字

3.static修饰的变量是静态变量

第七章 封装

包

可见性修饰符

访问器方法

第八章 继承

继承

· Java是单继承模式：一个类只能继承一个直接父类

方法的覆盖

继承关系中的构造方法和super关键字

（2）当子类的成员出现同名时，可以用super来区分

Object类及其常用方法

1.toString()

2.hashCode()

3.equals()

Final关键字

第九章 多态

多态

父类子类对象的使用与转化

Instanceof运算符

第十章 抽象类和接口

抽象类

接口

内部类

第十一章 Lambda表达式

函数式接口

Lambda表达式

第十二章 异常与断言

异常的概念

一、异常的概念以及常见的异常

2、常见的异常：数组索引越界、空指针异常、日期格式化异常，等

二、异常的体系

异常的处理

Finally子句

1.通过代码强行使程序走到finally块前停止。

2.出现“天灾”

Java的断言机制

第十三章 字符串与日期

封装类

数字的格式化

DecimalFormat

2，DecimalFormat 类包含一个模式和一组符号

正则表达式

单个符号

1、英文句点.符号：匹配单个任意字符。

4、表示匹配次数的符号

6、\\S符号：非空字符

快捷符号

常用的正则表达式

3、JavaScript：/^\\w+$/匹配字母数字下划线。

日期

第十四章 数组

数组的基本知识

4、数组当中可以存储基本数据类型也可以存取引用数据类型

6、数组在内存方法是怎样的

13、数组中首元素的地址作为整个数组对象的地址

15、数组的优缺点

16、如何声明、定义一个数组？

17、怎么初始化一个一维数组

18、当一个方法的参数是一个数组

21、一维数组扩容

（1）在Java中数组一旦确定，长度不可变

数组的复制

数组的排序

1、使用Arrays.sort()排序

2、冒泡排序

3、选择排序

4、反转排序

5、直接插入排序

数组的查找

普通查找

二分法查找

Arrays类

第十五章 集合

集合类概述

Collection接口

1、Collection接口包括的主要方法：

1）添加元素：

2）删除元素：

3）查询：

（1）查询元素

（2）查询集合

4）遍历元素

5）转换数组：

2、Collection接口的定义：

3、Iterable接口的定义方法：

4、Iterable是Java集合类中的一个重要接口，Iterable接口不用于存储元素，而用来遍历已有集合中的元素。例如List、Set和Map等。（于Set而言，Iterable是遍历其中元素的唯一途径）

5、在Collection的子接口中，List中的元素有位置（即index），而Set中的元素没有位置和顺序。

Llist集合

Set集合

Map集合

迭代器

泛型

*   **Java概述**

#### **Java运行原理**  ####

**1.编写**

编写是指在Java开发环境中进行程序代码的编辑，最终生成后缀名为“.java”的Java源文件。

**2.编译**

编译是指使用Java编译器对源文件进行错误排查的过程，编译后将生成后缀名为.class的字节码文件，该文件可以被Java虚拟机（JVM）的解释器正常读取。

**3.运行**

运行是指使用Java解释器将字节码文件翻译成机器代码，执行并显示结果。字节码文件是一种和任何具体机器环境及操作系统环境无关的中间代码，它是一种二进制文件，是Java源文件由Java编译器编译后生成的目标代码文件。编程人员和计算机都无法直接读懂字节码文件，它必须由专用的Java解释器来解释执行，因此Java是一种在编译基础上进行解释运行的语言。

在运行Java程序时，首先会启动JVM，然后由它来负责解释执行Java的字节码，并且Java字节码只能运行于JVM之上。这样利用JVM就可以把Java字节码程序和具体的硬件平台以及操作系统环境分隔开来，只要在不同的计算机上安装了针对于特定具体平台的JVM，Java程序就可以运行，而不用考虑当前具体的硬件平台及操作系统环境，也不用考虑字节码文件是在何种平台上生成的。JVM把这种不同软硬件平台的具体差别隐藏起来，从而实现了真正的二进制代码级的跨平台移植。JVM是Java平台无关的基础，Java的跨平台特性正是通过在JVM中运行Java程序实现的。

#### **JDK简介** ####

JDK是 [Java][] 语言的[软件开发工具包][Link 1]，主要用于[移动设备][Link 2]、[嵌入式设备][Link 3]上的java应用程序。JDK是整个java开发的核心，它包含了JAVA的运行环境（JVM+Java系统类库）和JAVA工具。

#### **Java程序的分类** ####

**Application**

―Java应用程序”是可以独立运行的Java程序。

由Java解释器控制执行。

**Applet**

―Java小程序”不能独立运行（嵌入到Web页中）。

由Java兼容浏览器控制执行。

**Serverlets**

是Java技术对CGI 编程的解决方案。

是运行于Web server上的、作为来自于Web browser 或其他HTTP client端的请求和在server上的数据库及其他应用程序之间的中间层程序。

Serverlets的工作是：

读入用户发来的数据（通常在web页的form中）

找出隐含在HTTP请求中的其他请求信息（如浏览器功能细节、请求端主机名等。

产生结果(调用其他程序、访问数据库、直接计算)

格式化结果（网页）

设置HTTP response参数(如告诉浏览器返回文档格式)

将文档返回给客户端。

1.  Java区分大小写
2.  Java源程序文件的扩展名是.java。字节码文件的扩展名是.class。
3.  编译Java程序的命令是javaco
4.  运行Java程序的命令是java

*   **基本符号**

#### **变量** ####

在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：

type identifier \[ = value\]\[, identifier \[= value\] ...\] ;

格式说明：type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。

以下列出了一些变量的声明实例。注意有些包含了初始化过程。

int a, b, c; // 声明三个int型整数：a、 b、c int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值 byte z = 22; // 声明并初始化 z String s = "runoob"; // 声明并初始化字符串 s double pi = 3.14159; // 声明了双精度浮点型变量 pi char x = 'x'; // 声明变量 x 的值是字符 'x'。

Java语言支持的变量类型有：

类变量：独立于方法之外的变量，用 static 修饰。

实例变量：独立于方法之外的变量，不过没有 static 修饰。

局部变量：类的方法中的变量。

**实例**

public class Variable\{ static int allClicks=0; // 类变量 String str="hello world"; // 实例变量 public void method()\{ int i =0; // 局部变量 \} \}

**Java 局部变量**

局部变量声明在方法、构造方法或者语句块中；

局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；

访问修饰符不能用于局部变量；

局部变量只在声明它的方法、构造方法或者语句块中可见；

局部变量是在栈上分配的。

局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

**实例 1**

在以下实例中age是一个局部变量。定义在pupAge()方法中，它的作用域就限制在这个方法中。

package com.runoob.test; public class Test\{ public void pupAge()\{ int age = 0; age = age + 7; System.out.println("小狗的年龄是: " + age); \} public static void main(String\[\] args)\{ Test test = new Test(); test.pupAge(); \} \}

以上实例编译运行结果如下:

小狗的年龄是: 7

**实例 2**

在下面的例子中 age 变量没有初始化，所以在编译时会出错：

package com.runoob.test; public class Test\{ public void pupAge()\{ int age; age = age + 7; System.out.println("小狗的年龄是 : " + age); \} public static void main(String\[\] args)\{ Test test = new Test(); test.pupAge(); \} \}

以上实例编译运行结果如下:

Test.java:4:variable number might not have been initialized

age = age + 7;

^1 error

**实例变量**

实例变量声明在一个类中，但在方法、构造方法和语句块之外；

当一个对象被实例化之后，每个实例变量的值就跟着确定；

实例变量在对象创建的时候创建，在对象被销毁的时候销毁；

实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；

实例变量可以声明在使用前或者使用后；

访问修饰符可以修饰实例变量；

实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；

实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；

实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObjectReference.VariableName。

**实例**

Employee.java 文件代码：

import java.io.\*; public class Employee\{ // 这个实例变量对子类可见 public String name; // 私有变量，仅在该类可见 private double salary; //在构造器中对name赋值 public Employee (String empName)\{ name = empName; \} //设定salary的值 public void setSalary(double empSal)\{ salary = empSal; \} // 打印信息 public void printEmp()\{ System.out.println("名字 : " + name ); System.out.println("薪水 : " + salary); \} public static void main(String\[\] args)\{ Employee empOne = new Employee("RUNOOB"); empOne.setSalary(1000.0); empOne.printEmp(); \} \}

以上实例编译运行结果如下:

$ javac Employee.java

$ java Employee名字 : RUNOOB薪水 : 1000.0

--------------------

**类变量（静态变量）**

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。

无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。

静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。

静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量。

静态变量在第一次被访问时创建，在程序结束时销毁。

与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型。

默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。

静态变量可以通过：ClassName.VariableName的方式访问。

类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。

**实例：**

Employee.java 文件代码：

import java.io.\*; public class Employee \{ //salary是静态的私有变量 private static double salary; // DEPARTMENT是一个常量 public static final String DEPARTMENT = "开发人员"; public static void main(String\[\] args)\{ salary = 10000; System.out.println(DEPARTMENT+"平均工资:"+salary); \} \}

以上实例编译运行结果如下:

开发人员平均工资:10000.0

注意：如果其他类想要访问该变量，可以这样访问：Employee.DEPARTMENT。

#### **标识符** ####

Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言，是由[Sun Microsystems][]公司于1995年5月推出的Java程序设计语言和[Java平台][Java 1]（即JavaSE, JavaEE, JavaME）的总称。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、[数据中心][Link 4]、游戏控制台、科学[超级计算机][Link 5]、移动电话和互联网，同时拥有全球最大的开发者专业社群。在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。

Java语言中，对于变量，[常量][Link 6]，函数，语句块也有名字，我们统统称之为Java标识符。

**标识符组成**

Java标识符由数字，字母和下划线（\_），美元符号（$）或人民币符号（￥）组成。在Java中是区分大小写的，而且还要求首位不能是数字。最重要的是，Java[关键字][Link 7]不能当作Java标识符。

下面的标识符是合法的：

myName，My\_name，Points，$points,\_sys\_ta，OK，\_23b，\_3\_

下面的标识符是非法的：

\#name，25name，class，&time，if

**命名约定**

1.类和接口名。每个字的首字母大写，含有大小写。例如，MyClass，HelloWorld，Time等。

2.方法名。首字符小写，其余的首字母大写，含大小写。尽量少用下划线。例如，myName，setTime等。这种命名方法叫做驼峰式命名。

3.[常量][Link 8]名。基本数据类型的常量名使用全部大写字母，字与字之间用下划线分隔。对象常量可大小混写。例如，SIZE\_NAME。

4.变量名。可大小写混写，首[字符][Link 9]小写，字间[分隔符][Link 10]用字的首字母大写。不用下划线，少用美元符号。给变量命名是尽量做到见名知义。

#### **Java的基本符号**  ####

**1.注释（单行注释，多行注释，文档注释）**

**(1)什么是注释？请写出单行注释，多行注释，以及文档注释**

为了方便程序的阅读，Java语言允许程序员在程序中写上一些说明性的文字，用来提高程序的可读性，这些文字性的说明就称为注释。

单行注释：使用“//”开头，“//”后面的单行内容均为注释

多行注释：以“/”开头以“/”结尾

文档注释：以“/\*\*”开头以“\*/”结尾

**2.标识符规则\_驼峰规则**

**(2)标识符的作用是什么，标识符的声明需要遵循哪些规则，哪些规范，标识符可以使用汉字么？**

标识符是用来给变量、类、方法以及包进行命名的；不可以。

**(3)将课上的代码敲两遍，体验一下标识符的声明规则和规范**

**1.Java的关键字保留字**

**(1)将文档中的关键字都手写一遍，混个脸熟**

Abstract assert Boolean break byte case

Catch char class const continue default

Do double else extends final finally

Float for goto if implements import

Instanceof int interface long native new

Null package private protected public return

Short statics strictfp super switch synchronized

This throw throws transient try void

Volatile while

**2.变量的本质\_声明格式和初始化问题**

**(1)变量的本质是什么？**

可操作的存储空间

**(2)变量的要素是哪三点？**

变量名称 变量类型 作用域

**3.变量分类（局部变量，成员变量，静态变量）**

**(1)什么是局部变量？什么是成员变量？什么是静态变量？它们的生命周期分别是？**

**局部变量：**方法或语句块内部定义的变量。生命周期是从声明位置开始到到方法或语句块执行完毕为止。

**成员变量;**方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。

**静态变量**;使用static定义。 从属于类，生命周期伴随类始终，从类加载到卸载。

**4.常量和final**

**(1)什么是常量，什么是字面常量？什么是符号常量？**

常量通常指的是一个固定的值；

将1，2，3，a，b，true，false等称为字面常量

Final修饰的 PI称为符号常量

**（2）变量和常量的命名规则有哪些？**

1．见名知意

2．首字母小写和驼峰规则

**5.基本数据类型介绍**

**(1)数据类型分为哪两大类？**

基本数据类型 引用数据类型

**(2)基本数据类型中有几大类？又细分为哪几种？分别占据的空间是多少？**

3大类

**数值型：** 整数类型byte1字节short2字节int4字节long8字节

**浮点型** float 4字节 double 8字节

**字符型**： char 2字节

**布尔型**： 1位

**6.整型变量和整型常量**

**(1)整型分为哪几种？整型常数默认为什么类型？**

4种 byte-128~127 short-32768~32767 int long int为默认

**(2)整型常量的表示形式有哪几种？分别是什么样的格式？**

四种表现形式 ， 十 ， 八：以0开头 ， 十六：以0x开头 ， 二进制：0b开头

**7.浮点型变量和BigDecimal的使用**

**(1)浮点型的表示形式有几种？分别是什么样的格式？**

十进制数形式，例如:3.14 314.0 0.314

科学记数法形式，如314e2 314E2 314E-2

**(2)浮点型有几种？分别精确到几位有效数字？**

两种 ，float 7位

double 14位

**(3)浮点型适合金融领域么？金融领域用什么比较好？**

不适用 BinDecimal

**8.字符串类型\_转义字符**

**(1)表示一个char类型，用单引号还是双引号？**

单引号

**(2)char类型占几个字节？一个汉字占几个字节？一个char变量能存储一个汉字么？**

2字节 2字节 能

**(3)什么是转义字符？**

用\\将后面字符换变为其他含义

**9.布尔型\_if语句的使用要点**

**(1)布尔型的值有哪些，占用多少存储空间？**

True，false 占1位

**(2)布尔值一般配合什么关键字一起使用？**

Boolean

**10.运算符介绍**

**(1)运算符有哪些？**

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

**算数运算符**

**(1)算数运算符分为哪些？整型做运算，浮点数做运算，有什么需要注意的？**

算术运算符：二元运算符：+，-，，/，%

一元运算符：++，–

整数/整数 得整数

有 long 结果为long

有double 结果为double

只有两个为float 结果才为float

**(2)取余操作，余数与谁的符号一致？**

符号和左边操作数相同

**(3)++ – 操作在数字前后有什么区别？**

判断是先加先减还是后加后减

**赋值和赋值扩展运算符**

**(1)Int a =3 ，把谁赋值给了谁？**

3赋值给了a

**(2) A += 3 等价于什么？**

a = a + 3

**关系运算符**

**(1)关系运算符的结果是什么？分别有哪些关系运算符，代表什么意思？**

结果为 ture或false

**逻辑运算符\_短路运算详解**

**(1)逻辑运算符操作的是什么？逻辑与逻辑或的规则是什么？**

运算符 说明

逻辑与 &( 与) 两个操作数为true，结果才是true，否则是false

逻辑或 |(或) 两个操作数有一个是true，结果就是true

短路与 &&( 与) 只要有一个为false，则直接返回false

短路或 ||(或) 只要有一个为true， 则直接返回true

逻辑非 !（非） 取反：!false为true，!true为false

逻辑异或 ^（异或） 相同为false，不同为true

**(2)什么是短路与，短路或？**

短路与 &&( 与) 只要有一个为false，则直接返回false

短路或 ||(或) 只要有一个为true， 则直接返回true

**位运算符**

**(1)位运算符有哪些？分别代表什么意思？**

位运算符 说明

~ 取反

& 按位与

| 按位或

^ 按位异或

<< 左移运算符，左移1位相当于乘2

右移运算符，右移1位相当于除2取商

**(2)& 和 | 左右侧如果是布尔值，就是逻辑运算符，如果是数字，就是位运算符，这句话对么？**

后半句不对，如果两侧的操作数是整数类型，就是位运算符

**(3)怎么样计算3\*16最快？**

3<<4

**字符串连接符**

**(1)字符串是基本数据类型么？什么时候加号会变成字符串连接符？**

不是 ，是对象 ；“+”运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接。

**条件运算符**

**(1)条件运算符的格式是什么？**

X ? Y : Z

**(2)条件运算符也成为三目运算符，三目运算也可以用什么来代替**

If else

#### **数据类型** ####

**1、 整数数据类型**

byte：1个字节，8位，256种状态，取值范围为【-128,127】

short：2个字节，16位，65536种状态，取值范围为【-32768,32767】

int：4个字节，32位，整数类型默认是int类型，取值范围约21亿

long：8个字节，64位，long类型表示long类型常量，要加L或者l，建议加L

**2、 小数数据类型**

float：4个字节，32位，单精度，能精确到6~7位，声明一个小数类型，要加F或者f，建议加F

double：8个字节，64位，双精度，能精确到15~16位，小数类型默认是double类型

**3、 字符数据类型**

char：2个字节，16位，字符表示Unicode（万国码）编码表中的每一个符号，每个符号使用单引号引起来，其中前128个符号和ASCII表相同

**4、 布尔数据类型**

boolean：占1位，有true和false2个值，一个表示真，一个表示假，一般用于表示逻辑运算

#### **数据类型转换** ####

**一、自动类型转换**

**首先我们要了解自动类型转换是什么，为什么要进行自动类型转换呢？**

1.自动类型转换就是类型范围小的变量，可以直接赋值给类型范围大的变量。比如以下代码：

其中int类型的范围大于byte类型，故a的值可以直接赋予b，这就叫自动类型转换。

2.自动类型转换就是让存在不同类型的变量赋值给其他类型的变量。简而言之就是让类型小的数据可以直接赋值给类型大的数据，让数据类型大的去得到它。

数据类型的大小关系，从小到大：

byte→short→char→int→long→float→double

**注意事项**

1.在表达式中，表达式的最终结果类型由表达式的最高类型决定。

2.在表达式中，byte 、short、char是直接转换成int类型参与运算的。

**二、强制类型转换**

**为什么要进行强制类型转换，强制类型转换是什么？**

1.类型范围大的数据或者变量是不能直接赋值给类型范围小的变量的，所以就必须使用强制类型转换来帮忙实现数据的转换。

2.强制类型转换就是可以强制将类型范围大的数据或者变量赋值给类型范围小的变量。

3.强制类型转换的一般写法: 数据类型 变量2 = （数据类型）变量 ；

#### **运算符** ####

#### **保留字**  ####

**1.定义数据类型（16）**

基本数据类型（8）：boolean，byte，char，int，short，long，float，double

实例相关（4）：new，this，super，instanceof

其他类型（4）：class，interface，enum，void

**2.用于流程控制（10）**

选择（5）：if，else，switch，case，break

循环（3）：do，while，for

其他（2）：continue，return

**3.用于修饰变量（常量）、方法、类（接口）和包等（16）**

访问权限（4）：private，protected，public，default

类、接口间关系（2）：extends，implements

包相关（2）：import，package

常用（4）：abstract，final，static，synchronized

不常用（4）：native，strictfp，transient， volatile

**4.异常处理（6）**：try，catch，throw，throws，finally，assert

**5.无意义保留字（2）**：goto，const

**6.非关键字类型（3）**：false，true，null

#### **转义字符** ####

#### **null符号** ####

null是代表不确定的对象

Java中，null是一个关键字，用来标识一个不确定的对象。因此可以将null赋给引用类型变量，但不可以将null赋给基本类型变量。

比如：int a = null;是错误的。Ojbect o = null是正确的。

Java中，变量的适用都遵循一个原则，先定义，并且初始化后，才可以使用。我们不能在int a后，不给a赋值，就去打印a的值。这条对对于引用类型变量也是适用的。

有时候，我们定义一个引用类型变量，在刚开始的时候，无法给出一个确定的值，但是不指定值，程序可能会在try语句块中初始化值。这时候，我们下面使用变量的时候就会报错。这时候，可以先给变量指定一个null值，问题就解决了。

#### **Void符号** ####

**一、void含义**

void是无返回值的意思

void的字面意思是“无类型”，void \*则为“无类型指针”，void \*可以指向任何类型的数据。void几乎只有“注释”和限制程序的作用，定义一个void变量没有意义。

**二、void的作用**

void的作用在于对函数返回的限定以及对函数参数的限定。如果7a6431333366306535JAVA里指针p1和p2的类型相同，那么我们可以直接在p1和p2间互相赋值，如果p1和p2指向不同的数据类型，则必须使用强制类型转换运算符把赋值运算符右边的指针类型转换为左边指针的类型。

#### **注释** ####

**1、单行注释**

以双斜杠“//”标识，只能注释一行内容，用在注释信息内容少的地方。打开 Eclipse，在 Java 代码中使用单行注释。

**2、多行注释**

包含在“/\*”和“\*/”之间，能注释很多行的内容。为了可读性比较好，一般首行和尾行不写注释信息（这样也比较美观好看）。

注意：多行注释可以嵌套单行注释，但是不能嵌套多行注释和文档注释。

**3、文档注释**

包含在“/\*\*”和“\*/”之间，也能注释多行内容，一般用在类、方法和变量上面，用来描述其作用。注释后，鼠标放在类和变量上面会自动显示出我们注释的内容。

注意：文档注释能嵌套单行注释，不能嵌套多行注释和文档注释，一般首行和尾行也不写注释信息。

#### **Math类** ####

在 Java 中 Math 类封装了常用的数学运算，提供了基本的数学操作，如指数、对数、平方根和三角函数等。Math 类位于 java.lang 包，它的构造方法是 [private][] 的，因此无法创建 Math 类的对象，并且 Math 类中的所有方法都是类方法，可以直接通过类名来调用它们。

#### **Scanner类** ####

Scanner类是一个可以解析基本类型和字符串的简单文本扫描器。

使用Scanner类：通过new一个Scanner对象，从控制台输入语句：Scanner s = new Scanner(System.in)；

常用的输入的内容分为：

nextInt():输入整数

nextDouble():输入双精度数

nextLine():输入字符串（包括单词之间的空格和除回车以外的所有符号）

next():输入字符串（只从有效字符计算，对输入有效字符之前遇到的空格键、Tab键、换行符或Enter键等结束符，next（）方法会自动将其去掉，只有在输入有效字符之后，next（）方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符以空格结束）

1.  数据类型的精度由高到低的顺序是double, float, int, byte
2.  对于一个三位的正整数n,取出它的十位数字k(k为整型)的表达式是k = n/10% 10 
3.  Unicode 是一种字符编码
4.  6+5%3+2 的值是10
5.  \-20能正确表示Java语言中的一个整型常量
6.  在Java语言中，逻辑常量只有true和false两个值
7.  Java中的字符使用的是16位的Unicode编码
8.  Java语言中的浮点型数据根据数据存储长度和数值精度的不同，进一步分为float和double 两种具体类型

### **第三章 选择结构** ###

#### **if语句** ####

If语句主要用于分支结构，表示判断的意思，主要分为3种表现方式

**1：if语法**

If一般用于单个判断，表示如果的意思；条件成立则会执行相应的代码。

语法：

If(表达式)\{

//代码块，当表达式为true时，才会执行这里的代码

注意：表达式的结果必须是一个布尔值，如果条件有多个可以使用逻辑运算符&&-并且， || - 或者， ！-非，取反

**2：if --- else ---**

If-else结构一般用于二选一的情况，如果if成立执行if的代码块，否则执行else中的代码块。

If(表达式)\{

//代码块，当表达式为true时，才会执行这里的代码

\}else\{

//表达式为false时，执行这里的代码

**3：if-- else if-- else**

多重if结构主要用于多重判断的情况，语法如下：

if(表达式1)\{

//表达式1为true时，执行这里的代码

\}else if(表达式2)\{

//表达式2为true时，执行这里的代码

\}else if(表达式3)\{

//表达式3为true时，执行这里的代码

\-----

else\{

//所有条件都不满足的时候，会执行这里的代码

If小结：

一次判断用if语句

两次判断（一个真一个假）用if - else 语句

两次以上判断使用 if - else if - else

**4：嵌套if**

嵌套if就是在if判断语句中还有if判断的语句，嵌套if控制语句可以通过外层语句和内层语句的协作，增强程序的灵活性。

#### **Switch语句** ####

Switch语句可以实现根据某一变量选则执行代码块。当然直接使用If语句也可以做到，但是有时候使用Switch语句往往更加简洁优美。

### **第四章 循环结构** ###

#### **for循环** ####

for 语句是一种在程序执行前就要先判断条件[表达式][Link 11]是否为真的循环语句。假如条件表达式的结果为假，那么它的循环语句根本不会执行。for 语句通常使用在知道循环次数的循环中。

for 语句语法格式如下所示。

for(条件表达式1;条件表达式2;条件表达式3) \{

语句块;

for 循环中 3 个条件表达式的含义如表 1 所示。

表 1 for 循环中 3 个表达式的含义 表达式 形式 功能 举例 条件表达式 1 赋值语句 循环结构的初始部分，为循环变量赋初值 int i=1 条件表达式 2 条件语句 循环结构的循环条件 i>40 条件表达式 3 迭代语句，通常使用

\++ 或 -- 运算符 循环结构的迭代部分，通常用来修改循环

变量的值 i++

for 关键字后面括号中的 3 个条件表达式必须用“;”隔开。for 循环中的这 3 部分以及大括号中使循环体必需的 4 个组成部分完美地结合在一起，简单明了。

for 循环语句执行的过程为：首先执行条件表达式 1 进行初始化，然后判断条件表达式 2 的值是否为 true，如果为 true，则执行循环体语句块；否则直接退出循环。最后执行表达式 3，改变循环变量的值，至此完成一次循环。接下来进行下一次循环，直到条件表达式 2 的值为 false，才结束循环

#### **while循环** ####

while循环在每次循环开始前，先会判断条件是否成立。如果计算结果为true，就把循环体内的语句执行一遍，如果计算结果为false，那就直接跳到while循环的末尾，继续往下执行。

举个例子，用while循环来计算1到100的累加。

public class Main \{

public static void main(String\[\] args) \{

int sum = 0; // 累加的和，初始化为0

int n = 1;

while (n <= 100) \{ // 循环条件是n <= 100

sum = sum + n; // 把n累加到sum中

n ++; // n自身加1

System.out.println(sum); // 5050

执行结果：

5050

值得注意的是while循环是先判断循环条件，再循环，因此，有可能一次循环都不做。如果循环条件永远满足，那这个循环就变成了死循环。死循环将导致100%的CPU占用，用户会感觉电脑运行缓慢，所以要避免编写死循环代码。

如果循环条件的逻辑写得有问题，也会造成意料之外的结果。

#### **do while循环** ####

do-while循环总是先执行循环体，然后再计算条件表达式。如果表达式为真，则循环继续。否则，循环结束。对所有的Java循环都一样，条件condition必须是一个布尔表达式。

下面是一个重写的“tick”程序，用来演示do-while循环。它的输出与先前程序的输出相同。

// Demonstrate the do-while loop.

class DoWhile \{

public static void main(String args\[\]) \{

int n = 10;

do \{

System.out.println("tick " + n);

n--;

\} while(n > 0);

该程序中的循环虽然在技术上是正确的，但可以像如下这样编写更为高效：

do \{

System.out.println("tick " + n);

\} while(--n > 0);

在本例中，表达式“-- n > 0 ”将n值的递减与测试n是否为0组合在一个表达式中。它的执行过程是这样的。首先，执行-- n 语句，将变量n递减，然后返回n的新值。这个值再与0比较，如果比0大，则循环继续。否则结束。

do-while循环在你编制菜单选择时尤为有用，因为通常都想让菜单循环体至少执行一次。

#### **continue和break**  ####

break的用法：1.break用于switch语句中，终止switch语句

2.break用于循环时，跳出循环

3.break用于其他位置时，毫无意义

在循环结构中，当我们遇到不满足某些条件时，不需要继续执行下去，这时就可以用break跳出循环结构。break通常在循环中与条件语句一起使用。

continue语句的作用是跳过当前循环而执行下一次循环，它只能用在循环中。

### **第五章 方法与重载** ###

#### **方法定义** ####

1.方法的名称 2.方法返回的数据类型 3.方法体（方法里不能定义方法）。

方法的返回值：void是无返回值的，有返回值有return（return跳出方法，给出结果，返回类型为该方法返回值的类型，只能返回一个值。）；

方法只允许单继承，可以有多个接口。

static静态的 调用为 类名.方法名（），不是静态的要实例化然后 对象名.方法名（）。

静态的方法不能访问非静态的。

#### **方法调用** ####

第一种：通过对象名.方法名进行调用，这是最普通的也是最常见的一种调用方式。

第二种：通过new关键字调用[构造方法][Link 12]，这种是在实例化对象时使用的方式。

第三种：通过类名.方法名调用，当需要调用的那个方法为静态（有[static][]的）方法时使用。

#### **方法重载** ####

1.同一个类中，方法名称一致；

2.方法参数的个数、类型或者顺序不一致；

有多个方法名相同，编译器只能通过独一无二的参数列表来表示。参数个数、类型、顺序不同均可表示。（顺序不同也可以区分两个方法，但是建议不要这样用，否则将增加代码维护的难度）。

3.与返回值、访问修饰符无关。

重载的判断依据调用时能否区分开，故传入参数类型、参数个数都是可以区分，然而返回类型当调用时是不能区分开的（这样应该就可以理解特点2和特点3的原因了吧……——……）。

\*区分重载的方法是只能依据类名和方法的形参列表作为标准，这种正向使用方法的角度进行判断更利于程序员的运用。

### **第六章 类与对象** ###

#### **面对对象** ####

*  面向对象是相对面向过程而言
 *  面向对象和面向过程都是一种思想
 *  面向过程强调的是功能、行为
 *  面向对象：将功能封装进对象，强调具备了功能的对象
 *  面向对象是基于面向过程的

#### **类的定义** ####

java类的定义： 类是一类事物的抽象概念，是一个模型。

java对象： 对象是由这个模型所创造的一个个具体存在的，实实在在存在的实例。

所以创建对象的过程也叫实例化对象。

类的结构：

成员变量：类中的属性 名词：品牌，颜色，价格，型号等

方法：类中行为 动词：行驶，加速，停止。

#### **对象的创建** ####

**1. new**

**2. clone**

**3. 通过反射newInstance**

**4. 反序列化**

**5. String s = “abc”（这个是比较特殊的）**

#### **方法的调用** ####

**1.调用静态方法**

静态方法就是用 static 修饰的方法，静态方法的调用是通过类名来调用的， 表现形式如下：

类名.方法()

eg:

public class InvokeMethod\{

public static void main (String\[\] args)\{

InvokeMethod.t2();

public static void t2()\{

System.out.println("static t2....");

**2非静态方法**

非静态方法就是没有 static 修饰的方法，对于非静态方法的调用，是通过对 象来调用的，表现形式如下。

对象名.方法（）

eg：

public class InvokeMethod\{

public static void main(String\[\] args)\{

InvokeMethod in = new InvokeMethod();

in.t1();

public void t1()\{

System.out.printfln("t1");

**3.方法与方法之间的调用**

方法与方法之间的调用，主要是在一个方法内部如何调用其他方法。

**（1）静态方法内部调用其他方法**

如果在本类当中，静态方法可以直接调用静态方法，

除了在 main 方法中，还可以在自定义的静态方法中直接调用。

如果在本类当中是非静态方法，就必须通过对象来调用。

public class InvokeMethod\{

public static void main (String\[\] args)\{

t2();

public static void t2()\{

System.out.println("static t2...");

public static void t1()\{

//静态方法调用非静态方法需通过对象来调用

//InvokeMethod in =new InvokeMethod();

//in.t2();

t2();

System.out.println("static t1");

如果不在一个类当中，静态方法调用其他类中的静态方法，必须通过

类名.静态方法（）；

如果在不同类当中，静态方法调用其他类的非静态方法，需要导入该类中的包，以及通过创建对象调用。

**（2）非静态方法内部调用**

如果在本类中，非静态方法可以直接调用静态方法与非静态方法。

在不同类中，非静态方法调用其他类的静态方法，需要通过导入该类中的包，并且需要通过类名来调用。

在不用类中，非静态方法调用其他类的非静态方法时，需要导入该类中的包，还需要通过创建对象来调用。

#### **给方法传递对象参数** ####

java中给方法传递对象参数，和传递[数组][Link 13]一样，传递对象实际上是传递对象的引用。

#### **变量的作用域** ####

\*　类级变量又称全局级变量或静态变量，需要使用static关键字修饰。类级变量在类定义后就已经存在，占用内存空间，可以通过类名来访问，不需要实例化。

\*　对象实例级变量就是成员变量，实例化后才会分配内存空间，才能访问。成员变量是定义在方法之外，类之内的。成员变量随着对象的创建而存在，随着对象的消失而消失。

\*　方法级变量就是在方法内部定义的变量，就是局部变量。局部变量在调用了对应的方法时执行到了创建该变量的语句时存在，局部变量的作用域从它被声明的点开始，一旦出了自己的作用域马上从内存中消失。

\*　块级变量就是定义在一个块内部的变量，变量的生存周期就是这个块，出了这个块就消失了，比如 if、for 语句的块。块是指由大括号包围的代码，

#### **This关键字** ####

1、this是一个关键字，翻译为：这个。

2、this是一个引用，this变量中保存了内存地址指向自身，this存储在JVM内存java对象内部。

3、创建1001个java对象，每一个对象都有this,也就说有100个不同的this

4、this可以实现出现在“实例方法中”当中，this指向当前正在执行这个动作的对象

#### **Static关键字** ####

1.static英语单词翻译为静态的

2.static修饰的方法是静态方法

3.static修饰的变量是静态变量

4.所有static修饰的元素都称为静态级的，都可以使用“类名.”的方式访问，当然也可以用引用.的方式访问【但不建议】

5.static修饰的所有元素都是类级别的特征，和具体的对象无关

### **第七章 封装** ###

#### **包** ####

包(package) 是组织类的一种方式.

使用包的主要目的是保证类的唯一性.

#### **可见性修饰符** ####

#### **访问器方法** ####

更改器就是会改变原来的数据；

访问器只是会查看数据；

而构造器就是创建。

### **第八章 继承** ###

#### **继承** ####

*   子类可以继承父类的属性和行为，但是子类不能继承父类的构造器
 *  Java是单继承模式：一个类只能继承一个直接父类
 *  Java不支持多继承、但是支持多层继承
 *  Java中所有的类都是object类的子类

Q：子类是否可以继承父类的构造器？

A：不可以，子类有自己的构造器，父类构造器用于初始化父类对象。

Q：子类是否可以继承父类的私有成员？

A：可以，只是不能直接访问。

Q：子类是否可以继承父类的静态成员？

A：子类可以直接使用父类的静态成员，但是不能继承父类的静态成员（共享并不是继承）。

Q：Java中为什么不支持多继承？

A：若子类继承的两个父类中有一个同名方法时，无法选择调用哪一个方法。

Q：Java中为什么支持多层继承（A继承B，B继承C）？

A：即使B和C中有同名方法，A可以通过就近原则来调用B的方法。

#### **方法的覆盖** ####

*  方法的重写发生在具有继承关系的父子类之间
 *  方法名相同返回值类型相同，返回值列表相同（尽量复制粘贴）
 *  访问权限不能更低，可以更高
 *  抛出异常可以更多，可以更少。

#### **继承关系中的构造方法和super关键字** ####

（1）super和this关键字的特点类似：super代表的是父类对象的引用

（2）当子类的成员出现同名时，可以用super来区分

（3）在子类构造方法中，通过super关键字调用父类的构造方法，完成对相关字段值的初始化

强调：当构造一个子类对象的时候一定会先调用父类的构造方法来构造父类的对象。调用父类构造方法的语句必须是子类构造方法中的第一条指令

#### **Object类及其常用方法** ####

**1.toString()**

用于返回对应对象的字符串表示

println(对象名);这个方法会层层调用，一直到object中的toString()

object中toString()默认实现：对象名@十六进制的哈希码值

子类重写toString()后 打印的是对象的的类型+属性+属性值

**2.hashCode()**

用于返回对应对象的哈希码值

哈希码值的得出是通过一种算法，让不同的对象具有不同的哈希码值，用户区分不同的对象

有时存在不同对象相同哈希码值的情况，称之为“哈希碰撞”现象

Object默认实现哈希码值根据地址值生成

子类重写后哈希码值根据重写后传入的对象的属性生成

**3.equals()**

用于指示其他某个对象是否与当前对象“相等”

Object中默认实现使用的是==比较

==比较的是左右两边的值，如果是基本类型，比较的就是字面值，引用类型比较的是引用类

型变量保存的地址值

子类重写后，比较的是对象的类型+属性+属性值

#### **Final关键字** ####

### **第九章 多态** ###

#### **多态** ####

多态，就是方法或对象有多种形态，包括方法的多态和对象的多态。

#### **父类子类对象的使用与转化** ####

实例化是谁，谁提供成员变量以及属性，谁声明，用谁的变量与函数的范围。

这个可能与对象的实现机制有关，后面扒一扒java底层和jvm应该好理解。

关系

父类就是被继承的那个类，也叫做基类、超类。子类就是继承父类的类。他们之间的关系主要

是以下几点

1.声明表示调用范围。

2. 实例化表示最终的对象类型。

父类与子类之间，除了父类实例化的不能强制转换成子类，其他的都可以。比如父类声明子类实例化，可以将父类强制转换成子类，而子类声明子类实例化的也可以强制转化成父类。

对于调用范围一说，看它声明是父类还是子类，父类只能调用父类所包含的属性，但调用的还是实例化对象的。

#### **Instanceof运算符** ####

java instanceof运算符用于测试指定对象是否是指定类型(类或子类或接口)的实例。

java中的instanceof也称为类型比较运算符，因为它将类型与实例进行比较。 它返回true或false。 如果对任何具有null值的变量应用instanceof运算符，则返回false。

### **第十章 抽象类和接口** ###

#### **抽象类** ####

普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。

那么什么叫抽象方法呢？在所有的普通方法上面都会有一个“\{\}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。

而拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明

#### **接口** ####

官方解释：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

我的解释：接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法。（JDK1.8之前可以这样理解）

#### **内部类** ####

内部类与外部类的关系

a.成员内部类的创建需要依赖于外部类对象-（成员方法必须通过对象调用），在没有外部类实例之前无法创建成员内部类对象

b.内部类与外部类相对独立，不是is a 的关系（发动机-汽车）

c.私有属性的互相访问，内部类可以直接访问外部类，而外部类访问内部类需要内部类的对象来访问

d.创建内部类的语法

1.在外部类内部创建内部类对象（Inner inner = new Inner()）

2.在外部类外部创建内部类对象，外部类.内部类 inner = new Outter().new Inner();

e.在内部类内部使用隐藏的外部类对象（隐藏的this）

### **第十一章 Lambda表达式** ###

#### **函数式接口** ####

函数式接口在Java中是指：有且仅有一个抽象方法的接口。

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可 以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实 底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部 类的“语法糖”，但是二者在原理上是不同的。

#### **Lambda表达式** ####

Lambda表达式（闭包）：java8的新特性，lambda运行将函数作为一个方法的参数，也就是函数作为参数传递到方法中。使用lambda表达式可以让代码更加简洁。

Lambda表达式的使用场景：用以简化接口实现。

关于接口实现，可以有很多种方式来实现。例如：设计接口的实现类、使用匿名内部类。 但是lambda表达式，比这两种方式都简单。

### **第十二章 异常与断言** ###

#### **异常的概念** ####

**一、异常的概念以及常见的异常**

1、异常是程序在“编译”或者“执行”的过程中出现的问题。ps：语法错误不算在一场体系中

2、常见的异常：数组索引越界、空指针异常、日期格式化异常，等

异常的作用：异常一旦出现了，如果没有提前处理，程序就会退出JVM虚拟机而终止。研究异常并且避免异常，然后提前处理异常，体现的是程序的安全、健壮性。

**二、异常的体系**

1、Error：系统级别的问题、JVM推退出等，代码无法控制。

2、Exception：java.lang包下，称为异常类，它表示程序本身可以处理的问题。

①RuntimeException及其子类：运行时异常，编译阶段不会报错。（空指针异常、数组越界异常）

②除RuntimeException之外所有的异常：编译时异常，编译期必须处理的，否则程序不能通过编译。（日期格式化异常）

#### **异常的处理** ####

第一种方式：在方法声明的位置上，使用throws关键字，抛给上一级。谁调用我，我就抛给谁。

第二种方式：使用try…catch语句进行异常的捕捉。

异常发生之后，如果我选择了上抛，抛给了我的调用者，调用者需要对这个异常继续处理，那么调用者处理这个异常同样有两种处理方式。Java中异常发生之后如果一直上抛，最终抛给了main方法，main方法向上抛，抛给了调用者JVM，JVM知道这个异常发生，只有一个结果：终止java程序。（方法1 --> 方法2 --> … --> JVM）

#### **Finally子句** ####

不论try块中是否出现异常或者异常是否被捕获，finally块一定会执行。

说finally块一定会执行，当然是理想条件下的（程序不会异常停止），但是在现实生活中，会出现突发情况（也可以是人为），在下面的两种情况下，finally块不会执行

1.通过代码强行使程序走到finally块前停止。

System.exit(status:0); //此行代码的作用是结束当前正在运行的Java虚拟机，其中status表示退出状态码，0.正常退出 非零.非正常退出

2.出现“天灾”

软件异常关闭、电脑突然关机(如果小伙伴使用的是台式机器突然停电机会导致突然关机)、等等。

需要注意的是，当return和finally同时出现的时候许多小伙伴就在这绊倒了。下面我分享一下小伙伴可能会遇到的题目或情况。

首先finally语句应用在我们需要捕获异常的时候（说了句废话），finally语句的作用呢，相信小伙伴们都已经了如指掌，正是因为finally的特殊性，在做项目的时候也通常会将关闭数据库、释放资源等类似的代码放入其中。return是指结束该方法，继续执行方法后的语句。但是有些题目，就是那么刁钻，将return和finally放在一块，在考验我们对知识掌握的深度。

#### **Java的断言机制** ####

J2SE 1.4 在语言上提供了一个新特性，就是 assertion 功能，他是该版本在 Java 语言方面最大的革新。从理论上来说，通过 assertion 方式可以证明程序的正确性，但是这是一项相当复杂的工作，目前还没有太多的时间意义。

在实现中，assertion 就是在程序中的一条语句，它对一个 boolean 表达式进行检查，一个正确程序必须保证这个 boolean 表达式的值为 true；如果该值为 false，说明程序已经处于不正确的状态下，系统将给出警告或退出。

一般来说，assertion 用于保证程序最基本、关键的正确性。assertion 检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion 检查通常是关闭的。

编写代码时，我们总是会做出一些假设，断言就是用于在代码中捕捉这些假设。

程序员相信在程序中的某个特定点该表达式值为真，可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言而在部署时禁用断言。同样，程序投入运行后，最终用户在遇到问题时可以重新启用断言。

使用断言可以创建更稳定、品质更好且不易于出错的代码。当需要在一个值为 FALSE 时中断当前操作的话，可以使用断言。单元测试必须使用断言(Junit/JunitX)。

除了类型检查和单元测试外，断言还提供了一种确定各种特性是否在程序中得到维护的极好的方法。使用断言使我们向按契约式设计更近了一步。

断言主要使用在代码开发和测试时期，用于对某些关键数据的判断，如果这个关键数据不是你程序所预期的数据，程序就提出警告或退出。

简而言之，断言就是一个帮助程序员来简化入参检测代码的工具类

常见的断言特性：

前置条件断言：代码执行之前必须具备的特性。

后置条件断言：代码执行之后必须具备的特性。

前后不变断言：代码执行前后不能变化的特性。

断言使用格式：

断言可以有两种形式：

assert

assert :

使用第一种格式，当布尔类型表达式为 false 时，抛出 AssertionError 异常；如果是第二种格式，则输出错误消息。

何时需要使用断言：

可以在预计正常情况下程序不会到达的地方放置断言：assert false。

断言可以用于检查传递给私有方法的参数(对于公有方法，因为是提供给外部的接口，所以必须在方法中有相应的参数检验才能保证代码的健壮性)。

使用断言测试方法执行的前置条件和后置条件。

使用断言检查类的不变状态，确保任何情况下，某个变量的状态必须满足(如 age 属性应大于 0 小于某个合适值)。

什么地方不要使用断言：

断言语句不是永远会执行，可以屏蔽也可以启用，因此：

不要使用断言作为公共方法的参数检查，公共方法的参数永远都要执行。

断言语句不可以有任何边界效应，不要使用断言语句去修改变量和改变方法的返回值。

### **第十三章 字符串与日期** ###

#### **封装类** ####

1.1.每一个基本类型都有与之对应的对象（包装类型），所谓的面向对象编程！操作对象一定比操作基本类型简单因为对象提供了强大的功能供我们使用。

1.2.java一共有8种基本数据类型，分别为：byte、short、int、long、float、double、char、boolea。其对应的对象（包装类型）分别为：Byte、Short、Integer、Long、Float、Double、Character、Boolean。

基本类型-> 包装类 Integer.valueOf(int i)

包装类-> 基本类型 x.intValue()

基本类型 -> String String.valueOf(String s)

String ->基本类型 Integer.parseInt(Sting s)

包装类 ->String integer2.toString();

String -> 包装类 Integer.valueOf(s2);

#### **数字的格式化** ####

### **DecimalFormat** ###

1,是 **NumberFormat** 的**一个子类**，用于格式化**十进制**数字。

2，**DecimalFormat 类**包含**一个模式和一组符号**

#### **正则表达式** ####

用来描述或者匹配一系列符合某个语句规则的字符串

**单个符号**

1、英文句点.符号：匹配单个任意字符。

表达式t.o 可以匹配：tno，t\#o，teo等等。不可以匹配：tnno，to，Tno，t正o等。

2、中括号\[\]：只有方括号里面指定的字符才参与匹配，也只能匹配单个字符。

表达式：t\[abcd\]n 只可以匹配：tan，tbn，tcn，tdn。不可以匹配：thn，tabn，tn等。

3、| 符号。相当与“或”，可以匹配指定的字符，但是也只能选择其中一项进行匹配。

表达式：t(a|b|c|dd)n 只可以匹配：tan，tbn，tcn，tddn。不可以匹配taan，tn，tabcn等。

4、表示匹配次数的符号

表达式：\[0—9\]\{ 3 \} \\— \[0-9\]\{ 2 \} \\— \[0-9\]\{ 3 \} 的匹配格式为：999—99—999

因为—符号在正则表达式中有特殊的含义，它表示一个范围，所以在前面加转义字符\\。

5、^符号：表示否，如果用在方括号内，^表示不想匹配的字符。

表达式：\[^x\] 第一个字符不能是x

6、\\S符号：非空字符

7、\\s符号：空字符，只可以匹配一个空格、制表符、回车符、换页符，不可以匹配自己输入的多个空格。

8、\\r符号：空格符，与\\n、\\tab相同

**快捷符号**

1、\\d表示\[0—9\]

2、\\D表示\[^0—9\]

3、\\w表示\[0—9A—Z\_a—z\]

4、\\W表示\[^0—9A—Z\_a—z\]

5、\\s表示\[\\t\\n\\r\\f\]

6、\\S表示\[^\\t\\n\\r\\f\]

**常用的正则表达式**

1、Java：((\[a-z\]|\_)(\\\\w\*))\{6,20\}匹配以字母或下划线开头，字母数字下划线结尾的字符串

2、JavaScript：/^(\\-?)(\\d+)$/匹配数字

3、JavaScript：/^\\w+$/匹配字母数字下划线。

#### **日期** ####

yyyy-MM-dd HH:mm:ss.SSSSSS

y-年，M-月，d-日，H-24小时制(0-23)，h-12小时制(1-12)，m-分钟，s-秒，S-毫秒

java只能取到毫秒，微秒级别全是零，但是可以取出到微秒的这种格式化时间戳形式：

DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSSS");

LocalDateTime now = LocalDateTime.now();

System.out.println(now.format(dateTimeFormatter)); //2022-01-06 11:18:20.044000

### **第十四章 数组** ###

#### **数组的基本知识** ####

1、idea换背景色：File->Setimgs->Editer->Color Schame

2、Java语言中的数组是一种引用数据类型，不属于基本数据类型。数组的父类是object类

3、数组是一个容器，可以同时容纳多个元素（数组是一个数据的集合）

4、数组当中可以存储基本数据类型也可以存取引用数据类型

5、数组因为是引用数据类型，所以数组对象是堆内存当中（数组是存储在堆内存当中的）

6、数组在内存方法是怎样的

7、数组当中如果存储的是“Java对象”，实际上存储的是对象的引用（对象的内存地址），数组中不能直接存储Java对象

8、数组一旦创建，Java中规定长度不可变

9、数组的分类包括一维数组，二维数组及其多维数组

10、所有的数组对象都有length属性，用于获取数组中元素的个数

11、Java中数组要求数组元素类型统一，比如int类型数组只能存储int类型元素

12、数组在内存方面，存储的时候，存储元素的内存地址是连续的（存储的每一个元素都是有规则的），数组实际上是一种数据结构

13、数组中首元素的地址作为整个数组对象的地址

14、数组中每个元素都是有下标的，从0开始以1递增，最后一个元素下标为length-1

15、数组的优缺点

优点：查询、查找、检索某个下标上的元素时效率极高，可以说是查询效率最高一个数据结构（第一、每一个元素的内存地址是连续的；第二、每一个元素的类型相同，所以占用空间大小一样；第三、知道元素内存地址，知道下标，所以通过一个数学表达式可以计算出某个元素的内存地址，通过内存地址定位元素，所以数组的检索效率是最高的）

缺点：第一、由于为了保证数组中每个元素的存储是连续的，所以在数组上随机增加删除元素效率较低，因为随机增加删除元素涉及后面元素的移位（注意：对于数组中最后一个元素的增加删除是不受影响的）

第二、数组不能存储大数据量，因为很难在内存空间上找到一块大的连续的内存空间

16、如何声明、定义一个数组？

语法格式：int\[\] array1; double\[\]array2; String\[\]array2…..

17、怎么初始化一个一维数组

静态初始化一维数组：

int\[\] array =\{1,2,3\}

动态初始化一维数组：

int\[\] aray = new int\[5\] //这里的5表示数组的元素个数；初始化一个5个长度的int类型数组，每个元素默认值0

String\[\] array = new String\[5\]// 初始化一个5个长度的String类型数组，每个元素默认值null

18、当一个方法的参数是一个数组

Public class ArrayTest\{

Public static void main(String\[\] args)\{

int\[\] a = \{1,2,3\};//静态初始化一维数组

printArray(a);

int\[\] a2 =new int\[4\]; //动态初始化一维数组

printArray(a2);

printArray(new int\[3\]);//这样也可以

printArray(new int\[\]\{1,2,3\});//如果直接传递一个静态数组语法应该这样写

//为什么使用静态方法：方便不需要你new对象

public static void printArray(int\[\] array)\{

for(int I = 0;i<array.length;i++)\{

System.out.println(array\[i\])；

19、main方法中的一维数组有什么用（JVM调用main方法的时候会自动传递一个String数组过来）

注意：args.length = 0 //默认长度为0（空数组）

20、对于数组来说，实际上只能存储Java对象的“内存地址”数据中存储的每个元素是“引用”

21、一维数组扩容

（1）在Java中数组一旦确定，长度不可变

（2）Java中对数组的扩容：新建一个大容量的数组，然后将小容量数组的数据一个一个拷贝到大数组中（数组扩容效率较低）

（3）调用System.arraycopy(五个参数)进行数组拷贝

public class ArrayTest\{

public static void main(String\[\] args)\{

int\[\] src = \{1,2,3,4,5\};

int\[\] dest = new int\[20\];

System.arraycopy(src,1, dest,3,3);//(源，源的起始位置，目标，目标的起始地址，拷贝长度)

#### **数组的复制** ####

1.  Arrays 类的 copyOf() 方法
2.  Arrays 类的 copyOfRange() 方法
3.  System 类的 arraycopy() 方法
4.  Object 类的 clone() 方法

#### **数组的排序** ####

**1、使用Arrays.sort()排序**

Arrays.sort()排序方法在java中是最简单且最常用的排序方法。int \[\]arr1= \{45,34,59,55\};

Arrays.sort(arr1);//调用方法排序即可

Arrays.sort()的使用主要分为对基本数据类型数组的排序和对对象数组的排序。

**2、冒泡排序**

简单来说，冒泡排序就是重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。//array\[\]为待排序数组，n为数组长度

void BubbleSort(int array\[\], int n)

int i, j, k;

for(i=0; i

for(j=0; j

if(array\[j\]>array\[j+1\])

k=array\[j\];

array\[j\]=array\[j+1\];

array\[j+1\]=k;

**3、选择排序**

先找到最小元素所在位置的索引，然后将该元素与第一位上的元素进行交换。int arr3\[\]= \{23,12,48,56,45\};

for(int i=0;i

int tem=i;

//将数组中从i开始的最小的元素所在位置的索引赋值给tem

for(int j=i;j

if(arr3\[j\]

tem=j;

//上面获取了数组中从i开始的最小值的位置索引为tem，利用该索引将第i位上的元素与其进行交换

int temp1=arr3\[i\];

arr3\[i\]=arr3\[tem\];

arr3\[tem\]=temp1;

**4、反转排序**

将原数组按逆序排列//将数组第i位上的元素与第arr.length-i-1位上的元素进行交换

int \[\]arr4=\{23,12,48,56,45\};

for(int i=0;i

int tp=arr4\[i\];

arr4\[i\]=arr4\[arr4.length-i-1\];

arr4\[arr4.length-i-1\]=tp;

**5、直接插入排序**int \[\]arr5=\{23,12,48,56,45\};

for (int i = 1; i < arr5.length; i++) \{

for (int j = i; j > 0; j--) \{

if (arr5\[j - 1\] > arr5\[j\]) \{//大的放后面

int tmp = arr5\[j - 1\];

arr5\[j - 1\] = arr5\[j\];

arr5\[j\] = tmp;

#### **数组的查找** ####

**普通查找**

对数组循环[遍历][Link 14]，依次比较匹配，时查找算法中最基础，最简单的算法

**二分法查找**

与插入排序算法类似，它作用对象的前提是一个有序数组

先设立最小值角标、最大值角标以及中间值角标。从最中间值开始比较，若比较值比查找值大，则在剩下数列的左半轴重新划分最大值、最小值以及中间值，再进行比较查找；否则在右半轴进行相关操作；若不存在该值，最后会使得min<max，退出循环

#### **Arrays类** ####

*  Arrays位于java.util包下(Arrays是一个操作数组的工具类)
 *  Arrays包含各种操作数组的方法(例如排序和搜索)。该类还包含一个静态工厂，允许将数组视为列表。
 *  Arrays类里的方法都是静态方法可以通过Arrays.方法名()直接调用

*   **集合**

#### **集合类概述** ####

集合类是Java数据结构的实现。Java的集合类是java.util包中的重要内容，它允许以各种方式将元素分组，并定义了各种使这些元素更容易操作的方法。Java集合类是Java将一些基本的和使用频率极高的基础类进行封装和增强后再以一个类的形式提供。集合类是可以往里面保存多个对象的类，存放的是对象，不同的集合类有不同的功能和特点，适合不同的场合，用以解决一些实际问题。百度百科

集合是一个容器，是一个载体，可以一次容纳多个对象。数组其实就是一个集合，集合实际上就是一个容器。

在实际开发中，假设链接数据库，数据库中有10条记录，那么假设把十条记录查询出来，这时java程序会把十条数据封装成10个java对象，然后将Java对象放到一个集合中，将集合传到前端，然后遍历集合，将数据一个个展现出来。

集合不能直接存储基本数据类型，另外集合也不能直接存储Java对象，集合里面存储Java对象的内存地址(集合中存储的是引用)。【注意】 list.add(100)//这里存的不是基本数据类型int，自动装箱-->Integer

在Java中每一个不同的集合，底层对应有不同的数据结构， 往不同的集合中存储元素，等于将数据放到不同的数据结构中。使用不同的集合，等同于使用了不同的数据结构。不需要精通数据结构，Java中已经写好了常用的集合类，只需要掌握如何使用就好。在合适的情况，选择合适的集合。

所有集合类和集合接口都在java.until包下。

#### **Collection接口** ####

**1、Collection接口包括的主要方法**：

添加元素：add(E),addAll()

删除元素：remove(Object),removeAll,removeIf,clear

是否包含元素：contains(Object)

获取元素个数：size

是否为空集合：isEmpty

遍历所有元素：iterator()

转换为数组：toArray,toArray(T\[\])

**1）添加元素**：

public boolean add(E object);

public boolean addAll(Collection<? extends E>collection);

（add方法可以添加单个指定的元素，而addAll是把参数collection中的所有元素批量添加到当前Collection结构中。）

**2）删除元素**：

public boolean remove(Object object);

public boolean removeAll(Collection<?>collection);

public boolean retainAll(Collection<?>collection);

（remove用于删除单个指定对象；removeAll用于删除参数collection中的所有元素；retainAll仅保留参数collection中的所有元素，不在参数collection中的元素都删除。）

public void clear（）；//快速删除所有元素，调用此方法后Collection集合是空集

**3）查询：**

（1）查询元素：（如果包含，contains方法返回true,否则返回false）

public boolean contains(Object object);

（2）查询集合：（size方法返回Collection中元素的数量，isEmpty方法判断Collection是否为空）

public int size（）；

public boolean isEmpty（）；

4）遍历元素：（Collection本身不提供对元素的遍历方法，元素的遍历由Iterator完成）

public Iterator<E> iterator();

注:该方法返回一个Iterator类型的对象，使用该对象对原有的Collection进行元素的遍历。

5）转换数组：

public Object\[\] toArray();//转换为Object类型的数组

public <T> T\[\] toArray(T\[\] array);//转换为元素类型为T的数组

**2、Collection接口的定义**：

public interface Collection<E> extends Iterable<E>

注：Collection继承了接口Iterable,Iterable是Collection接口的父类

**3、Iterable接口的定义方法**：

（通过该方法可以获得一个Iterable类型的对象，一般称为迭代器，主要用于遍历当前集合中的元素）

Iterable<T> iterable();

**4、Iterable是Java集合类中的一个重要接口，Iterable接口不用于存储元素，而用来遍历已有集合中的元素。例如List、Set和Map等。（于Set而言，Iterable是遍历其中元素的唯一途径）**

**5、在Collection的子接口中，List中的元素有位置（即index），而Set中的元素没有位置和顺序。**

注：Collection接口中的元素没有位置的概念，所以Collection接口不包含获得指定元素下标的方法。

#### **Llist集合** ####

~List有序集合也称为序列。该界面的用户可以精确的控制列表中每个元素的插入位置。用户可以通过整数索引访问元素。并搜索列表中的元素。

~与Set集合不同，列表通常允许重复元素。

List集合特点：

有序：存储和取出的元素顺序一致；

可重复：存储的元素可以重复。

#### **Set集合** ####

(1)Set集合是由一串无序的，不能重复得相同类型元素构成的集合。以下是一个班级的Set集合，这个Set集合中有一些学生，这些学生是无序的，不能通过类似于List集合的序号访问。而且不能有重复的同学。

(2)提示：List集合中的元素是有序的，可重复的，而Set集合中的元素是无序的。不能重复得，List集合强调的是有序的，Set集合强调的是不重复，当不考虑顺序，且没有重 复元素时，Set集合和List集合可以互相替换的。

(3)Set接口直接实现类主要是HashSet,HashSet是基于散列表数据结构的实现

#### **Map集合** ####

1.Map是一个双列[集合][Link 15]，一个元素包含两个值（一个key，一个value）

2.Map集合中的元素，key和value的数据类型可以相同，也可以不同

3.Map中的元素，key不允许重复，value可以重复

4.Map里的key和value是一一对应的。

#### **迭代器** ####

迭代器是用来遍历容器内所有元素对象的，也是一种常见的设计模式。

迭代器包含以下四个方法：

hasNext() :boolean —— 容器内是否还有可以访问的元素。

next() :E —— 返回下一个元素。

remove() :void —— 删除当前元素。

forEachRemaining(Consumer) :void —— JDK 8 中添加的，提供一个 lambda 表达式遍历容器元素。

#### **泛型** ####

*  泛型的本质就是"参数化类型"。一提到参数，最熟悉的就是定义方法的时候需要形参，调用方法的时候，需要传递实参。那"参数化类型"就是将原来具体的类型参数化
 *  泛型的出现避免了强转的操作，在编译器完成类型转化，也就避免了运行的错误。

[Java]: https://baike.baidu.com/item/Java/85979?fromModule=lemma_inlink
[Link 1]: https://baike.baidu.com/item/%E8%BD%AF%E4%BB%B6%E5%BC%80%E5%8F%91%E5%B7%A5%E5%85%B7%E5%8C%85/10418833?fromModule=lemma_inlink
[Link 2]: https://baike.baidu.com/item/%E7%A7%BB%E5%8A%A8%E8%AE%BE%E5%A4%87/9157757?fromModule=lemma_inlink
[Link 3]: https://baike.baidu.com/item/%E5%B5%8C%E5%85%A5%E5%BC%8F%E8%AE%BE%E5%A4%87/10055189?fromModule=lemma_inlink
[Sun Microsystems]: https://baike.baidu.com/item/Sun%20Microsystems?fromModule=lemma_inlink
[Java 1]: https://baike.baidu.com/item/Java%E5%B9%B3%E5%8F%B0?fromModule=lemma_inlink
[Link 4]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E4%B8%AD%E5%BF%83/967340?fromModule=lemma_inlink
[Link 5]: https://baike.baidu.com/item/%E8%B6%85%E7%BA%A7%E8%AE%A1%E7%AE%97%E6%9C%BA/5373711?fromModule=lemma_inlink
[Link 6]: https://baike.baidu.com/item/%E5%B8%B8%E9%87%8F/10232375?fromModule=lemma_inlink
[Link 7]: https://baike.baidu.com/item/%E5%85%B3%E9%94%AE%E5%AD%97?fromModule=lemma_inlink
[Link 8]: https://baike.baidu.com/item/%E5%B8%B8%E9%87%8F?fromModule=lemma_inlink
[Link 9]: https://baike.baidu.com/item/%E5%AD%97%E7%AC%A6?fromModule=lemma_inlink
[Link 10]: https://baike.baidu.com/item/%E5%88%86%E9%9A%94%E7%AC%A6?fromModule=lemma_inlink
[private]: https://so.csdn.net/so/search?q=private&spm=1001.2101.3001.7020
[Link 11]: https://so.csdn.net/so/search?q=%E8%A1%A8%E8%BE%BE%E5%BC%8F&spm=1001.2101.3001.7020
[Link 12]: https://so.csdn.net/so/search?q=%E6%9E%84%E9%80%A0%E6%96%B9%E6%B3%95&spm=1001.2101.3001.7020
[static]: https://so.csdn.net/so/search?q=static&spm=1001.2101.3001.7020
[Link 13]: https://so.csdn.net/so/search?q=%E6%95%B0%E7%BB%84&spm=1001.2101.3001.7020
[Link 14]: https://so.csdn.net/so/search?q=%E9%81%8D%E5%8E%86&spm=1001.2101.3001.7020
[Link 15]: https://so.csdn.net/so/search?q=%E9%9B%86%E5%90%88&spm=1001.2101.3001.7020