JavaSE 入门
文章目录
- Java基础
-
- 注释
- 标识符
-
- 关键字
- 标识符注意点
- 数据类型
- 什么是字节
- 类型转换
- 变量
-
- 变量作用域
- 常量
- 变量的命名规范
- 包机制
- Java 流程控制
-
- 用户交互Scanner
- Java方法
-
- 何谓方法
- 方法的定义
- 方法调用
- 方法的重载
- 可变参数
- 数组
-
- 数组的定义
- 数组声明创建
- 内存分析
-
- 三种初始化
- 数组的四个基本特点
- 数组边界
- 数组使用
- 多维数组
- Array 类
- 面向对象
-
- 类与对象的关系
- 创建与初始化对象
- 封装
- 继承
-
- super
- 方法重写
- 多态
- static关键字
- 抽象类
- 接口
- 内部类
- 异常
-
- 什么是异常
- 简单的分类
- 异常体系结构
- Error
- Exception
- 异常处理机制
- 自定义异常
Java基础
注释
平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。
注释并不会被执行，是给我们写代码的人看的。
书写注释是一个非常好的习惯
Java中的注释有三种
单行注释：
//单行注释
多行注释：
/*多行注释*/
文档注释：
JavaDoc：文档注释
/**
*@Description Hello World
*@Author 狂神说
*/
标识符
关键字
Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
标识符注意点
所有的标识符都应该以字母（A-Z 或者 a-z），美元符（$）、或者下划线（_）开始
首字符之后可以是字母（A-Z 或者 a-z），美元符（$）、或者下划线（_）或数字的任何字符组合
不能使用关键字作为变量名或方法名
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1__value
非法标识符举例：123abc、-salary、#abc
public static void main(String[] args){
String 王者荣耀 = "最强王者";
System.out.println(王者荣耀);
}
可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low
数据类型
强类型语言
要求变量的使用要严格符合规定，所有变量都必须先定义后才使用
弱类型语言
与强类型语言相反（强类型语言的安全性比弱类型语言弱）
Java的数据类型分为两大类
什么是字节
位（bit）：是计算机 内部数据 存储的最小单位，11001100是一个八位二进制数。
字节（byte）：是计算机中 数据处理 的基本单位，习惯上用大写 B 来表示
1 B（byte，字节） = 8 bit（位）
字符：是指计算机中使用的字母、数字、字和符号
1 bit表示 1位
1 Byte表示一个字节 1B = 8b
1024B = 1KB
1024KB = 1M
1024M = 1G
类型转换
由于Java是最强类型语言，所以要进行有些运算的时候，需要用到类型转换。
低 ------------------------------------------> 高
byte，short，char --> int --> long --> float --> double
运算中， 不同类型的数据先转化为同一类型，然后进行运算。
强制转换 （类型）变量名 高 —> 低
int i = 45;
byte b = (byte)i;
自动转换 低 —> 高
注意点：
1、不能对布尔值进行转换
2、不能把对象类型转换为不相干的类型
3、在把高容量转换到低容量的时候，强制转换
4、转换的时候可能存在内存溢出，或者精度问题！
变量
变量是什么：就是可以变化的量
Java是一种强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域，
数据类型 变量名 = 值; 可以使用逗号隔开来声明多个同类型变量。
注意事项：
每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符
变量声明是一条完整的语句，因此每一个声明都必须以分号结束
变量作用域
类变量
实例变量：从属于对象
局部变量：必须声明和初始化值
public class Test{
//类变量 从属于类 static 变量名
static double salary = 2500;
//属性：变量
//实例变量：从属于对象；如果不自行初始化，这个类型的默认值 0
//布尔值：默认是false
//除了基本类型，其余的默认值都是null
String name;
int age;
//main方法
public static void main(String[] args){
//局部变量：必须声明和初始化值
int i = 10;
System.out.println(i);
//变量类型 变量名字 = new Test();
Test test = new Test();
System.out.println(test.age);
System.out.println(test.name);
//类变量 static
System.out.println(salary);
}
}
常量
常量（Constant）：初始化（initialize）后不能再改变值！不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变
final 常量名 = 值;
final double PI = 3.14;
常量名一般使用大写字符
变量的命名规范
所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run()，runRun()
包机制
为了更好的组织类，Java 提供了包机制，用于区别类名的命名空间。
包语句的语法格式为：
package pkg1[. pkg2[. pkg3...]];
一般利用公司域名倒置作为包名；
为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 “import” 语句可以完成此功能
import package1[.package2...].(classname|*);
Java的运算符就省略了
Java 流程控制
用户交互Scanner
基本语法：
Scanner s = new Scanner(System.in);
通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要 使用 hasNext() 与 hasNextLine() 判断是否还有输入的数据。
public class Test{
public static void main(String[] args) {
//创建一个扫描对象，用于接受键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收：");
//判断用户有没有输入字符串
if (scanner.hasNext()){
String str = scanner.next();
System.out.println("输出的内容为：" + str);
}
//凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
scanner.close();
}
}
next():
1、一定要读取到有效字符后才可以结束输入
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
4、next() 不能得到带有空格的字符串
nextLine():
1、以 Enter 为结束符，也就是说 nextLine() 方法返回的是输入回车之前的所有字符
2、可以获得空白
一个例子
public class Test{
public static void main(String[] args) {
//输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入执行结果
Scanner scanner = new Scanner(System.in);
//和
double sum = 0;
//计算输入了多少个数字
int m = 0;
//通过循环判断是否还有输入，并在里面对每一次进行求和和统计
while (scanner.hasNextDouble()){
double x = scanner.nextDouble();
m = m + 1;
sum = sum + x;
System.out.println("你输入了第" + m + "个数据，然后当前结果sum= " + sum);
}
System.out.println(m + "个数的和为" + sum);
System.out.println(m + "个数的平均值是" + ( sum / m ));
scanner.close();
}
}
Java的控制流程：选择语句：if语句，if…else…语句，if…elseif…else语句，switch语句
循环语句：for循环，while循环，do…while循环
跳出循环的两个关键字：continue（跳出本次循环）break（跳出整个循环）
Java方法
何谓方法
Java方法是语句的集合，它们在一起执行一个功能。
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用
设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。
回顾：方法的命名规则? 首字母小写和驼峰原则：run()，runRun()
方法的定义
Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下定义一个方法包含以下语法：
方法包含一个方法头和一个方法体，下面是一个方法的所有部分：
修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型
返回值类型：方法可能会返回值。returnValue Type 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValue Type 是关键字 void
方法名：是方法的实际名称。方法名和参数表共同构成方法签名
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
形式参数：在方法被调用时用于接收外界输入的数据
实参：调用方法时实际传给方法的数据
方法体：方法体包含具体的语句，定义该方法的功能。
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}
方法调用
调用方法：对象名.方法名(实参列表)
Java 支持两种调用方法的方式，根据方法是否返回值来选择
当方法返回一个值的时候，方法调用通常被当做一个值。例如：
int larger = max(30,40);
如果方法返回值是 void ，方法调用一定是一条语句。
System.out.println("Hello,kuangshen!");
值传递 和 引用传递
方法的重载
重载就是在一个类中，用相同的函数名称，但是参数不同的函数。
方法的重载的规则：
方法名称必须相同
参数列表必须不同（个数不同、或类型不同、参数排序顺序不同等）
方法的返回类型可以相同也可以不相同
仅仅返回类型不同不足以成为方法的重载
实现理论：
方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。
public class Test{
public static void main(String[] args) {
sum(1,1);
sum(3.2,3.1);
}
public static int sum(int a,int b){
return a +b ;
}
public static double sum(double a,double b){
return a +b ;
}
}
可变参数
JDK 1.5 开始，Java 支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加上一个省略号（…）。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
相当于数组（本质就是数组）
public static void printMax(double ... numbers){
if (numbers.length == 0){
System.out.println("No argument passed");
return;
}
double result = numbers[0];
//排序！
for (int i = 1; i < numbers.length; i++) {
if (numbers[i] > result){
result = numbers[i];
}
}
System.out.println("This max value is " + result);
}
递归方法就是自己调用自己（省略）
数组
数组的定义
数组是相同类型数据的有序集合
数组描述的是相同类型的若干个数组，按照一定的先后次序排列组合而成
其中，每一个数据称作一个数据元素，每个数组元素可以通过一个下标来访问它们
数组声明创建
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法
Java语言使用 new 操作符来创建数组，语法如下：
dataType[] arrayRefVer = new dataType[arraySize];
数组的元素是通过索引访问的，数组索引从 0 开始。
获取数组长度：arrays.length
内存分析
Java内存分析：
三种初始化
静态初始化
int[] a = {1，2，3};
Man[] mans = {new Man(1,1),new Man(2,2)};
动态初始化
int[] a = new int[2];
a[0] = 1;
a[1] = 2;
数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
数组的四个基本特点
其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
其元素必须是相同类型。不允许出现混合类型
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，
数组对象本身是在堆中的。
数组边界
下标的合法区间：[0,length-1]，如果越界就会报错；
public static void main(String[] args) {
int[] a = new int[2];
System.out.println(a[2]);
}
ArrayIndexOutOfBoundsException：数组下标越界异常
小结：
数组是相同数据类型（数据类型可以为任意类型）的有序集合
数组也是对象。数组元素相当于对象的成员变量
数组长度是确定的，不变的。如果越界，则报：ArrayIndexOutOfBounds
数组使用
For-Each 循环
数组作方法入参
数组作返回值
举个栗子
public class Test{
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
int[] reverse = reverse(arrays);
printArray(reverse);
//JDK1.5开始，没有下标(引号前面是数组的对象，引号后面是数组名)
for (int array : arrays) {
System.out.println(array);
}
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i] + " ");
}
}
//反转数组
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
//反转的操作
for (int i = 0, j = result.length-1; i < arrays.length; i++,j--) {
result[j] = arrays[i];
}
return result;
}
}
多维数组
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
二维数组
int a[][] = new int[2][5];
解析：以上二维数组 a 可以看成一个两行五列的数组
思考：多维数组的使用就是 数组中嵌套数组
Array 类
数组的工具类 java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用，但 API 中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
查看 JDK 帮助文档
Arrays类中的方法都是 static 修饰的静态方法，在使用的时候可以直接使用类名进行调用，而 “不用” 使用对象来调用（注意：是 “不用” 而不是 “不能”）
具有以下常用功能：
给数组赋值：通过 fill 方法
对数组排序：通过 sort 方法，升序
比较数组：通过 equals 方法比较数组中元素值是否相等
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作
面向对象
面向对象编程（Object-Oriented Programming，OOP）
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据
抽象
三大特征：
封装
继承
多态
从认识论角度考虑是现有对象后有类。对象，是具体的事物。类，是抽象的，是对 对象 的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。
public class Test {
public static void main(String[] args) {}
//静态成员和类一起加载
public static void a(){
b();
}
//非静态成员，类实例化 之后才存在
public void b(){
a();
}
}
类与对象的关系
类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
动物、植物、手机、电脑…
Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为。
对象是抽象概念的具体实例
张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例
能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。
创建与初始化对象
使用 new 关键字创建对象
使用 new 关键字创建的时候，除了分配内存空间之外，还会给 创建好的对象 进行默认的初始化 以及 对类中的构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
1、必须和类的名字相同
2、必须没有返回类型，也不能写 void
class Person{
//一个类即使什么都不写，它也会存在一个方法
//显示的定义构造器
String name;
//实例化初始值
// 使用 new 关键字，本质是在调用构造器
public Person(){
}
//有参构造：一旦定义了有参构造，无参就必须显示定义
public Person(String name){
this.name = name;
}
// alt + insert
}
构造器：
1、和类名相同
2、没有返回值
作用：
1、new 本质在调用构造方法
2、初始化对象的值
注意点：
定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
封装
该露的露，该藏的藏
我们程序设计要追求 “高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
记住这句话就够了：属性私有，get/set方法
public class Student {
//属性私有
private String name;
private int id;
private char sex;
//提供一些可以操作这个属性的方法
// 提供一些 public 的 set、get的方法
//set方法 给这个数据设置值
public void setName(String name){
this.name = name;
}
//get方法 获得这个数据
public String getName(){
return this.name;
}
//get、set方法的快捷方式：alt + insert
}
封装的作用：1、提高了程序的安全性，保护数据
2、隐藏代码的实现细节
3、统一接口
4、系统可维护增加了
继承
继承的本质是对某一批类的对象，从而实现对实现世界更好的建模。
extands 的意思是 “扩展”。子类是父类的扩展。
Java只有单继承，没有多继承！
继承是类和类的之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字 extands 来表示。
子类和父类之间，从意义上讲应该具有 “is a” 的关系
object类：是所有类的父类
super
super注意点：
1、super调用父类的构造方法，必须在构造的第一个
2、super 必须只能出现在子类的方法或者构造方法中
3、super 和 this 不能同时调用构造方法
Vs this：
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
前提：
this：没有继承也可以使用
super：只能在继承条件才可以使用
构造方法：
this(); 本类的构造
super(); 父类的构造
方法重写
重写：需要有继承的关系，子类重写父类的方法！
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可以扩大但不能缩小：public>protected>default>private
4、抛出异常：范围，可以缩小，但不能扩大； ClassNotFoundException --> Exception（大）
重写，子类的方法和父类必须要一致；方法体不同
为什么要重写：
父类的功能，子类不一定需要，或者不一定满足
class A{
public void print(){
System.out.println("A类被调用");
}
}
class B extends A{
@Override
public void print() {
super.print();
System.out.println("B类被调用");
}
}
多态
即同一方法可以根据发生对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
有继承关系
子类重写父类的方法
父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性。
（包括向上转型和向下转型）
public class Test {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//可以指向的引用类型就不确定了：父类的引用指向子类
//Student 能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//Person 父类型，可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
// 使用 s2.eat(); 会发生报错，提示：父类Person中没有eat方法
((Student)s2).eat();
//子类重写了父类的方法，执行子类的方法
//子类继承了父类的所有方法,
s2.run();
}
}
class Person{
public void run(){
System.out.println("run");
}
}
class Student extends Person{
public void eat(){
System.out.println("eat");
}
@Override
public void run() {
System.out.println("son");
}
}
比如A类是父类，B类是子类
A a = new B(); //向上转型
B b = (A) a; //向下转型
多态注意事项：
1、多态是方法的多态，属性没有属性
2、父类和子类，有联系 类型转换异常！ClassCastException！
3、存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new Son();
1、static 方法，属于类，它不属于实例
2、final 常量
3、private 方法
对于Java多态执行：成员变量，静态方法看左边；非静态方法：编译看左边，运行看右边。
具体的可以看 https://baijiahao.baidu.com/s?id=1709162791065825410&wfr=spider&for=pc
static关键字
static的意思就是静态，随着类的创建而诞生。
多个类对象共用一个静态变量
抽象类
abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
抽象类，不能使用 new 关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
//抽象类
public abstract class Action {
//约束~有人帮我们实现~
//abstract,抽象类,只有方法名字,没有方法的实现！
public abstract void doSomething();
//1、不能 new 这个抽象类,只能靠子类去实现它：约束！
//2、抽象类中可以写普通的方法
//3、抽象类必须在抽象类中~
}
//子类
public class A extends Action{
@Override
public void doSomething() {
System.out.println("Hello World!");
}
}
接口
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！自己无法写方法专业的约束！约束和实现分离：面向接口编程
声明类的关键字是class，声明接口的关键字是interface
//interface 定义的关键字,接口都需要有实现类
public interface UserService {
//接口中的所有定义其实都是抽象的 public abstract
void add(String name);
void delete(String name);
}
//抽象类：extends
// 类 可以实现接口 implements 接口
//实现了接口的类,就需要重写接口中的方法~
//可以利用接口实现多继承
public class UseServiceImpl implements UserService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
}
接口作用：
1、约束
2、定义一些方法，让不同的人实现
3、public abstract
4、public static final
5、接口不能被实例化，接口中没有构造方法
6、implements 可以实现多个接口
7、必须要重写接口中的方法
内部类
内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
1、成员内部类 2、静态内部类 3、局部内部类 4、匿名内部类
public class Outer {
private int id;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
public static void main(String[] args) {
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
}
匿名类
public class Test {
public static void main(String[] args) {
//没有名字初始化类,不用讲实例保存到变量中
new Apple().eat();
new UserService(){
@Override
public void hello() {
System.out.println("Hello");
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
异常
什么是异常
实际工作中，遇到的情况不可能是非常完美的。比如:你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序再跑着，内存或硬盘可能满了。等等。
软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题,我们叫异常，英文是:Exception，意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃。
异常指程序运行中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。
异常发生在程序运行期间，它影响了正常的程序执行流程。
public static void main(String[] args) {
System.out.println(1/0);
}
程序会报错
Exception in thread "main" java.lang.ArithmeticException: / by zero
简单的分类
要理解 Java 异常处理是如何工作的，需要掌握以下三种类型的异常：
检查性异常:最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常:运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误:错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
异常体系结构
Java把异常当作对象处理，并定义一个基类 java.lang.Throwable作为所有异常的超类
在 Java API 中已经定义了许多异常类，这些异常分为两大类，错误Error和异常Exception
Error
Error类对象由 Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关
Java虚拟机运行错误(Virtual MachineError)，当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java 虚拟机 (JVM) 一般会选择线程终止;
还有发生在虚拟机试图执行应用时，如类定义错误(NoClassDefFoundError)、链接错误(LinkageError)。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
Exception
在 Exception 分支中有一个重要的子类 RuntimeException (运行时异常)
ArraylndexOutOfBoundsException (数组下标越界)
NullPointerException(空指针异常)
ArithmeticException(算术异常)
MissingResourceException(丢失资源)
ClassNotFoundException(找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这些异常的发生。
Error和Exception的区别:Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机(JVM)一般会选择终止线程;Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
异常处理机制
抛出异常
捕获异常
异常处理五个关键字
try、catch、finally、throw、throws
public class Test {
public static void main(String[] args) {
int a = 1;
int b = 0;
try{ //try监控区
System.out.println(a/b);
}catch (ArithmeticException e){ //catch(想要捕获的异常类型！) 捕获异常
System.out.println("程序出现异常,变量b不能为0");
}finally { //无论出不出异常,都会执行finally中的内容,处理善后工作
System.out.println("finally");
}
}
}
可以使用多个catch捕获异常
捕获的异常类型从小到大排序
public class Test {
public static void main(String[] args) {
int a = 1;
int b = 0;
try{
System.out.println(a/b);
}catch (Error e){
System.out.println("Error");
}catch (Exception e){
System.out.println("Exception");
}catch (Throwable e){
System.out.println("Throwable");
}finally { //无论出不出异常,都会执行finally中的内容,处理善后工作
System.out.println("finally");
}
}
}
throw和throws
public class Test {
public static void main(String[] args) {
// ctrl+alt+t
try {
new Test().test(1,0);
} catch (ArithmeticException e) {
e.printStackTrace();
}
}
public void test(int a,int b) throws ArithmeticException{
if (b==0){
throw new ArithmeticException(); //主动的抛出异常,一般在方法中使用
}
}
}
自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
在程序中使用自定义异常类，大体可分为以下几个步骤：
1、创建自定义异常类
2、在方法中通过throw关键字抛出异常对象
3、如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
4、在出现异常方法的调用者中捕获并处理异常。
总结：
1、处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
2、在多重catch块后面，可以加一个catch (Exception)来处理可能会被遗漏的异常对于不确定的代码，也可以加上 try-catch，处理潜在的异常
3、尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出具体如何处理异常，要根据不同的业务需求和异常类型去决定
4、尽量添加finally语句块去释放占用的资源
try{
代码/可能有异常
}catch(Exception e){
捕获到异常
1.当异常发生时
2.系统将异常封装成Exception对象e，
传递给catch
3.得到异常对象后，程序员自己处理
4.注意，如果没有发生异常catch代码块不执行
}finally{
1.不管try代码块是否有异常发生，始终要执行finally
2.所以，通常将释放资源的代码，放在finally
}