JavaSE 入门

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
}