【Java】Java零基础学习笔记

---

前言

【狂神说Java】Java零基础学习视频通俗易懂
学习网站：https://www.bilibili.com/video/BV12J41137hu?spm_id_from=333.999.0.0
所制作内容为学习中途记录内容，内容并不详细，可以作为复习材料，如有遗漏或者问题还望告知。
望有幸可以一起学习。~

---

思维导图

---

前期准备

卸载JDK

1. 删除java安装目录
2. 删除java_home
3. 去除环境变量
4. java -version

安装JDK

1. 安装JDK8，找到下载地址
2. 统一协议
3. 下载的电脑对应版本
4. 双击安装JDK
5. 记住安装路径
6. 配置环境变量
   1. 我的电脑->右键->属性
   2. 高级系统设置->环境变量->JAVA_HOME
   3. 配置path变量
7. cmd检测Java是否安装：java -version

Hello,world

1. 随便新建一个文件夹，存放代码

2. 新建一个java文件

   1. 注意文件后缀
   2. hello.java
   3. 注意文档的对应信息

3. Java文件编译,代码编写

   public class Main {
       public static void main(String[] args) {
           // write your code here
           System.out.print("hello,world");
       }
   }
   

4. 编译javac java文件

5. 运行class文件，Java class文件

可能遇到情况

1. 每个单词大小写不能出错，Java大小写敏感
2. 尽量使用英文
3. 文件名和类名必须一致，并且手写字母大写
4. 符号使用了中文

java程序运行机制

1. 编译型
2. 解释型
3. 程序的运行机制

IDEA的安装

1. IDEA的安装
2. IDEA的使用
   1. pwvm-主函数
   2. sout-输出函数
3. IDEA的优化

---

java基础部分

基础语法

1. 注释、标识符、关键字

   1. 注释

      1. 书写注释是一个非常好的习惯

      2. 单行注释

         // 单行注释-注释一行文字
         // 注释
         

      3. 多行注释

         // 多行注释-可以注释一段文字		
         /*注释*/
         

      4. 文档注释

         // JavaDoc:文档注释	/** 注释*/
         /**
         *@Author hahaha
         */
         

   2. 标识符

      1. 不能使用关键字作为变量名
      2. 标识符大小写敏感
      3. 不建议中文名字进行

2. 数据类型

   1. 强类型语言

      1. 要求变量的使用要严格符合规范，所有变量都必须先定义后使用

   2. 弱类型语言

   3. Java的数据类型分为两大类

      1. 基本类型

         1. 整数类型

         2. 浮点类型

         3. 字符类型

         4. 布尔类型

            // 八大基本数据类型
            
            // 整数
            byte num1=20;
            int num2=10;// 最常用
            short num3=30;
            long num4=50L;// 一般会再数字结尾加L
            
            // 浮点数
            float num5=40.5F; // 一般再结尾加F
            double num6=3.141592653589;
            
            // 字符类型
            char name='A';
            // 字符串,String不是关键字是类
            String name1="halhal";
            
            // 布尔值
            boolean flag=true;
            
            
            

      2. 引用类型

         1. 类
         2. 接口
         3. 数组

      3. 数据类型扩展

         // 整数扩展	进制	二进制0b	十进制	八进制0	十六进制0x
         int i=10;// 十进制
         int i2=010;// 八进制
         int i3=0x10;// 十六进制0x
         
         // 浮点数扩展
         // 最好完全使用浮点数进行比较
         // BigDecimal 数学工具类
         
         // 字符扩展
         // 所有的字符本质还是数字
         // 编码
         
         // 转义字符
         // \t 制表符
         // \n 换行
         // ...
         
         // 布尔值扩展
         boolean flag=true;
         
         
         

3. 类型转换

   1. 运算中，不同类型的数据先转化为同一类型，然后进行运算
   2. 内存溢出问题
   3. 强制转换 （类型）数据-高到低
   4. 自动类型转换 低到高
   5. 注意点
      1. 不能对布尔值进行转换
      2. 不能把对象转换为不相干的类型
      3. 在把高容量转换到低容量的时候，强制转换
      4. 转换的时候可能出现内存溢出，或精度问题
   6. 操作比较大的数的时候，注意溢出问题
      1. JDK7新特性，数字之间可以用下划线分割
      2. 在计算时候就进行对应类型的转换

4. 变量、常量

   1. 变量

      // 数据类型 变量名=值；
      // 可以使用逗号隔开来声明多个同类型变量
      

      注意事项

      1. 每个变量都有类型，类型可以是基本类型，也可以是引用类型
      2. 变量名必须是合法的标识符
      3. 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

      // int a=1,b=2,c=3; // 程序可读性
      String name = "qinjiang";
      char x='x';
      double pi=3.14;
      

      变量作用域

      1. 类变量

         statice 数据类型 名称=值

      2. 实例变量

         从属于对象，在方法外，类内

         如果不自行初始化，这个类型默认值为 0，0.0，

         布尔值默认false

         除了基本类型，其余的默认值都是null

      3. 局部变量

         局部变量在方法里，必须声明和初始化值

   2. 常量

      1. final 数据类 名称=值
      2. 修饰符，不存在先后顺序

   3. 变量的密码规范

      1. 所有变量、方法、类名：见名知意
      2. 类成员变量：首字母小写和驼峰原则
      3. 局部变量：首字母小写和驼峰原则
      4. 常量：大写字母和下划线
      5. 类名：首字母大写和驼峰原则
      6. 方法名：首字母小写和驼峰原则

5. 运算符

6. 包机制、javaDoc

运算符

1. 算数运算符

   1. CTRL+D复制当前行到下一行
   2. 运算类型以最高的为基准
   3. %取余符号
   4. 自增，自减运算符一元运算符
      1. 自增 ++
         1. ++a 先自增
         2. a++ 先赋值
      2. 自减 –
      3. 幂运算
         1. Math类

2. 赋值运算符

3. 关系运算符

4. 逻辑运算符

   1. 与-and
      1. 两个变量都为真，结果为真
   2. 或-or
      1. 两个变量有一个真，结果为真
   3. 非-取反
      1. 如果是真则为假，如果是假则为真
   4. 短路运算
      1. 假设前面的为错，后面的结果可能不进行运算

5. 位运算符（了解）

     /**
     A=0011 1100
     B=0000 1101
     
     A&B=0000 1100	//有0为0
     A|B=0011 1101	//有1为1
     A^B=0011 0001
     ~B=1111 0010
     效率高
     <<	*2
     >>	/2
     
     */
     ```
   
   

6. 条件运算符

   1. 三元运算符

      // x?y:z
      // 如果x==true,则结果为y,否则结果为z
      

7. 扩展赋值运算符

   1. +字符输出，会将所有类型变为字符串连接，如果在计算前直接连接，如果在计算后，先运算再连接

8. 优先级

包机制

1. 区别于命名空间
2. 包的本质就是文件夹
3. 一般利用公司域名倒置作为包名
4. 导包-import
5. 分包-package
6. 阿里巴巴开发手册

javaDoc文档手册

1. Java api手册

   /**
   *@author Test
   *@version 1.0
   */
   

2. 类上是类的注释，方法上是方法的注释

3. 包文档的构建

4. javadoc -encoding UTF-8 -charst UTF–8 Doc.java

java流程控制

用户交互-Scanner对象

1. 基础语法

   // 基础语法
   // 创建扫描器对象
   Scanner scanner=new Scanner(System.in);
   System.out.println("使用next方式接收：");
   
   // 判断用户有没有输入对象
   if（scanner.hasNext()）{
       // 使用next方式接收输入量
       // next方法->不能得到带空格的字符串
       //String str=scanner.next();
       // nextLine->以Enter为结束符，可以获得空白字符
       String str=scanner.nextLine();
       // 输出对象内容
       System.out.println(str);
   }
   // 使用完就关闭，凡是属于IO流不关闭会占用内存
   scanner.close();
   

2. 输出

   Scanner scanner=new Scanner(System.in);
   int i=0;
   float f=0.0f;
   // 进行整数输出
   System.out.printfl("请输入一个整数");
   if(scanner.hasNextInt()){
       i=scanner.nextInt();
       System.out.println("输入的是整数")
   }
   else{
       System.out.println("输入的不是整数")
   }
   // 进行小数输出
   System.out.printfl("请输入一个小数");
   if(scanner.hasNextFloat()){
       i=scanner.nextFloat();
       System.out.println("输入的是小数")
   }
   else{
       System.out.println("输入的不是小数")
   }
   
   scanner.close();
   

顺序结构

1. 基本结构，从上往下执行。
2. 它是任何一个算法都离不开的一种基础结构

选择结构

1. if单选择结构

   // 语法
   if(布尔表达式){
       //布尔表达式成立执行
       // 判断字符串是否相等equals()方法;
   }
   

2. if双选择结构

   // 语法
   if(布尔表达式){
       // 如果布尔表达式的值为true
   }
   else{
       // 如果布尔表达式值为false
   }
   

3. if多选择结构

   // 语法
   if(布尔表达式1){
       //布尔1成立
   }else if(布尔表达式2){
       //布尔2成立
   }else if(布尔表达式3){
       //布尔3成立
   }
   .......
   else{
       
   }
   

4. 嵌套的if结构

   // 语法
   if(布尔表达式1){
       if(布尔表达式2){
           
       }
   }
   

5. switch多选择结构

   1. 判断变量的值是否相等

   2. 语法格式

      switch(expreesion){
          case value:
              // 语句
              break;//可选
          case value:
              // 语句
              break;//可选
          default://可选
              //语句
      }
      

   3. JDK7开始支持字符串的比较

   4. 反编译-（IDEA）

循环结构

1. while循环

   1. while是最基本的循环

   2. 语法格式

      while(表达式){
          // 循环内容
      }
      

   3. 我们大多数情况会让循环停止下来的，我们需要一个让表达式失效的方法来结束循环

2. do…while循环

   1. do…while循环至少会执行一次

   2. 语法格式

      do{
          // 循环内容
      }while()
      

3. for循环

   1. 语法格式

      for(初始化;布尔表达式;更新){
          // 循环内容
      }
      

   2. 是最有效、最灵活的循环结构

   3. 增强for循环

      // 遍历数组元素
      
      int[] numbers={1,2,3,4};//定义一个数组
      for(int x:numbers){
          // 根据数组进行遍历
      }
      

break，continue

1. break终止循环
2. continue终止本次循环
3. goto关键字
   1. Java没有goto
   2. 标签

练习

1. 打印星星
2. Debug-断点

java方法详解

何谓方法

1. 解决方法有序的组合
2. 方法包含于类或对象中
3. 方法再程序中被创建 ，再其他地方被引用
4. 一个方法只完成一个功能，这又有利于我们后期扩展

方法的定义及调用

1. 类似函数，用来完成特定功能的代码片段

2. 方法包含一个方法头和一个方法体

   1. 修饰符
   2. 返回值类型
   3. 方法名
   4. 参数类型
   5. 方法体

3. 语法格式

   // 语法格式
   修饰符 返回值类型 方法名（参数类型 参数名）{
       方法体
   }
   

4. 形式参数，用来定义作用的

5. 实际参数，实际调用传递给他的参数

6. 方法的调用

   1. 对象.方法名（实力参数）
   2. 值传递（Java）

方法重载

1. 方法名称必须相同
2. 参数列表必须不同
3. 方法的返回值类型可以相同也可以不相同
4. 仅仅返回类型不同不足以成为方法的重载
5. 根据参数自动匹配

命令行传递参数

1. javac 类名
2. java 包名

可变参数

1. 在指定参数类型后加一个省略号（…）

2. 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在它之前声明

3. 相关案例

   public static void main(String[0]args) i
   	Demoe demoe = new Demoe();	
   	demoe4.test(1,2,3,4);
   }
   public void test(int... i){
       system.out.print1n(i[0]);
   }
   
   

递归讲解

1. 自己调用自己
2. 递归结构包括两个部分
   1. 递归头：什么时候不调用自身方法，如果没有头，将陷入死循环。
   2. 递归体：什么时候需要调用自身方法。
3. 使用栈机制
4. 主要学习递归思想

数组

数组概述

1. 数组是相同类型数据的有序集合
2. 描述若干个数据，按一定的先后顺序组合而成
3. 每个数据成为数组元素，可以使用下标来访问它们

数组声明创建

1. 首先必须声明数组变量，才能在程序中使用数组，

   dataType[] arrayRefVar;// 首选
   或
   dataType arrayRefVar[];// 效果相同，但是不是首选
   

2. Java语言使用new操作符来创建数组

   dataType[] arrayRefVar=new dataType[arrayRefVar];
   

3. 数组元素是通过索引访问的，数组索引从0开始

4. 获取数组长度：arrays.length

三种初始化及内存分析

1. Java内存

   1. 堆
   2. 栈
   3. 方法区

2. 三种初始化

   1. 静态初始化

      // 静态初始化：创建+赋值
      int[] a={1,2,3,4,5};
      

   2. 动态初始化

      // 动态初始化
      int[] b=new int[10];
      

   3. 数据默认初始化

数组下标界及小结

1. 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

2. 其元素必须是相同类型,不允许出现混合类型。

3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。

4. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

5. 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

6. 下标合法区间：[0,length-1]

数组的使用

1. 下标使用-for循环

2. for-each循环-没有下标

3. 打印数组元素方法

   1. 输出数组

   2. 反转数组

      for(int i=0,j=result.lengtj-1;i<arrays.length;i++,j--){
          result[j]=arrays[i];
      }
      

多维数组

1. 可以看成数组的数组-数组的嵌套

   int[][] arrays={{1,2},{2,4}};
   

2. 二维数组

   int a[][]=new int[2][5];
   

Arrays类

1. 查看JDK文档
2. 不建议重复造轮子
3. 常用方法
   1. toString方法
   2. fill方法
   3. sort方法

冒泡排序

1. 两层循环，外层冒泡层次，内存数值比较
   1. 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位子
   2. 每次比较，都会产生一个最大，或最小的数字
   3. 下一轮则可以少一次排序
   4. 一次循环，直到结束

稀疏数组

1. 数据结构

2. 压缩算法

3. 大部分都为0，或相同

4. 处理方法

   1. 记录数组几行几列
   2. 把不同值的元素和行列值记录在一个小规模的数组中

   // 正常创建
   int[][] array1=new int[11][11];
   array1[1][2]=1;
   array1[2][3]=1;
   
   // 转换成稀疏数组
   int sum=0;
   for(int i=0;i<11;i++){
       for(int j=0;j<11;j++){
           if(array1[i][j]!=0)
               sum++;
       }
   }
   // 创建一个二维数组，将非零的值，存放稀疏数组中
   int[][] array2=new int[sum+1][3];
   array2[0][0]=11;
   array2[0][1]=11;
   array2[0][2]=sum;
   // 记录稀疏数组
   int count=e;
   for (int i = e; i < array1.length ; i++) {
       for (int j - e; j < array1[i].length; j++) {
           if ( array1[i][j]!=0){
               count++;
               array2[count][0] = i;
               array2[count][1] = j;
               array2[countj][2] = array1[i][j];
           }
       }
   }
   // 还原稀疏数组
   //1.读取稀疏数组
   int[][]array3 = new int[array2[0][0]][array2[0][1]];
   //2.给其中的元素还原它的值
   for (int i = 1; i < array2.length; i++) {
       array3[array2[i][0]][array2[i][1]] = array2[i][2];
   }
   

---

面向对象编程

面向对象与面向过程

1. 面向过程
   1. 线性步骤
2. 面向对象
   1. 物以类聚-分类思想
   2. 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
   3. 以类的方式组织代码，以对象的组织(封装)数据。
   4. 抽象
   5. 封装，继承，多态

回顾方法的定义

1. 方法的定义

   1. 修饰符返回类型
   2. break:跳出switch，结束循环和return的区别
   3. 方法名:注意规范就OK见名知意
   4. 参数列表:(参数类型，参数名)…
   5. 异常抛出

   修饰符 返回值类型 方法名（）{
       // 方法体
       return 返回值；
   }
   // break,continue
   

2. 方法的调用

   1. 静态方法直接使用，非静态方法，需要实例化后才能使用
   2. 静态方法
   3. 非静态方法
   4. 形参和实参
   5. 值传递和引用传递
      1. 值传递
      2. 引用传递->对象，本质还是值传递
   6. this关键字

类与对象的关系

1. 类
   1. 类是一种抽象的数据类型,它是对某一类事物整体描述定义,但是并不能代表某一个具体的事物.
   2. 抽象的
2. 对象
   1. 对象是抽象概念的具体实例
   2. 具体的

创建与初始化类与对象

1. 一个项目应该只存在一个main方法
2. 类
   1. 属性：字段
   2. 方法
   3. 使用new关键字创建对象
3. 学程序好？对世界进行更好的建模

构造器的详解

1. 一个类，即使什么都不写，他也会存在一个方法
2. 构造器作用
   1. 使用new关键字，必须要有构造器，本质是在调用构造器
   2. 用来初始化值
   3. alt+insert
3. 构造器创建
   1. 和类名相同
   2. 没有返回值
4. 注意点
   1. 一旦定义了有参构造，无参就必须显示定义

创建对象内存分析

简单小结类与对象

1. 类与对象
   1. 类是一个模板:抽象，对象是一个具体的实例
   2. 方法定义、调用!
   3. 对应的引用
      1. 引用类型:基本类型(8)
      2. 对象是通过引用来操作的:栈—>堆
   4. 属性:字段Field成员变量
      1. 默认初始化:
         1. 数字
         2. char
         3. boolean
         4. 引用
         5. 修饰符﹑属性类型属性名=属性值!
   5. 对象的创建和使用
      1. -必须使用new关键字创造对象，构造器Person kuangshen = new Person( );
      2. -对象的属性uangshen.name
      3. -对象的方法euangshen.sLeep()
   6. 类;
      静态的属性 属性
      动态的行为 方法
   7. 封装、继承、多态

封装

1. 该露就露，改藏就藏
   1. 高内聚，低耦合
   2. 类的内部数据操作细节自己完成，不允许外部干涉
   3. 仅暴露少量的方法给外部使用
2. 数据隐藏
3. 属性私有，get/set
   1. private-私有数据
   2. get/set
      1. 提供一些public的get，set方法
   3. alt+insert
4. 封装的意义
   1. 提高程序的安全性，保护数据
   2. 隐藏代码的实现细节
   3. 统一接口
   4. 系统的可维护增加了
5. 方法的重载
   1. 方法名，参数列表

继承

1. 继承本质上对某一批类的继承，对世界更好的建模
2. extands的意思是扩展，子类是父类的扩展
3. Java类中只有单继承，没有多继承
4. CTRL+H-查看继承情况
5. 在Java中，所有的类，都默认直接或间接继承object
6. object类

Super详解

1. 父类的属性和方法
2. 私有的东西无法被继承
3. 子类继承，默认先执行父类的无参构造-调用父类的构造器，必须放在子类构造器的第一行
4. 注意点
   1. super调用父类的构造方法，必须在构造方法的第一个
   2. super必须只能出现在子类的方法或者构造方法中
   3. super和this不能同时调用构造方法
5. Vs this
   1. 代表对象不同：
      1. this 本身调用者这个对象
      2. super 代表父类对象的应用
   2. 前提
      1. this 没有继承也可以使用
      2. super 只能在继承条件下才可以使用
   3. 构造方法
      1. this（） 本类的构造
      2. super（） 父类的构造

方法的重写

1. 重写都是方法的重写，与属性无关
2. 父类的引用指向了子类
3. 静态方法和非静态方法不一样
4. 需要有继承关系，子类重写父类的方法
   1. 方法名必须相同
   2. 参数列表必须相同
   3. 修饰符：范围可以扩大
   4. 抛出的异常：范围可以被缩小，但是不能扩大
5. 重写，子类的方法和父类必须一致，方法体不同
6. alt+insert

什么是多态

1. 动态编译：类型：可扩展性
2. 一个对象的实际类型是确定的
3. 可以指向的引用类型就不确定
4. 父类引用指向子类
5. 对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
6. person 父类型，可以指向子类，但是不能调用子类独有的方法
7. 注意事项
   1. 多态是方法的多态，属性没有多态
   2. 父类和子类，有联系 类型转换异常
   3. 存在条件：继承关系，方法需要重写，父类的引用指向子类对象
   4. 以下内容不能重写
      1. static方法，属于类，不属于实例
      2. final 常量
      3. private方法

instanceof和类型转换

1. 判断一个对象时什么类型，判断是否存在父子类关系

   System.out.println(x instanceof y);
   // 能不能编译通过，X,Y的关系
   

2. 有关系才能使用instanceof

3. 类型之间的转化

   1. 基本类型转换
   2. 父子之间的转换
      1. 高转低需要强制转换
      2. 子类转换为父类可能丢失原来的一些方法

4. 注意点：

   1. 父类引用指向子类对象
   2. 把子类转换为父类，向上转型
   3. 把父类转换为子类，向下转型，强制转换
   4. 方便方法的钓鱼呢，减少重复的代码
   5. 抽象思想

static详解

1. 类的字段

2. 静态变量

3. 执行顺序：静态代码块（只执行一次），匿名代码块，构造方法

4. 静态导入包

      import static java.lang.Math.random;
   

抽象类

1. abstract进行代码的修饰
2. 约束
3. 抽象类的所有方法，继承了它的子类，都必须需要实现它的方法
4. 抽象方法，只有方法名字，没有方法的实现
5. extends-单继承
6. 接口可以多继承
7. 注意点：
   1. 不能new这个抽象类，只能靠子类去实现它，约束
   2. 抽象类可以写普通方法
   3. 抽象方法必须卸载抽象类中
   4. 抽象的抽象：约束
8. 抽象类存在构造器嘛？
9. 抽象类存在的意义？

接口

1. 普通类:只有具体实现
2. 抽象类:具体实现和规范(抽象方法)都有!
3. 接口:只有规范!自己无法写方法~专业的约束，约束和实现分离，面向接口编程
4. 接口就是规范，定义一组规则，
5. 接口的本质是契约
6. 通过 interface进行定义
7. 接口中的所有定义其实都是抽象的-publice abstract
8. 接口都需要实现类
9. 类可以实现一个接口，impements
10. 实现了接口的类，就需要重写接口中的方法
11. 利用接口实现多继承
12. 作用
    1. 约束
    2. 定义一些方法，让不同的人实现
    3. public abstract
    4. public static final
    5. 接口不能被实例化，接口中没有构造方法
    6. implements可以实现多个接口
    7. 必须要重写接口中的方法
    8. 总结博客

内部类

1. 成员内部类

   1. 通过类来实例化内部类

   2. outer.new Inner();
      

2. 静态内部类

3. 局部内部类

   1. 一个Java中可以有多个class类，但是只能由一个public类

4. 匿名内部类

   1. 没有名字的初始化类，不用将实例保存到变量中

---

异常机制

Error和Exception

1. 异常机制
   1. 程序报错，异常
   2. 检查性异常
   3. 运行时异常
   4. 错误
2. Error
   1. 虚拟机异常
   2. 运行时异常
3. Exception
   1. 逻辑错误
   2. 非运行时异常
4. Error时致命性错误，Exception尽可能处理异常

捕获和抛出异常

1. 抛出异常
2. 捕获异常
   1. try{}-监控异常
   2. catch(){}-捕获
      1. （）参数的捕获类型
      2. 可以多层异常嵌套进行-层层递进
      3. ERROR->Exception->Throwable
      4. 从小到大的捕获异常
   3. finally{}-善后
      1. IO,资源，关闭
      2. 可以不用
3. CTRL+ALT+T
4. 主动的抛出异常 throw throws-一般在方法中使用
5. 发现处理不了的异常也可以主动抛出

自定义异常，小结

1. 自定义异常的使用-框架
   1. 创建自定义异常类。-继承Exception
   2. 在方法中通过throw关键字抛出异常对象/构造器。
   3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
   4. 在出现异常方法的调用者中捕获并处理异常。
2. 处理异常
   1. 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
   2. 在多重catch块后面，可以加一个catch (Exception)来处理可能会被遗漏的异常
   3. 对于不确定的代码，也可以加上 try-catch，处理潜在的异常
   4. 尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出具体如何处理异常，要根据不同的业务需求和异常类型去决定
   5. 尽量添加finally语句块去释放占用的资源