Java基础

一 入门介绍

一. Java语言前言

1.字节：计算机中存储数据的最小计量单位，用byte或者B表示

计算机中最小的存储单元是二进制，二进制用bit表示

8个二进制代表一个字节

8bit = 1B

2.常用的dos命令

win+r→输入cmd

二. java环境

1.JVM和跨平台

jvm（java虚拟机）：java运行程序的假想计算机，主要用来运行Java程序，一次编写，到处运行

2.JDK和JRE

jdk：java开发工具包，包含了jre

jre：java运行环境，包含了jvm以及后面开发用到的核心类库

jdk包含了jre，jre包含了jvm

*从jdk9开始就没有单独的jre目录了，jdk9引用模块化的技术，让开发者能按照自己的应用创建一个最小的运行时环境

三. 程序开发

编写->编译->运行

关键字：java自带

二 数据类型

一. 常量

1.在代码的运行过程中，值不会发生改变

整数常量，小数常量，字符常量 ‘a’，字符串常量 “aa”，布尔常量，空常量 null

二. 变量

1.变量的数据类型：

a.基本数据类型：4类8种

整型：byte（1字节） short（2） int（4） long（8）

浮点型 float（4） double（8）

字符型 char（2）

布尔型 boolean（1）

b.引用数据类型：类 数组 接口 枚举 注解

2.变量的定义

在代码的运行过程中，值会随着不同的情况而随时发生改变的数据

字符串不属于基本数据类型，属于引用数据类型，用String表示

String是一个类，只不过字符串在定义的时候可以和基本数据类型格式一样

3.变量的使用

定义初始化，使用

定义Long类型的变量，建议后面加个L long num = 10L

4.变量的运算

变量的加减乘除

转义字符：\

作用：将普通字符转成具有特殊含义的字符

将具有特殊含义的字符转成普通字符

n普通字符 \n转义字符

t普通字符 \t制表符

float和double的区别：

float的小数为只有23位，double的小数位有52位

不要用float或double直接参与运算，会有精度损失

变量使用注意事项：

1. 变量不初始化
2. 在同一个作用域中不能定义重名的变量
3. 不同作用域中的数据尽量不要调用

在小作用域中能直接访问大作用域的变量，但是大作用域中不能直接访问小作用域的变量

三. 标识符

给类，方法，变量取的名字

硬性规定

标识符可以包含“英文字母”“数字”“$和_”

标识符不能以数字开头

标识符不能是关键字

软性建议

给类取名：大驼峰式

四.数据类型转换

when？

a.等号左右两边类型不一致

b.不同类型的数据做运算

分类

a.自动类型转换

b.强制类型转换

基本类型按照取值范围从小到大排序

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

自动类型转换

取值范围小的可以赋值给取值范围大的

取值范围小的和取值范围大的做运算

强制类型转换

将取值范围大的数据类型赋值给取值范围小的数据类型

float num1 = (float)1.5(小数默认类型是double)

注意事项：

精度损失，数据溢出

三 运算符

一. 算数运算符

任务类型的算术运算符遇见字符串，都会变成字符串

• 自增自减运算符

变量++ →后自加 ++ 变量→前自加 自增自减只变化1

混合使用： 符号在前先运算，符号在后先使用原值后运算（简单设计）

二. 赋值运算符

• 基本赋值运算符 =

先看等号右边的，再将等号右边的数据赋值给等号左边的变量

• 复合赋值运算符 +=,-=,/=,*=

i += 2 → i = i + 2(不可完全等价)

三. 关系运算符

• 结果：boolean ——> true,false
• == 符号前后相等
• <
• ≥
• ≤
• ≠

四. 逻辑运算符

作用：连接多个bollean结果的

结果：boolean结果

• && 有假则假，前为false，不继续执行运算
• || 有真则真，前为true，继续执行运算
• ！ 不是true就是false
• ^ 符号前后结果一样为false，不一样为true
• & 如果符号前后都是数字，看作是位运算符，前为false，继续执行运算
• | 如果符号前后都是数字，看作是位运算符，前为true，继续执行运算

五. 三元运算符

• 格式 Boolean表达式？表达式1：表达式2

score ≥ 60 ? “及格”:”不及格”

四 常用的类

1.Scanner:键盘录入

• 导包 import java.util.Scanner

• 创建对象：Scanner sc = new Scanner(System.in)

• 调用方法

  sc.nextInt() 录入一个整数

  sc.next() 录入字符串，遇到空格或者回车就结束录入

  sc.nextLine() 录入字符串，遇到回车就结束录入

2.Random：生成随机数

a.概述：java定义好的类

b.作用：在一个指定的范围内随机一个整数

c.使用:

• 导包：import java.util.Random
• 创建对象：Random ra= new Random（）
• 调用方法：

ra.nextInt() 在int的取值范围内随机一个整数

ra.nextInt(int bound) → 在0→(bound-1)之间随机

3.switch

• a.格式

switch(变量){

case 常量值1：

执行语句1；

break

…..

default:

执行语句;

break;

}

4.if….else

• a.格式

if(表达式){

执行语句1

}else{

执行语句2

}

5.for循环

• 格式

for（初始变量；比较；步长语句）{

执行语句

}

6.while循环

• 格式

while（比较）{

循环语句

步进表达式

}

7.do… while

• 格式

do {

循环语句

步进表达式

}while（比较）

五 数组

一.数组的定义

• 数组概述：是一个容器，数组本身属于应用数据类型
• 作用：一次存储多个数据
• 特点：

a.既可以存储基本类型的数据，还能存储引用类型的数据

b.定长（定义数组是长度为多长，最多能存多少个数据）其实也是最大的缺点

• 定义：

a.动态初始化：在定义数组的时候，没有给具体的数据，只指定了长度

数据类型 数组名[] = new 数据类型[长度]

b.静态初始化：在定义数组的时候，我们直接给了数据

简化的静态初始化：数据类型 数组名[] = {元素1，元素2，…}

二.数组操作

• 获取数组的长度

1. 格式：数组名.length
2. 注意：length后不要带小括号，这是数组的属性，不是数组中的方法

• 索引

1. 概述：元素在数组中的位置
2. 索引都是从0开始，最大索引是数组长度减1
3. 作用：我们要操作元素，必须通过索引来操作

• 存储元素

格式：数组名[索引]=赋值

• 获取元素

格式：数组名[索引]

细节说明：直接输出数组名，会输出数组在内存的地址值（数组在内存中的唯一标识）

如果数组中没有存储数据，直接获取也能获取出来一些数据（元素的默认值）

• 遍历元素

for(int i=0;i<arr.length;i++)

快捷键：数组名.fori

三.操作数组的两个常见的问题

1. 数组索引越界异常 ArrayIndexOutOfBoundsException

• 原因：超出了数组的索引范围

1. 空指针异常 NullPinterException

• 当数组对象为null时，操作数组元素

四.内存图

1. 内存，可以理解为“内存条”，所有的软件，程序运行起来都会进入到内存中，占用内存，java将内存分为了五块
2. 分为哪五块？

• a.栈（Stack）

主要运行方法，方法的运行都会进栈内存进行，运行完毕之后，需要“弹栈”腾出空间

• 堆（Heap）

保存的是对象，数组，每new一次，都会在堆内存中开辟空间，并为这个空间分配一个地址值，堆内存中的数据都是有默认值的

• 方法区（Method Area）

代码的“预备区”。记录了类的信息以及方法的信息，方法区中主要保存clas文件以及其中的信息

代码运行之前，需要先进内存（方法区）

• 本地方法栈（Native Method Stack）

本地方法可以理解为对java功能的扩展

• 寄存器（pc register）

五.二维数组

1. 概述：数组中套了多个数组
2. 定义：

• 动态初始化：数据类型 数组名[][] = new 数据类型[m][n]

• 静态初始化：数据类型 数组名[][] = {{元素1，元素2…..},{元素1，元素2…..}……

模块六 方法

一. 方法的使用

1.方法介绍以及简单方法定义

所有代码放在main方法中→代码太多，不好维护

解决：将不同的功能放在不同的方法中，想执行某个功能，直接调用方法名就行了

2.格式

修饰符 返回值类型 方法名（参数）{

    方法体return 结果

}

3.通过通用格式可以分成四种方法来学习

a.无参无返回值

1.无参无返回值定义：
public static void 方法名(){方法体->实现此方法的具体代码;
}public static void farmer(){.....
}

b.有参无返回值

public static void 方法名(数据类型 变量名){方法体->实现此方法的具体代码
}
public static void add(int x,int y){int sum = x + y;System.out.println("sum += " + sum);
}

c.无参有返回值

public static 返回的数据类型 方法名(){方法体->实现此方法的具体代码;return 结果;
}
public static int ran(){int num = math.random();return num;
}

d.有参有返回值

public static 返回的数据类型 方法名(数据类型 变量名){方法体->实现此方法的具体代码;return 结果;
}
public static int add(int x,int y){int sum = x + y;return sum;
}

4.形式参数和时间参数的区别

形式参数：在定义方法的时候形式上定义的参数，此参数还没用值

实际参数：在调用方法的时候给形参赋予的具体的值

二.方法注意事项

1. 方法不调用不执行
2. 方法的执行顺序只和调用顺序有关
3. 方法之间不能相互嵌套
4. void 不能和[return 结果]共存，但是void能和[return]共存

a. void: 代表没有返回值

b. return 结果：就代表有返回值了

1. 一个方法中不能连续写多个return
2. 调用方法一定先定义

三.方法的重载

需求：实现一个函数，计算两个，三个，四个，五个整数相加

1. 概述：方法名相同，参数列表不同的方法

2.什么叫参数列表不同;

1. 参数个数不同
2. 参数类型不同
3. 参数类型顺序不同

方法重载的注意事项：

判断两个方法的是否为重载方法，和什么无关：

1. 和参数名无关
2. 和返回值无关

七 面向对象

一. 类和对象

1.面向对象的介绍
a.面向过程：自己的事情自己干，代表语言c语言b.面向过程：自己的事情别人帮忙去干，代表语言Java语言c.为什么要使用面向对象思想编程：简化了过程，减少了代码量d.什么时候使用面向对象思想编程：调用别人的功能时

2.类和对象
2.1 类
1.测试类：带main方法的类，主要时运行代码的
2.实体类：是一类事务的抽象表示形式
组成部分：
a.属性（成员变量）
定义位置：类中方法外
作用范围：作用于当前类
定义格式：数据类型 变量名
默认值：整数：0，小数：0.0，布尔：false，引用：null，字符：'\\u0000'
b.行为(成员方法)
将static方法去掉，其他的一样

2.2 对象
1.概述：一类事物的具体表现
2.使用：
a.导包：import 包名.类名
如果两个类在同一个包下，想使用对方的成员不需要导包
如果两个类不在同一个包下，想使用对方的成员需要导包
b.创建对象:想要使用哪个类的成员，就new哪个类的对象
类名 对象名 = new 类名（）
c.调用对象
想用使用哪个类的成员，就用哪个对象去调用
对象名.方法名()-->调用的是无参无返回值方法
对象名.方法名(实参)-->调用的是有参无返回值方法
数据类型 变量名 = 对象名.方法名()-->调用的是无参有返回值方法
数据类型 变量名 = 对象名.方法名(实参)-->调用的是有参有返回值方法

3.匿名对象的使用
1.int i = 10
a. int:数据类型
b. i：变量名
c  等号右边的10才是真正的数据2.person p = new person()
a.等号左边的person：对象的类型，好比是int
b：p：对象名
c：等号右边的new person（）：真正的数据，是一个person对象，这个对象是真正创建出来了
所谓的匿名对象：其实就是没有等号左边的部分，只有等号右边的部分3.使用
new 对象().方法()
//原始方式
person p = new person();
p.eat()
//匿名方式
new person().eat();注意：
1.我们只是单纯的想调用一个对象的方法，可以用匿名对象
2.但是涉及到赋值，千万别用匿名对象

二. 成员变量和局部变量的区别

1.定义位置不同：
a.成员变量：类中方法外
b.局部变量：定义在方法之中或者参数位置2.初始化值不同
a.成员变量：有默认值可以直接使用
b.局部变量：没有默认值不可以直接使用3.作用范围不同
a.成员变量：作用于整个类
b.局部变量：作用于方法内部4.内存位置不同
a.成员变量：在堆中，跟着对象走
b.局部变量：在栈中，跟着方法走5.生命周期不同
a.成员变量：随着对象的创建而产生，跟着对象的消失而消失
b.局部变量：随着方法的调用而产生，随着方法调用完毕而消失

三. static关键字

1.概述：静态关键字
2.使用
a,修饰一个成员变量
b.修饰一个方法
3.调用静态成员，类名直接调用
4.特点
a.静态成员不属于对象，属于类成员
b.静态成员会随着类的加载而加载
c.静态成员优先于对象存在在内存中
d.凡是根据静态成员所在的类创建出来的对象，都可以共享这个静态成员
5.内存说明
jdk6：方法区
jdk7：堆（回收效率高）
从jdk7开始静态变量开始在堆中出现

6.static修饰成员的访问特点
1.在静态方法中能直接访问非静态成员吗？
不可
2.在非静态方法中能直接访问静态成员吗？
可
3.在静态方法中能直接访问静态成员吗？
可
4.在非静态方法中能直接访问非静态成员吗？
可
7.静态成员的使用场景
大量使用static关键字的问题：类一加载，静态成员就会进内存，会占用大量内存
静态成员什么时候定义？
一般情况下，我们在抽取工具类的时候就可以将工具类中的所有成员都定义成静态的
什么时候定义工具类？
我们在写代码的过程中，发现有的功能在反复实现，代码一样，功能一样就可以抽取出来，形成工具类

四. 可变参数

需求：
定义一个方法，实现n个整数相加
分析：
方法参数位置，只明确了参数的类型，但是不明确参数个数，此时就可以定义成可变参数1.介绍和基本使用
定义格式
数据类型...变量名
public void sum(int...arr){
}
注意：
可变参数的本质是一个数组
参数位置不能连续写多个可变参数，而且当可变参数和其他参数一起使用时，可变参数需要放到参数列表最后

五.权限修饰

public：公共的，在哪里都能访问
protected: 受保护的
default: 默认的，注意：不写权限修饰符就是默认，不能直接把default写出来
private:私有的，只能在自己的类中直接访问

六.final关键字

1.格式：public final class 类名{}

2.特点：

被final修饰的类不可以被继承；

被final修饰的方法不能被重写；

final和abstract不能同时使用；

被final修饰的全局变量不能二次赋值；

被final修饰的对象地址值不能改变；

被final修饰的成员变量需要手动赋值，且不能二次赋值；

七.代码块

1.构造代码块

{代码
}

构造代码块每次都优先于构造方法执行

2.静态代码块

static{代码
}

静态代码块优先于构造代码块和构造方法，而且只执行一次

3.使用场景

如果想让数据优先初始化，而且只需要初始化一次，就可以将这些数据放到静态代码块中

八.内部类

当一个事物的内部，还有一个部分需要完整的结构去描述，而这个内部的完整结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类

class A{class B{} 
}

1.静态成员内部类

1.格式：直接在定义内部类的时候加上static关键字
public class A{static class B{}
}
2.注意：
a.内部类可以定义属性，方法，构造等
b.静态内部类可以被final或者abstract修饰
c.静态内部类不能调用外部的非静态成员
d.内部类还可以被四种权限修饰符修饰3.调用方式
外部类.内部类 对象名= new 外部类.内部类()

2.非静态成员内部类

外部类.内部类 对象名= new [外部类().new](<http://外部类.new>) 内部类()

3.局部内部类

可以定义在方法中，代码块中，构造中

4.匿名内部类

概述：所谓的匿名内部类，可以理解为没有显示声明出类名的内部类

问题描述：我们如果想实现接口，简单使用一次抽象方法，就需要创建一个实现类，实现这个接口，重写抽象方法，还要new实现类对象，所以我们在想如果就单纯的想使用一次接口中的方法

格式：

new 接口/抽象类(){重写方法
}.重写的方法（）；

八 封装

1. 封装的介绍以及使用

1.面向对象的三大特征： 封装   继承      多态2.什么是封装思想？
将细节隐藏起来，不让外界随便使用，但是我们可以提供一个公共的接口让外界间接使用隐藏起来的细节3.private关键字
问题：定义成员变量，只要new出来对象，就可以随便调用，哪怕是不合理的值
解决：将属性封装起来
private（私有化）——>被private修饰的成员只能在本类中使用，在别的类中使用不了
修饰成员变量 private 数据类型 数据名;问题：属性被私有化，外界调用不了，所以需要提供公共的接口操作属性
get/set方法

2.this关键字的使用

如果成员变量和局部变量重名时，我们遵循就近原则，优先使用局部变量
this:代表的是当前对象，this可以区分重名的成员变量和局部变量
哪个对象调用了this所在的方法，this就代表哪个对象

3.构造方法

1.概述：方法名和类名一致并且能初始化对象的方法
2.分类：
a.无参构造：没有参数
b.有参构造：有参数
3.特点：
a.方法名和类名一致
b.没有返回值，连void都没有
4.格式：
public 类名(){
}
每个类虚拟机会默认创建无参构造方法
作用：new 对象使用

4.标准JavaBean

JavaBean是Java语言编写类的一种标准规范
（1）类必须是具体的，plublic class 类名
（2）并且具有无参数的构造方法，有参构造
（3）成员变量私有化，并提供用来操作成员变量的get和set方法controller -->专门和页面打交道的类（表现层）
service    -->专门放业务处理的类（业务层）
dao        -->专门放和数据库打交道的类（持久层）
pojo       -->专门放JavaBean类
utils      -->专门放工具类

*：快速生成JavaBean的通用键：alt+insert

5.方法参数

1.基本数据类型vs引用数据类型 基本数据类型： 4类8种：整数，浮点数，字符型，布尔型 引用数据类型： 除了基本数据类型，其他的都属于引用数据类型

2.基本类型作为方法传递 变量作为参数传递，传递不是变量本身，而是参数的值 方法运行：压栈 方法结束：弹栈

3.引用类型作为方法传递 变量作为参数传递，传递的是变量的地址值

九 继承

一.继承

1. 什么是继承？

父类，子类
1.父类如何形成的？
我们定义了多个类，发现这些类中有很多重复性的代码，我们就定义了一个父类，将相同的代码抽取出来
放到父类中，其他的类直接继承这个父类，就可以直接使用父类中的内容了
2.如何去继承：extends
子类 extends 父类
3.注意
a.子类可以继承父类中的私有和非私有成员，但是不能使用父类中私有成员
b.构造方法不能继承
4.继承怎么学：
a.要从能否使用来学习

2.继承如何使用

1.定义一个父类，在其中定义重复性的代码
2.定义一个子类继承父类
子类 extends 父类
3.创建子类对象，直接继承父类中非私有成员

3.继承中成员变量的访问特点

成员变量：
父类对象不能调用子类的特有变量，子类对象可以调用父类的非私有变量
先看等号左边是谁，先调用谁中的成员，子类没有找父类成员方法
父类对象不能调用子类的特有方法，子类对象可以调用父类的非私有方法
看new的谁，先调用谁的方法，子类没有找父类

4.方法的重写

1.概述：子类中有一个和父类方法名以及参数列表相同的方法
2.前提：继承
3.访问：看new的是谁，就先调用谁的，没有在去找父类的
4.检查是否为重写方法：在该方法上写
@Override注意事项：
1.子类重写父类方法后，权限必须要保证大于等于父类权限（权限指的是访问权限）
public > protected > 默认
2.子类方法重写父类方法，方法名和参数列表要一样 
3.私有方法不能被重写，构造方法不能被重写，静态方法不能被重写
4.子类重写父类方法之后，返回值类型应该是父类方法返回值的子类类型使用场景：
某一个功能的升级改造，子类需要对父类的某一个功能进行升级改造

二.super和this

1.继承中构造方法的特点

1.注意
new子类对象时，会先初始化父类（优先走父类的无参构造）
2.原因：
每个构造方法的第一行，默认都会有一个super（），不写jvm自动提供一个
super（）代表的是父类的无参构造

2.super和this的具体使用

super
1.概述：代表的是父类引用
2.作用：可以调用父类中的成员
3.使用：
a.调用父类构造方法-->在子类中的构造中写
b.调用父类成员变量
c.调用父类成员方法this
1.概述：代表的是当前对象
2.作用
a.区分成员变量和局部变量
b.调用当前对象中的成员
3.使用：
a.调用当前对象的构造
b.调用当前对象的成员变量
c.调用当前对象的成员方法
4.不管是super还是this都必须在第一行使用，不能同时出现；

3.继承的特点

1.继承只支持单继承，不能多继承
2.继承支持多层继承
3.一个父类可以有多个子类
4.构造方法不能继承，也不能重写
私有方法可以被继承，不能被重写
静态方法可以被继承，不能被重写

三.抽象

1.将共有的方法抽取出来形成父类，但是抽取出来的方法没法确定，此时该方法不用写方法体了，没有方法
体的方法可以定义成抽象方法，抽象方法所在的类必须是抽象类
2.关键字abstract
3.定义抽象方法
修饰符 abstract 返回值类类型 方法名(参数):
4.抽象类
public abstract class 类名{}
5.抽象类里不是必须要存在抽象方法
注意：
a.抽象方法所在的类一定是抽象类
b.抽象类中不一定非得有抽象方法
c.子类继承抽象父类是，一定要冲重写父类中所有的抽象方法
d.抽象类不能new对象，只能通过new子类对象调用重写的方法
e.抽象类中可以有构造方法，其作用是子类初始化父类成员变量时使用的
6.可以将抽象类看成是一类事物的标准，要求只要是属于这一类的，都必须要拥有抽象类中的方法，必须
要实现--->重写

十. 接口

一.接口

1.接口是一种引用数据类型，是一种标准，规则
2.关键字
a.interface
public interface 接口名{}
b.implements
实现类 implements 接口名{}
3.接口中可以定义的成员：
a.jdk7以及之前：
抽象方法：public abstract --> 即使不写public abstract，默认也有
成员变量：public static final 数据类型 变量名 = 值 --> 即使不写public static final ，默认也有
b.jdk8
默认方法：public default 返回值类型 方法名(形参){}
静态方法: public static 返回值类型 方法名(形参){}
c.jdk9
私有方法：private 返回值类型 方法名(){}3.1抽象方法
1.定义格式：
public abstract 返回值类型 方法名(形参){}
2.注意
不写 public abstract默认也有
3.使用
a.定义实现类
b.重写抽象方法
c.new对象调用3.2 默认方法
1.定义格式
public default 返回值类型 方法名(形参){方法体return 结果
}
2.使用
a.定义实现类，实现接口
b.默认方法可重写，可不重写
c.new对象调用3.3静态方法
1.定义格式
public static 返回值类型 方法名(形参){}
2.使用
接口名之间调用
默认方法和静态方法可以当作接口中临时加入的小功能3.4成员变量
1.格式
public static final 数据类型 变量名 = 值
2.final
final修饰的变量不能再次赋值，可以看作常量
3.使用
接口名直接调用4.接口的特点
1.接口可以多继承
2.接口可以多实现
3.一个子类可以继承一个父类的同时实现一个或者多个接口
4.当一个类实现多个接口时，如果接口中的抽象方法有重名且参数一样的，只需要重写一次
如果接口中的默认方法有重名且参数一样的，必修重写一次5.接口和抽象类的区别
相同点：
a.都位于继承体系的顶端，用于被其他类实现或者继承
b.都不能new
c.都包含抽象方法，其子类或者实现类都必须重写这些抽象方法
不同点：
a.抽象类：一般作为父类使用，可以有成员变量，构造，成员方法，抽象方法等
b.接口：成员单一，一般抽取接口，抽取的都是方法，视为功能的大集合
c.类不能多继承，但是接口可以

二.多态

面向对象三大特征：封装，继承，多态
1.前提：
a.必须有子父类继承或者接口实现关系
b.必须有方法的重写，没有重写，多态没有意义，多态主要玩的就是重写方法
c.new对象:父类引用执行子类对象，理解为大类型接收了一个小类型的数据
2.注意
多态下不能调用子类的特有方法
3.多态条件下的成员访问特点
成员变量，看等号左边是谁，先调用谁的
成员方法，看new的是谁，就先调用谁的
4.为什么学多态？
多态方式和原始方式new对象的优缺点：
原始方式：
a.优点：既能调用重写的，还能调用父亲非私有的，还能调用自己特有的
b.缺点：拓展性差
多态：
a.优点：拓展性强->用父类类型接口，可以传递任意它的子类对象，接受哪个子类对象就指向哪个子类对象
就调用哪个子类对象重写后的方法
b.缺点：不能直接调用子类特有功能
5.多态中的转型
5.1向上转型
父类引用指向子类对象
5.2向下转型
将大类型强制转成小类型
想要调用子类特有功能，需要向下转型
instance of判断数据类型

十一. 异常

一.API文档
1API：Application Programing Interface,检查API，又称为应用编程接口
（定义出来的类以及接口，以及其中的方法）
为了方便我们去查询开发好的接口以及类，以及其中的方法，会提供一个对应的文档-→API文档
2API文档的作用：查询我们要使用的对象以及方法，是我们程序员的“字典”
二.异常
1.异常介绍以及出现过程
概述：相当于代码出现了错误，在java中，异常都是一个一个的类
Throwable类有两个子类，Error，Exception。
Exception又分为编译时期异常（Excepiton以及子类除了RuntimeException）和运行时期异常（RuntimeException及其子类）
编译时期异常：
当我们调用方法的时候，该方法底层给我们抛了一个编译时期异常，所以才导致我们一调用此方法，一编译，就爆红了。当我们一旦触发了这个异常，jvm就会将异常信息打印到控制台上，给程序员看
运行时期异常：
运行时候才会出现，一层一层的往上抛
2.创建异常对象
3.异常处理的两种方式
异常处理的两种方式-try…catch

catch多个异常

1.格式：

try{

可能出现的异常

}catch（异常 对象名）{

处理异常的代码-->将异常信息保存到日志文件中

}catch（异常 对象名）{

处理异常的代码-->将异常信息保存到日志文件中

}catch（异常 对象名）{

处理异常的代码-->将异常信息保存到日志文件中

}

2.注意：

如果catch的多个异常之间有子父类关系，可以直接抛出父类Exception

如果不知道多个异常之间有子父类异常的继承关系，可以之间抛出Exception

4.finally关键字

finally关键字

1.概述:代表的是不管是否触发了异常，都会执行的代码块

特殊情况：如果之前执行了System.exit(0)终止当前正在执行的java虚拟机

2.使用：都是配合try...catch使用

try{

可能出现的异常

}catch（异常 对象名）{

处理异常的代码-->将异常信息保存到日志文件中

}finally{

不管是否有异常，都会执行的代码

}

3.使用场景：

1.关闭资源

2.对象如果没有用了，GC回收，回收堆内存中的垃圾，释放内存，有一些对象GC会回收不了，就需要手动

关闭，此时就可以将关闭资源的代码放在finally中

5.抛异常时注意的事项

抛异常时注意的事项

1. 如果父类中的方法抛了异常，那么子类要不要抛？

可抛可不抛

2. 如果父类中的方法没有抛异常，那么子类要不要抛？

不能抛

6.try…catch和throws的使用时机

try…catch和throws的使用时机

1.如果处理异常之后，还需要代码继续执行，使用try...catch

2.如果方法直接是递进关系（调用）,我们可以先throws，但是到了最后需要用try...catch做一个

的异常处理

3.编译时期异常必须处理

运行时期异常一般不处理

7.自定义异常

自定义异常

需求：登录功能，登录失败，抛出LoginException，此时需要自定义异常

public class LoginException extends Exception{}

1.定义一个类

2.如果继承Exception就是编译时期异常

3.如果继承RunTimeException就是运行时期异常

8.打印异常信息的三个方法

打印异常信息的三个方法

Throwable类中的方法：

String toString():输出的异常类型和设置的异常信息

String getMessage()：输出的是异常信息

void printStackTrace()：输出的异常信息最完整，包含异常信息和出现异常的行数