# 1.初识Java
### 什么是java
1995年由詹姆斯高斯林开发出一门面向对象编程语言
### Java SE 标准版
是各种应用平台的基础，主要应用于桌面开发和低端商务应用的解决方案。
### Java EE 企业版
以企业为环境开发应用程序的解决方案，这个版本以前称为J2EE。
### Java ME 微型版
为在移动设备和嵌入式设备上运行的应用程序提供一个健壮且灵活的环境。
### JDK（Java Development Kits）即Java开发工具箱，JDK主要部分
JRE（Java Runtime Environment，Java运行时环境）
JVM（Java Virtual Machine，Java虚拟机）主要作用是进行Java程序的运行和维护。
Java API（Application Programming Interface）主要作用是为编程人员提供已经写好的功能， 便于快速开发。
Java 编译器（javac.exe）、Java运行时解释器（java.exe）、Java文档化工具（javadoc.exe）及其他工具和资源。
### 如何编译.java文件
打开cmd--->切换到文件目录输入Javac xxx.java
### 如何运行.class文件
打开cmd --->切换到文件目录输入Java xxx
### 1.注释
Java中的注释一共有三种，分别为单行注释，多行注释，文档注释
# 2.变量与数据类型
### 1.标识符与变量
变量：变量是一个容器，是内容一个数据存储空间的表示，变量表示的值是可以随着业务的变化而变化的。
### 变量的组成
1. 变量名
2. 变量类型
3. 变量值
4. 变量的表示方式：变量类型 变量名 = 变量值；
### java变量命名规则
字：字母（大小写）
下：下划线
美：美元符 $
人：人民币符号 ￥
数：数字0~9
骆驼：驼峰命名法 e.g schoolAddress addressOfSchool
2、变量命名需要注意的事项：
变量名不能用数字开头
变量名用字下美人数组成
只有类名往往用大写字母开头
3.不能和java关键字冲突
### javac常用数据类型
| 数据类型 | 大小 | 取值范围 |
| -------- | --------------- | ------------------------------------------- |
| byte | 1字节8位 | -128 ~ +127 |
| int | 4字节32位 | -2147483648（-231） ~ + 2147483647（231-1） |
| short | 2字节16位 | -32768 （-215） ~ + 32767 （+215-1） |
| long | 8字节64位 | -263 ~ + 263-1 |
| float | 4字节32位浮点数 | 1.4E-45 ~ 3.4E+38 , -1.4E-45 ~ -3.4E+38 |
| double | 8字节64位浮点数 | 4.9E-324 ~ 1.7E+308, -4.9E-324 ~ -1.7E+308 |
| char | / | / |
| boolean | / | / |
###
### 常量
关键修饰字：final
推荐写法
1. 通常大写
2. 不同字符用下划线分割
3. 只能被赋值一次，通常与static关键字联用
### 使用Scanner
```java
import java.util.*;//导包
Scanner input = new Scanner(System.in);//创建对象
int now = input.nextInt();//使用
```
### 自动类型转换
```java
double firstAvg = 81.29; //第一次平均分
double secondAvg; //第二次平均分
int rise = 2;
secondAvg = firstAvg + rise;
System.out.println("第二次平均分是：" + secondAvg);
```
如果一个操作数为double型，则整个表达式可提升为double型
两种类型要兼容
数值类型（整型和浮点型）互相兼容
目标类型大于源类型：
例如：double 型大于 int 型
### 强制类型转换
```java
int b = (int)10.2;
double a = 10;
int c = (int)a;
```
## 运算符：
1：赋值运算符
变量名 = 变量值;
变量值可以是一个表达式的结果：如两个数的和
2：算术运算符
基本的算术运算：+、-、*、/、%、++、--
复合算术运算符：+=、-=、*=、/=、%=
3：关系运算符
4：逻辑运算符
5：三元运算符/三目运算符/条件运算符
注意：三元运算符的结果需要一个变量来接受
# 3.选择结构
## 1. **基本if选择结构**
```
### if ( 条件 ) {**
### **//代码块**
### **}
```
## 2. **if-else选择结构**
```
### if ( 条件 ) {**
### **//代码块1**
### **}else {**
### **//代码块2**
### **}
```
## 3. **多重if选择结构**
```
### if ( 成绩>=80) {**
### **//代码块1**
### **}** **else if (成绩>=60) {**
### **//代码块2**
### }else {
### **//代码块3**
### **}
```
## 4.嵌套if选择结构
```
### if（条件1) {**
### **if（条件2) {**
### **代码块1**
### **} else {**
#### **代码块2**
### **}**
### **} else {**
### **代码块3**
### **}
```
## 5. **switch选择结构**
```
### switch (表达式) {
### case 常量 1:
### 语句;
### break;
### case 常量 2:
### 语句;
### break;
### …
### default:
### 语句;
```
## 6. **switch与多重if的相同点与不同点**
### 1. **相同点**
1.都是用来处理分支条件的结构
### 2. **不同点**
1.switch只能处理等值条件判断
# 4.循环结构
### 常用的循环结构有三大类：
### While循环， do-while循环，for循环。
### 在java5中引入一种主要用于数组和对象的增强型for循环，又称foreach循环。
## 1. **基础while循环结构**
```
## while ( 循环条件 ) {**
## **//****循环操作**
## **}
```
## 2. **doWhile循环结构**
```
## do {**
## **//****循环操作**
## **}while ( 循环条件 );
```
## 3. **doWhile与while的区别**
### **先执行再判断和先判断再执行**
## 4. **for循环结构**
```
## for(int i=0;i<100;i++){**
## **//循环操作**
## **}
```
## 5. **循环注意点**
### **注意死循环**
## 6. **循环总结**
## 7. **什么是多重循环**
### **一个循环体内又包含着另外一个循环结构，外层变化一次，内层变化一遍**
### ***\*语法：\****
```
### for(变量 i； 循环条件；跟新变量)\{ // 外层循环
### //循环操作1
### for(变量 j； 循环条件；跟新变量)\{ // 内层循环
### //循环操作2
### ｝
### ｝
```
## 8. **break语句作用**
### **跳出循环**
## 9. **continue语句作用**
### **进行下一次循环**
## **常用的调试说明**
可以在程序中打断点进行调试：说明如下
在程序中双击，做个断点，budeg启动程序进入调试模式
***\*说明：\****
1表示当前继续执行代码（放行），直到遇到下一个断点，快捷键F8（resume），
2表示停止调试（terminate），
3表示进入当前方法内部，一步一步执行，快捷键F5（step into），
4表示运行下一行代码（下一步），执行当前行,但不进入执行细节，快捷键F6（step over），
5表示退出当前方法，返回到调用层，快捷键为F7（step return）
***\*另外调试中鼠标移到代码编辑窗口，放在变量上时会显示当前变量的值\****。
***\*注意：必须debug模式下的启动才会进入debug调试视图，否则断点无效\****
***\*取消断点方式：\****
***\*1：直接双击断点，可以取消\****
***\*2：在debug视图可以取消所有的断点，如下图：\****
# 5.一维数组
## **1：数组是什么**
数组是一个容器，可以用来存储相同数据类型的一组数据。
特点：
1：数组是有长度的；长度：这个数组可以存储几个值。长度从1开始；
2：数组是有下标的；下标：用来操作存取数组中的值，表示数组中元素的位置。下标从0开始；最大值都是长度-1
## 2. **数组基本的要素**
### 1. **标识符**
### 2. **数组元素**
### 3. **元素下标**
### 4. **元素类型**
## 3. **如何使用数组**
### 1. **声明数组**
数据类型 数组名[ ] ;
数据类型[ ] 数组名 ;
声明数组时不规定长度
## 2. **分配空间**
数据类型[ ] 数组名 = new 数据类型[大小] ;
### 3. **赋值**
数组名[下标]=xx;
边声明边赋值
例如：
```
int[ ] scores = {89, 79, 76};
```
循环赋值
```
for(int i = 0; i < xx; i ++){
数组名[i] = i;
}
```
# 6.二维数组
## 1. **二维数组声明**
### **<数据类型> [ ][ ] 数组名; 或者 <数据类型> 数组名 [ ][ ];**
## 2. **二维数组赋值**
### **1.int[][] scores=new int[][]{ { 90, 85, 92, 78, 54 }, { 76, 63,80 }};**
### **2.int scores[][] = {{ 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } };**
# 7.类和对象
## **1：理解对象的属性和方法**
***\*对象：用来描述客观事物的一个实体，由一组属性（静态特征）和方法（动态特征）构成；\****
***\*属性：用来描述对象的固有特征，一般是名词；\****
***\*方法：用来描述对象的动作，这个对象能干嘛，一般是动词；\****
## 2.类和对象的关系
***\*类是抽象的，对象是具体的\****
***\*类是具有相同属性和行为（方法）的对象的集合\****
***\*对象是类的一个实例，是一个具体的实体。\****
## **3：创建类和对象**
***\*使用java实现类和对象的关系\****
1：创建一个类（属性和方法）
2：通过这个类创建对象
3：使用对象名调用属性和方法，对象名.属性名 ， 对象名.方法名（）；
## **4：使用对象**
## 5.方法
***\*方法五要素：\*******\*修饰符，返回值类型，方法名，参数列表，方法体。\****
****
方法中返回值介绍：
***\*如果方法有返回值，方法中必须使用关键字return返回某个值，返回值类型为该值的类型，且返回值只能有一个。\****
***\*return的作用：结束方法，返回结果。\****
***\*注意：当调用有返回值的方法时，需要定义一个变量接受\****
***\*如果方法没有返回值，返回值类型为void\****
## **5.2：方法的调用**
问：如何调用一个类的方法？
明确：你要调用哪个类的哪个方法？
1：创建这个类的对象
2：对象名.方法名（）；
## **5.3：方法间的调用**
方法之间允许相互调用，不需要知道方法的具体实现，实现重用，提高效率
| **情况** | **举例** |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| **Student****类的方法a( )调用Student类的方法b( )，直接调用** | **public void** **a( ) {** b( ); //调用b( )} |
| **Student类的方法a( )调用Teacher类的方法b( )，先创建类对象，然后使用“.”调用** | **public void** **a( ) {** **Teacher t =** **new** **Teacher( );** **t.b( ); //调用Teacher类的b()} |
### 定义类的方法
#### 语法
```
public 返回值类型 方法名() {
//这里编写方法的主体
}
```
#### 举例
```java
public void show(){
System.out.println("姓名：" + name + "，密码：" + password);
}
```
#### 有返回值
```java
public String getName(){
return name;//return 只能有一个
}
```
#### 无返回值
```java
public void show(){
System.out.println("姓名：" + name + "，密码：" + password);
}
```
## 构造方法
/
```
/学生类
public class Student {
//属性
String name;
int age;
String sex;
```
### //***\*系统默认的无参构造方法，写和不写他都是存在的\****
```
public Student() {
}
//有参构造方法,创建对象的时候就已经给了初始值了
public Student(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
｝
```
## ***\*作用\****：创建对象，初始化对象
### ***\*特点：\****
1、无参构造方法，与类同名，不含返回类型。如果类中没有显示的构造方法，系统会给出默认的无参构造方法。
2、构造方法一般都是public的，才能被系统调用。
3、无参构造在给对象属性赋值时比较麻烦，可以定义有参的构造方法。
当成员变量（属性）和方法参数同名时，一般使用this表示当前对象，如：this.name = name;
4、构造方法经常用于程序初始化工作，例如：人出生要“洗澡”，就可以在人的构造方法时加入完成“洗澡”的程序代码，程序就不必每个人出时一个一个地告诉他们要“洗澡”了。
5、当类有了带参构造方法之后，系统不再自动生成默认的无参构造方法，若使用需重新定义
要求：如果一个类中有带参数的构造方法时，必须要定义无参的构造方法
6、构造方法只能用于创建对象时，不能在程序中像调用其他方法一样调用它，但是可以用this()的形式在其他构造方法中调用它，注意this()必须在第一行。
### ***\*构造方法和普通方法的区别： - 记住，至少4条\****
构造方法访问修饰符一般是public, 一般方法根据实际情况选择修饰符
构造方法没有返回值类型，一般方法要么无返回值-void，要么有返回值
方法名与类同名，一般方法见名思意，遵循驼峰命名规则
构造方法的方法体是对象的初始化代码，一般方法是功能的实现
调用方式不一致，普通方法需要使用对象来调用，构造方法是new, this, super
# **方法重载：overload**
### 为什么会有方法的重载？
在同一个类中有一些方法的功能相同，仅仅是参数列表不一样，此时如果去定义不同的方法名很麻烦。
于是规定，方法名可以一样，但是参数列表必须不一样。所以就有了方法的重载。
#### ***\*方法重载\*******\*的判断标准：同类同名不同参，与其他无关。（不同参：不同的参数列表：个数不同，类型不同，顺序不同）\****
# **成员变量与局部变量 - 记住 ：至少4条**
***\*成员变量\****是属于类的变量，其实就是类中的***\*属性\****，类中的每一个方法都可以共享；
***\*局部变量就是定义在某个方法中的变量\****，只能在定义的方法中访问，其他的方法不能共享；
成员变量和局部变量区别：
***\*1：定义位置不同\****
成员变量：定义在类中的变量，属于类
局部变量：定义在方法中的变量，属于方法
***\*2：作用域不同\****
成员变量：属于类，类中的每一个方法都可以使用
局部变量：属于方法，只能在某一个方法中使用
***\*3：初始值不同\****
成员变量：有默认的初始值,在加载类的时候，就会给成员变量赋值（默认值)
局部变量：没有初始值，必须初始化之后才可以使用
***\*4：生命周期不同\****
成员变量：属于类，随着对象的创建而创建，随对象的消失而消失- 垃圾回收器
局部变量：属于方法，随着方法的调用而创建
***\*5：优先级不同：\****
1：在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级
2：在方法的参数列表中的参数，也是局部变量
# 8.封装
### 什么是封装
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
### 封装的原则
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
### 实现封装
1. 修改属性的可见性
2. 创建getter setter方法
3. 在getter setter方法中创建属性控制语句
### 封装好处
便于使用者正确使用系统，防止错误修改属性
有助于系统之间的松耦合，提高系统独立性
提高软件的可重用性
降低了构建大型系统的风险
### 包的作用
- 允许类组成较小的单元（类似
文件夹），易于找到和使用相
应的文件
- 防止命名冲突
区分名字相同的类
- 有助于实施访问权限控制
### 包的命名规范
包名由小写字母组成，不能以圆点开头或结尾
包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
包名后续部分依不同机构内部的规范不同而不同
### 访问修饰符
| **作用域****修饰符** | **同一个类中** | **同一个包中** | **子类中** | **任何地方** |
| -------------------- | -------------- | -------------- | ---------- | ------------ |
| **private** | **可以** | **不可以** | **不可以** | **不可以** |
| **默认修饰符** | **可以** | **可以** | **不可以** | **不可以** |
| **protected** | **可以** | **可以** | **可以** | **不可以** |
| **public** | **可以** | **可以** | **可以** | **可以** |
### static关键字
#### 成员变量
静态变量，可以直接通过类名访问
#### 成员方法
静态方法，可以直接通过类名访问
#### 代码块
静态代码块，当Java虚拟机加载类时，就会执行该代码块
JVM加载类时，加载静态代码块
如果有多个静态块，按顺序加载
每个静态代码块只会被执行一次
***\*按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫\****[***\*静态变量\****](https://www.baidu.com/s?wd=静态变量&tn=SE_PcZhidaonwhc_ngpagmjz&rsv_dl=gh_pc_zhidao)***\*或类变量；\****
***\*另一种是没有被static修饰的变量，叫实例变量。实例变量必须通过对象来调用。\****
### 静态变量特点：
1、被static修饰的变量静态变量，非静态变量叫实例变量
2、***\*在内存中只有一个，在加载类的时候创建，被所有方法和对象共享\****
3、其他类中，可以直接通过类名访问（可以通过类名直接调用）
#### 初始化：
静态变量在创建对象之前会被加载
实例变量，随着对象的创建被创建
注意：在静态资源内部不能直接调用非静态的资源（属性和方法）
规定：静态调用静态，非静态调用非静态。
# 9.继承
## **1.什么是继承**
继承顾名思义，继任，承接，传承的意思
## 2.**继承中的术语和注意事项**
1、类：类是具有共同属性和行为的一组对象。它是创建对象的模板或蓝图。
2、子类：子类是继承其他类的类。它也称为派生类，扩展类或子类。
3、超类/父类：超类是子类继承功能的类。它也称为基类或父类。-通用的属性和方法
4、可重用性：正如名称所指定的那样，可重用性是一种机制，可以帮助您在创建新类时重用现有类的属性和方法。
5、***\*Java中类只支持单继承，即一个类只能有一个\*******\*直接父类\****
****
## **3：使用继承**
1、编写父类，创建公共的属性和方法
2、编写子类使用***\*extends\****继承父类
3、编写子类中特有的属性和方法
#### ***\*注意：\****
**1、*****\*super关键字代表父类，只能出现在子类的方法和构造方法中\****
2、在子类构造方法中使用super调用父类***\*构造方法，必须位于第一句；\****
3、子类不可以直接访问父类中定义为private的属性和方法 - private的东西是不能被继承的。
## **4.什么时候使用继承**
符合 ***\*is a\**** 关系的设计时，可以考虑使用继承。
小狗是一个宠物，小猫是一个宠物
## **5：继承的优点**
将子类共有的属性和方法抽取到父类中,减少重复代码，实现代码的重用·
# 10.多态
## **方法的重写：overriding**
***\*使用：当父类中的方法不能满足子类的需要\****。
方法的重写又称方法的覆盖，一般用于子类根据需要可以对父类中的方法进行***\*重新编写\****
***\*重写的前提是：必须在继承体系下，也就是必须存在继承关系\****
重载的前提是：同一个类中
## 1：方法重写的原则
1、方法名必须相同
2、参数列表必须相同
3、返回值类型相同或者是其子类
4、访问权限相同或不能严于父类
5、父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法
子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super)
6、父类的私有方法不能被子类覆盖
7、不能抛出比父类方法更多的异常
***\*注意：\****
1、一般不会去改变返回值和访问权限
2、父类的私有方法不能被重写，重写的是可以被继承的方法
3、一般情况下，***\*重写都是会存在一模一样的方法仅仅是方法体不一样。\****
4、只能重写继承来的方法
## **2：方法重写和重载的区别**
重载：同类同名不同参，与其他无关（同一个类中，方法名，参数列表不同--个数不同，类型不同，顺序不同）
重写：在子类和父类中存在，同名同参同返回值同访问修饰符的方法（返回值可以是其子类，访问修饰符不能比父类更严格）
***\*简单来说就是一模一样。\****
## **3.object介绍**
Object类是所有类的父类；
Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
## **4.什么是多态**
所谓多态，***\*就是指一个引用变量在不同的情况下的多种表现状态\****。也可以理解为，***\*多态是指通过指向父类的引用变量，来调用在不同子类中实现的方法。\****
## **5.多态的运用**
一般用于继承体系下，***\*子类重写父类的某个方法，调用时根据具体的子类实现去调用子类的方法\****
## **3：抽象方法介绍**
如果父类中有一个方法，每一个子类都有不同的实现，此时可以将这个方法声明为抽象方法，抽象方法是没有方法体的，只是一种规范。
### 什么是抽象方法：被abstract修饰的方法，就是抽象方法。
## ***\*特征：\****
1：抽象方法没有方法体，只有方法的声明；
2：如果一个类中存在抽象方法，那么这个类必须声明为抽象类；abstact修饰的类,抽象类不能创建对象
3：抽象类不能被实例化；
4：抽象方法必须在子类中被重写，除非子类也是抽象类；
如：
```
// 抽象类
public abstract class Pet｛
//抽象方法
public abstract void toHospital();
｝
```
## 向上转型 - 自动类型转换
#### 把子类对象直接赋给父类引用叫向上转型，向上转型不用强制转换。
##### <父类型> <引用变量名> = new <子类型>();
如：
```
Pet p = new Dog();
```
***\*注意：\****
1、此时通过父类引用变量调用的方法是子类重写或继承父类的方法
2、此时通过父类引用变量无法调用子类特有的方法
## 向下转型 - 强制类型转换
#### 向上转型只能使用子类重写的一些方法，和从父类中继承的一些方法，如何使用自己独有的一些方法呢？可以使用向下转型。
#### 向下转型需要使用强制类型转换，调用子类特有的方法；
#### 语法：
##### <子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
如：
Dog dog=(Dog)pet;//将pet 转换为Dog类型
dog.method();//执行Dog特有的方法
在进行向下转型的时候，非常容易发生类型转换异常，
***\*ClassCastException\**** --- ***\*类型转换异常\****
***\*instanceof用于判断一个引用类型所引用的对象是否是一个类的实例\****
# 11.接口和抽象类
# **接口**
## **1：什么是接口**
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，***\*是抽象方法的集合\*******\*（接口中的所有的方法都是抽象方法）\*******\*，接口通常以interface来声明\****。
接口是一个特殊的类，这个类中只能存值抽象方法，为了和普通的类去做区分，同时弥补java单继承的缺陷，把这个特殊的类叫***\*接口，使用*interface*声明接口
一个类通过实现接口的方式，从而来实现接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
## 2：接口的声明
声明接口的语法：
```
public interface MyInterface {
public abstract void eat(); // 接口中的所有方法都是抽象方法；
void run(); // 可以省略前面的修饰
}
```
## **3：接口的特点**
1、接口不能用于实例化对象。
2、接口没有构造方法。
3、接口中所有的方法必须是抽象方法。默认为：public abstract
4、接口不能包含成员变量，除了 public static final 常量。
5、接口不是被类继承了，而是要被类实现。实现使用关键字：implements
6、接口支持多实现。
7、一个类可以继承一个类的同时实现多个接口。
## **4.使用接口**
使用接口的步骤：
1、创建接口，声明方法
2、创建类，实现接口，实现接口中的方法
3、使用实现后的方法执行具体的操作
## **5.接口与抽象类的区别**
1、抽象类使用关键字abstract class修饰，接口使用关键字interface；
2、抽象类使用关键字extends实现继承，接口使用implements来实现
3、抽象类中可以包含抽象方法和普通方法，接口中只能有抽象方法（1.7）；
4、抽象类可以有构造方法，接口中不能有构造方法；
5、抽象类可以有成员变量，接口中只能有常量；
6、抽象类只能单继承，接口可以多继承；
7、抽象类里面的方法可以是public,protect,private，接口的方法只能是public；
# 12.异常
## **1：什么是异常**
### 程序运行时***\*，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常\****
#### 常见的异常有：先记5个
算术异常：ArithmeticExecption
空指针异常：NullPointerException
数组下标越界异常：ArrayIndexOutOfBoundsException
类型转换异常：ClassCastException
数组负下标异常：NegativeArrayException
字符串转换为数字异常：NumberFormatException
输入类型不匹配：inputMisMatchException
## **2：异常处理**
### **1：什么是异常处理**
异常发生时，是任程序自生自灭，立刻退出终止，还是输出错误给用户？
##### Java提供了更加优秀的解决办法：***\*异常处理机制- 捕获异常，抛出异常\****
异常处理机制能让程序在异常发生时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。
在java应用中，***\*异常的处理机制分为\*******\*抛出异常\*******\*和\*******\*捕获异常\*******\*。\****
捕获异常： ***\*try , catch , finally\****
抛出异常：***\*throw, throws\****
### Java中涉及到的异常关键字有哪些？ - 记住
#### **异常关键字**
Java的异常处理是通过5个关键字来实现的：
***\*try、catch、 finally、捕获异常\****
***\*throw、throws、 抛出异常\****
## **异常的分类**
##### Java标准库内建了一些通用的异常，这些类以Throwable为顶层父类。Throwable又派生出Error类和Exception类。
错误：Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。
异常：Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。
#### Exception这种异常又分为两类：运行时异常和编译异常。
1、运行时异常(不受检异常)：RuntimeException类极其子类表示JVM在运行期间可能出现的错误。比如说试图使用空值对象的引用（NullPointerException）、数组下标越界（ArrayIndexOutBoundException）。此类异常属于不可查异常，一般是由程序逻辑错误引起的，在程序中可以选择捕获处理，也可以不处理。
2、编译时异常(受检异常)：Exception中除RuntimeException极其子类之外的异常。如果程序中出现此类异常，必须对该异常进行处理，否则编译不通过。在程序中，通常不会自定义该类异常，而是直接使用系统提供的异常类。
## **捕获异常**
在java应用中，异常的处理机制分为抛出异常和捕获异常。
捕获异常：一旦方法抛出异常，系统自动根据该异常对象寻找合适异常处理器（Exception Handler）来处理该异常。所谓合适类型的异常处理器指的是异常对象类型和异常处理器类型一致。
### **
```
### try - catch 语句**
**try** {
***\*//可能产生的异常的代码区，也成为监控区\****
***\*//try块中放可能发生异常的代码。\****
***\*//如果执行完try且不发生异常，则不会执行catch内的内容，跳过catch，继续向下执行\****
***\*//如果发生异常，则尝试去匹配catch块。\****
}**catch** (SQLException SQLexception) {
***\*//捕获并处理try抛出异常类型为SQLException的异常\****
***\*//每一个catch块用于捕获并处理一个特定的异常，或者这异常类型的子类。Java7中可以将多个异常声明在一个catch中。\****
***\*//catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的，则虚拟机将使用这个catch块来处理异常\*******\*,执行catch块里面的代码\*******\*。\****
***\*//在catch块中可以使用这个块的异常参数来获取异常的相关信息。异常参数是这个catch块中的局部变量，其它块不能访问。\****
***\*//如果try中没有发生异常，则所有的catch块将被忽略。\*******\*继续向下执行\****
***\*//如果try有异常，当发生异常后，try中异常后面的代码不会被执行。\****
***\*//如果catch中的异常与之匹配，则会执行catch代码块，并且继续向下执行\****
***\*//如果catch中没有与报错信息匹配的异常，此时程序报错，程序停止\****
}**catch**(Exception e) {
***\*//捕获并处理try抛出异常类型为ExceptionType2的异常\****
}
```
#### try-catch代码块的执行顺序：
A）try没有异常时，try代码块中的语句依次被执行，跳过catch。执行后续代码。
B）try捕获到异常时，如果存在与之匹配的catch，则跳到该catch代码块执行处理；处理之后继续执行后续代码。
注意，try代码块出现异常之后的代码不会被执行。
C）try捕获到异常时，如果没有与之匹配的catch子句，则该异常交给JVM处理；如果存在finally，则其中的代码仍然被执行，但是try块发生异常之后的代码和finally之后的代码不会被执行。
#### 补充：
在catch块中对异常的处理，我们可以使用自定义的输出语句进行提示，也可以使用异常类为我们提供的方法
printStackTrace() 输出异常的堆栈信息 -- 在命令行打印异常信息在程序中出错的位置及原因
### **2：****try-catch-finally** **语句**
可以在try - catch 后面加上finally 语句块；
Finally 表示最终的意思，不管是否发生异常，都会被执行。
**
```
try** **{**
***\*//可能产生的异常的代码区\****
}catch (ExceptionType1 e) {
***\*//捕获并处理try抛出异常类型为ExceptionType1的异常\****
}catch (ExceptionType2 e){
***\*//捕获并处理try抛出异常类型为ExceptionType2的异常\****
}finally{
***\*//finally块通常是可选的。\****
***\*//无论异常是否发生，异常是否匹配被处理，finally都会执行。\****
***\*//\*******\*一个try至少要有一个catch块，否则， 至少要有1个finally块。但是finally不是用来处理异常的，finally不会捕获异常。\****
***\*//finally主要做一些清理工作，如流的关闭，数据库连接的关闭等。\****
}
```
try-catch-finally代码块的执行顺序：
A) try没有捕获异常时，try代码块中的语句依次被执行，跳过catch。如果存在finally则先执行finally在执行后续代码，否则执行后续代码。
B) try捕获到异常时，如果存在匹配的catch，则跳到该catch代码块执行处理。如果存在finally则先执行finally代码块，然后执行后续代码；否则直接执行后续代码。
另外注意，try代码块出现异常之后的代码不会被执行。
A）try捕获到异常时，如果没有匹配的catch，则该异常交给JVM处理。如果存在finally，则其中的代码仍然被执行，但是finally之后的代码不会被执行。
***\*注意：\****
**（1）*****\*Finally唯一不被执行的情况\****：当发生异常时，在程序中手动的退出系统：System.exit(1);
**（2）*****\*当try 或者 catch 块中存在return的时候，同时存在finally时，其执行顺序是怎样的？\****
如果try代码块或者catch代码块中有return语句时，finally代码块将在方法返回前被执行。先执行finally , 最后执行return
### **3：捕获总结**
try代码块：用于捕获异常。其后可以接零个或者多个catch块。如果没有catch块，后必须跟finally块，来完成资源释放等操作；
catch代码块：用于捕获异常，并在处理异常。
finally代码块：无论是否捕获异常，finally代码总会被执行。如果try代码块或者catch代码块中有return语句时，finally代码块将在方法返回前被执行。
唯一一种finally不会被执行的情况就是，发送异常时，手动的退出了系统。
## **4：抛出异常**
如果一个方法可能会出现异常，但没有能力处理这种异常，或者自己不想解决的话，可以使用甩锅的方式解决。
### **1：throws抛出异常**
如果一个方法可能抛出异常，但是没有能力处理该异常或者需要通过该异常向上层汇报处理结果，可以在方法声明时使用throws来抛出异常。这就相当于计算机硬件发生损坏，但是计算机本身无法处理，就将该异常交给维修人员来处理。
```
Public void methodName() throws Exception1,Exception2….{
}
```
其中Exception1,Exception2…为异常列表，一旦该方法中某行代码抛出异常，则该异常将由调用该方法的上层方法处理。如果上层方法无法处理，可以继续将该异常向上层抛。
##### 如果一个方法向外抛出了异常，那异常由谁来解决？
1：调用者，谁调用这个方法就由谁来解决。
2：如果调用者也解决不了呢？调用者可以继续向外抛出这个异常。
### **2：throw抛出异常**
在方法内，用throw来抛出一个Throwable类型的异常。一旦遇到到throw语句，后面的代码将不被执行。然后，便是进行异常处理——包含该异常的try-catch最终处理，也可以向上层抛出。注意我们只能抛出Throwable类和其子类的对象。
throw new ExceptionType;
比如我们可以抛出：throw new Exception(); 当在方法内部抛出一个异常时，一般也会在方法上再次抛一个异常。
也有时候我们也需要在catch中抛出异常,这也是允许的，比如说：
```
Try{
//可能会发生异常的代码
}catch(Exceptione){
throw new Exception(e);
}
```
### 3.throw与throws
## **4.自定义异常**
如果 Java 提供的内置异常类型不能满足程序设计的需求，可以设计自己的异常类型，
自定义异常类必须继承现有的 Exception 类或 Exception 的子类来创建，其语法形式为
```
class <自定义异常名> extends <Exception>
```
在编码规范上，一般将自定义异常类的类名命名为 XXXException，其中 XXX 用来代表该异常的作用
自定义异常类一般包含两个构造方法：一个是无参的默认构造方法，另一个构造方法以字符串的形式接收一个异常消息，并将该消息传递给父类的构造方法。
***\*自定义异常的具体步骤：\****
1：定义一个类继承Exception或者其子类；
2：编写构造方法（无参和有参）；
3：在需要的地方调用异常类（使用throw 抛出实例化后的异常）- 在方法的声明中需要声明
## **5.异常使用原则**
##### 从性能角度看：
1：不要将所有的代码都放在try中，try只放有可能发送异常的代码；
2：在catch中指定具体的异常类型。
***\*记住：能解决的使用捕获，不能解决的使用抛出\****
# 13.html
1.Html就是超文本标记语言的简写，是最基础的网页语言。
2.Html是通过标签来定义的语言，代码都是由标签所组成。<h> - h标签
3.Html代码不用区分大小写。Html5，妥协版本
4.Html代码由<html>开始</html>
396
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
