常用API与异常

秒速五厘米 2023-10-14 06:22 127阅读 0赞

#### 常用API与异常 ####

*  1.API
 *   *  API概述-帮助文档的使用
     *  常用API
     *   *  2.1 Math
         *  2.2 System
         *  2.3 Object类的toString方法
         *  2.4BigDecimal
     *  键盘录入字符串
     *  String类
     *   *  String概述
         *  String类的构造方法
     *  创建字符串对象的区别对比
     *  字符串的比较
     *  遍历字符串案例
     *  统计字符次数案例
     *  手机号屏蔽-字符串截取
     *  敏感词替换-字符串替换
     *  StringBuilder类
     *   *  StringBuilder类和String类的区别
         *  StringBuilder常用的成员方法
         *  StringBuilder和String相互转换
 *  2.包装类
 *   *  基本类型对应的包装类
     *  自动拆箱和自动装箱
     *  int和String类型的相互转换
 *  3.时间日期类
 *   *  3.1 Date类
     *  3.2 Date类常用方法
     *  3.3 SimpleDateFormat类
 *  4.异常
 *   *  编译时异常和运行时异常的区别
     *   *  JVM默认处理异常的方式（理解）
     *  throws方式处理异常
     *  throw抛出异常
     *  try-catch方式处理异常
     *  Throwable成员方法
     *  自定义异常

## 1.API ##

### API概述-帮助文档的使用 ###

*  什么是API
    
    API (Application Programming Interface) ：应用程序编程接口
 *  java中的API
    
    指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。
    
    **如何使用API帮助文档 :**
 *  打开帮助文档
 *  找到索引选项卡中的输入框
 *  在输入框中输入Random
 *  看类在哪个包下
 *  看类的描述
 *  看构造方法
 *  看成员方法

### 常用API ###

#### 2.1 Math ####

*  1、Math类概述
    
     *  Math 包含执行基本数字运算的方法
 *  2、Math中方法的调用方式
    
     *  Math类中无构造方法，但内部的方法都是静态的，则可以通过 **类名.进行调用**
 *  3、Math类的常用方法
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名 方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>public static int abs(int a)</td> 
       <td>返回参数的绝对值</td> 
      </tr> 
      <tr> 
       <td>public static double ceil(double a)</td> 
       <td>返回大于或等于参数的最小double值，等于一个整数</td> 
      </tr> 
      <tr> 
       <td>public static double floor(double a)</td> 
       <td>返回小于或等于参数的最大double值，等于一个整数</td> 
      </tr> 
      <tr> 
       <td>public static int round(float a)</td> 
       <td>按照四舍五入返回最接近参数的int</td> 
      </tr> 
      <tr> 
       <td>public static int max(int a,int b)</td> 
       <td>返回两个int值中的较大值</td> 
      </tr> 
      <tr> 
       <td>public static int min(int a,int b)</td> 
       <td>返回两个int值中的较小值</td> 
      </tr> 
      <tr> 
       <td>public static double pow (double a,double b)</td> 
       <td>返回a的b次幂的值</td> 
      </tr> 
      <tr> 
       <td>public static double random()</td> 
       <td>返回值为double的正值，[0.0,1.0)</td> 
      </tr> 
     </tbody> 
    </table>

#### 2.2 System ####

System类的常用方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static void exit(int status)</td> 
   <td>终止当前运行的 Java 虚拟机，非零表示异常终止</td> 
  </tr> 
  <tr> 
   <td>public static long currentTimeMillis()</td> 
   <td>返回当前时间(以毫秒为单位)</td> 
  </tr> 
 </tbody> 
</table>

示例代码

*  需求：在控制台输出1-10000，计算这段代码执行了多少毫秒

public class SystemDemo {
        
        public static void main(String[] args) {
        
            // 获取开始的时间节点
            long start = System.currentTimeMillis();
            for (int i = 1; i <= 10000; i++) {
        
                System.out.println(i);
            }
            // 获取代码运行结束后的时间节点
            long end = System.currentTimeMillis();
            System.out.println("共耗时：" + (end - start) + "毫秒");
        }
    }

#### 2.3 Object类的toString方法 ####

*  Object类概述
    
     *  Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类，换句话说，该类所具备的方法，所有类都会有一份
 *  查看方法源码的方式
    
     *  选中方法，按下Ctrl + B
 *  重写toString方法的方式
    
     *  1.  Alt + Insert 选择toString
     *  1.  在类的空白区域，右键 -> Generate -> 选择toString
 *  toString方法的作用：
    
     *  以良好的格式，更方便的展示对象中的属性值
    
    #### 2.4BigDecimal ####
    
     *  作用
    
    可以用来进行精确计算

*  构造方法
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>BigDecimal(double val)</td> 
       <td>参数为double</td> 
      </tr> 
      <tr> 
       <td>BigDecimal(String val)</td> 
       <td>参数为String</td> 
      </tr> 
     </tbody> 
    </table>
 *  常用方法
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>public BigDecimal add(另一个BigDecimal对象)</td> 
       <td>加法</td> 
      </tr> 
      <tr> 
       <td>public BigDecimal subtract (另一个BigDecimal对象)</td> 
       <td>减法</td> 
      </tr> 
      <tr> 
       <td>public BigDecimal multiply (另一个BigDecimal对象)</td> 
       <td>乘法</td> 
      </tr> 
      <tr> 
       <td>public BigDecimal divide (另一个BigDecimal对象)</td> 
       <td>除法</td> 
      </tr> 
      <tr> 
       <td>public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式)</td> 
       <td>除法</td> 
      </tr> 
     </tbody> 
    </table>
 *  总结
    
    1.  BigDecimal是用来进行精确计算的
    2.  创建BigDecimal的对象，构造方法使用参数类型为字符串的。
    3.  四则运算中的除法，如果除不尽请使用divide的三个参数的方法。

### 键盘录入字符串 ###

**Scanner类 :**

next() : 遇到了空格, 就不再录入数据了 , 结束标记: 空格, tab键

nextLine() : 可以将数据完整的接收过来 , 结束标记: 回车换行符

### String类 ###

#### String概述 ####

1 String 类在 java.lang 包下，所以使用的时候不需要导包
    
    	2 String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象
    
    	3 字符串不可变，它们的值在创建后不能被更改

#### String类的构造方法 ####

public class Demo2StringConstructor {
        
        /*
            String类常见构造方法:
    
                public String() : 创建一个空白字符串对象，不含有任何内容
                public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
                public String(String original) : 根据传入的字符串内容，来创建字符串对象
                String s = “abc”;  直接赋值的方式创建字符串对象，内容就是abc
    
             注意:
                    String这个类比较特殊, 打印其对象名的时候, 不会出现内存地址
                    而是该对象所记录的真实内容.
    
                    面向对象-继承, Object类
         */
        public static void main(String[] args) {
        
            // public String() : 创建一个空白字符串对象，不含有任何内容
            String s1 = new String();
            System.out.println(s1);
    
            // public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
            char[] chs = {
        'a','b','c'};
            String s2 = new String(chs);
            System.out.println(s2);
    
            // public String(String original) : 根据传入的字符串内容，来创建字符串对象
            String s3 = new String("123");
            System.out.println(s3);
        }
    }

### 创建字符串对象的区别对比 ###

*  **通过构造方法创建**
    
    通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
 *  **直接赋值方式创建**
    
    以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

### 字符串的比较 ###

*  == 比较基本数据类型：比较的是具体的值
 *  == 比较引用数据类型：比较的是对象地址值

**String类 : public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写**

### 遍历字符串案例 ###

**案例需求 :**

键盘录入一个字符串，使用程序实现在控制台遍历该字符串

import java.util.Scanner;
    
    public class Test2 {
        
        /*
            需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
    
            思路：
            1. 键盘录入一个字符串，用 Scanner 实现
            2. 遍历字符串，首先要能够获取到字符串中的每一个字符
                public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
            3. 遍历字符串，其次要能够获取到字符串的长度
                public int length()：返回此字符串的长度
            4. 遍历打印
    9
         */
        public static void main(String[] args) {
        
            //  1. 键盘录入一个字符串，用 Scanner 实现
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入:");
            String s = sc.nextLine();
            // 2. 遍历字符串，首先要能够获取到字符串中的每一个字符
            for(int i = 0; i < s.length(); i++){
        
                // i : 字符串的每一个索引
                char c = s.charAt(i);
                System.out.println(c);
            }
        }
    }

### 统计字符次数案例 ###

**案例需求 :**

键盘录入一个字符串，使用程序实现在控制台遍历该字符串

import java.util.Scanner;
    
    public class Test3 {
        
        /*
           需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
    
           思路：
           1. 键盘录入一个字符串，用 Scanner 实现
           2. 将字符串拆分为字符数组
                    public char[] toCharArray( )：将当前字符串拆分为字符数组并返回
           3. 遍历字符数组
    
        */
        public static void main(String[] args) {
        
            //  1. 键盘录入一个字符串，用 Scanner 实现
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入:");
            String s = sc.nextLine();
            // 2. 将字符串拆分为字符数组
            char[] chars = s.toCharArray();
            // 3. 遍历字符数组
            for (int i = 0; i < chars.length; i++) {
        
                System.out.println(chars[i]);
            }
        }
    }

### 手机号屏蔽-字符串截取 ###

**案例需求 :**

以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽

import java.util.Scanner;
    
    public class Test5 {
        
        /*
            需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
            最终效果为：156****1234
    
            思路：
            1. 键盘录入一个字符串，用 Scanner 实现
            2. 截取字符串前三位
            3. 截取字符串后四位
            4. 将截取后的两个字符串，中间加上****进行拼接，输出结果
    
         */
        public static void main(String[] args) {
        
            // 1. 键盘录入一个字符串，用 Scanner 实现
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入手机号:");
            String telString = sc.nextLine();
            // 2. 截取字符串前三位
            String start = telString.substring(0,3);
            // 3. 截取字符串后四位
            String end = telString.substring(7);
            // 4. 将截取后的两个字符串，中间加上****进行拼接，输出结果
            System.out.println(start + "****" + end);
        }
    }

### 敏感词替换-字符串替换 ###

**案例需求 :**

键盘录入一个 字符串，如果字符串中包含（TMD），则使用\*\*\*替换

import java.util.Scanner;
    
    public class Test6 {
        
        /*
            需求：键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换
    
            思路：
            1. 键盘录入一个字符串，用 Scanner 实现
            2. 替换敏感词
                    String replace(CharSequence target, CharSequence replacement)
                    将当前字符串中的target内容，使用replacement进行替换，返回新的字符串
            3. 输出结果
    
         */
        public static void main(String[] args) {
        
            // 1. 键盘录入一个字符串，用 Scanner 实现
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入:");
            String s = sc.nextLine();
            // 2. 替换敏感词
            String result = s.replace("TMD","***");
            // 3. 输出结果
            System.out.println(result);
        }
    }

### StringBuilder类 ###

* 概述 :* StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，
    这里的可变指的是 StringBuilder 对象中的内容是可变的

#### StringBuilder类和String类的区别 ####

*  \*\*String类：\*\*内容是不可变的
 *  \*\*StringBuilder类：\*\*内容是可变的

#### StringBuilder常用的成员方法 ####

**添加和反转方法**

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public StringBuilder append(任意类型)</td> 
   <td>添加数据，并返回对象本身</td> 
  </tr> 
  <tr> 
   <td>public StringBuilder reverse()</td> 
   <td>返回相反的字符序列</td> 
  </tr> 
 </tbody> 
</table>

#### StringBuilder和String相互转换 ####

*  **StringBuilder转换为String**
    
    public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
 *  **String转换为StringBuilder**
    
    public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder

public class StringBuilderDemo02 {
        
        public static void main(String[] args) {
        
            /*
            //StringBuilder 转换为 String
            StringBuilder sb = new StringBuilder();
            sb.append("hello");
    
            //String s = sb; //这个是错误的做法
    
            //public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
            String s = sb.toString();
            System.out.println(s);
            */
    
            //String 转换为 StringBuilder
            String s = "hello";
    
            //StringBuilder sb = s; //这个是错误的做法
    
            //public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
            StringBuilder sb = new StringBuilder(s);
    
            System.out.println(sb);
        }
    }

## 2.包装类 ##

### 基本类型对应的包装类 ###

<table> 
 <thead> 
  <tr> 
   <th>基本数据类型</th> 
   <th>包装类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

### 自动拆箱和自动装箱 ###

*  自动装箱
    
    把基本数据类型转换为对应的包装类类型
 *  自动拆箱
    
    把包装类类型转换为对应的基本数据类型
 *  示例代码

Integer i = 100;  // 自动装箱
    i += 200;         // i = i + 200;  i + 200 自动拆箱；i = i + 200; 是自动装箱

### int和String类型的相互转换 ###

int转换为String

*  转换方式
    
     *  方式一：直接在数字后加一个空字符串
     *  方式二：通过String类静态方法valueOf()

public class IntegerDemo {
        
        public static void main(String[] args) {
        
            //int --- String
            int number = 100;
            //方式1
            String s1 = number + "";
            System.out.println(s1);
            //方式2
            //public static String valueOf(int i)
            String s2 = String.valueOf(number);
            System.out.println(s2);
            System.out.println("--------");
        }
    }

String转换为int

*  转换方式
    
     *  方式一：先将字符串数字转成Integer，再调用valueOf()方法
     *  方式二：通过Integer静态方法parseInt()进行转换

public class IntegerDemo {
        
        public static void main(String[] args) {
        
            //String --- int
            String s = "100";
            //方式1：String --- Integer --- int
            Integer i = Integer.valueOf(s);
            //public int intValue()
            int x = i.intValue();
            System.out.println(x);
            //方式2
            //public static int parseInt(String s)
            int y = Integer.parseInt(s);
            System.out.println(y);
        }
    }

## 3.时间日期类 ##

### 3.1 Date类 ###

*  计算机中时间原点
    
    1970年1月1日 00:00:00
 *  时间换算单位
    
    1秒 = 1000毫秒
 *  Date类概述
    
    Date 代表了一个特定的时间，精确到毫秒
 *  Date类构造方法
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>public Date()</td> 
       <td>分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒</td> 
      </tr> 
      <tr> 
       <td>public Date(long date)</td> 
       <td>分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数</td> 
      </tr> 
     </tbody> 
    </table>

public class DateDemo01 {
        
        public static void main(String[] args) {
        
            //public Date()：分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
            Date d1 = new Date();
            System.out.println(d1);
    
            //public Date(long date)：分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
            long date = 1000*60*60;
            Date d2 = new Date(date);
            System.out.println(d2);
        }
    }

### 3.2 Date类常用方法 ###

常用方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public long getTime()</td> 
   <td>获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值</td> 
  </tr> 
  <tr> 
   <td>public void setTime(long time)</td> 
   <td>设置时间，给的是毫秒值</td> 
  </tr> 
 </tbody> 
</table>

public class DateDemo02 {
        
        public static void main(String[] args) {
        
            //创建日期对象
            Date d = new Date();
    
            //public long getTime():获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
    //        System.out.println(d.getTime());
    //        System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");
    
            //public void setTime(long time):设置时间，给的是毫秒值
    //        long time = 1000*60*60;
            long time = System.currentTimeMillis();
            d.setTime(time);
    
            System.out.println(d);
        }
    }

### 3.3 SimpleDateFormat类 ###

*  SimpleDateFormat类概述
    
    SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。
    
    我们重点学习日期格式化和解析
 *  SimpleDateFormat类构造方法
    
    <table> 
     <thead> 
      <tr> 
       <th>方法名</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>public SimpleDateFormat()</td> 
       <td>构造一个SimpleDateFormat，使用默认模式和日期格式</td> 
      </tr> 
      <tr> 
       <td>public SimpleDateFormat(String pattern)</td> 
       <td>构造一个SimpleDateFormat使用给定的模式和默认的日期格式</td> 
      </tr> 
     </tbody> 
    </table>
 *  SimpleDateFormat类的常用方法
    
     *  格式化(从Date到String)
        
         *  public final String format(Date date)：将日期格式化成日期/时间字符串
     *  解析(从String到Date)
        
         *  public Date parse(String source)：从给定字符串的开始解析文本以生成日期

public class SimpleDateFormatDemo {
        
        public static void main(String[] args) 
        {
        
            //格式化：从 Date 到 String
            Date d = new Date();
    //        SimpleDateFormat sdf = new SimpleDateFormat();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
            String s = sdf.format(d);
            System.out.println(s);
            System.out.println("--------");
    
            //从 String 到 Date
            String ss = "2048-08-09 11:11:11";
            //ParseException
            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date dd = sdf2.parse(ss);
            System.out.println(dd);
        }
    }

## 4.异常 ##

*  异常的概述
    
    异常就是程序出现了不正常的情况
 *  异常的体系结构  
    ![在这里插入图片描述][9f1746e06aed44f7a5272e01dbc05e07.png]

### 编译时异常和运行时异常的区别 ###

*  编译时异常
    
     *  都是Exception类及其子类
     *  必须显示处理，否则程序就会发生错误，无法通过编译
 *  运行时异常
    
     *  都是RuntimeException类及其子类
     *  无需显示处理，也可以和编译时异常一样处理
    
    #### JVM默认处理异常的方式（理解） ####
 *  如果程序出现了问题，我们没有做任何处理，最终JVM 会做默认的处理，处理方式有如下两个步骤：
    
     *  把异常的名称，错误原因及异常出现的位置等信息输出在了控制台
     *  程序停止执行
    
    ### throws方式处理异常 ###
    
    定义格式

public void 方法() throws 异常类名 {
        
        
    }

注意事项

*  这个throws格式是跟在方法的括号后面的
 *  编译时异常必须要进行处理，两种处理方案：try…catch …或者 throws，如果采用 throws 这种方案，在方法上进行显示声明,将来谁调用这个方法谁处理
 *  运行时异常因为在运行时才会发生,所以在方法后面可以不写,运行时出现异常默认交给jvm处理

### throw抛出异常 ###

*  格式
    
    throw new 异常();
 *  注意
    
    这个格式是在方法内的，表示当前代码手动抛出一个异常，下面的代码不用再执行了
 *  throws和throw的区别
    
    <table> 
     <thead> 
      <tr> 
       <th>throws</th> 
       <th>throw</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>用在方法声明后面，跟的是异常类名</td> 
       <td>用在方法体内，跟的是异常对象名</td> 
      </tr> 
      <tr> 
       <td>表示声明异常，调用该方法有可能会出现这样的异常</td> 
       <td>表示手动抛出异常对象，由方法体内的语句处理</td> 
      </tr> 
     </tbody> 
    </table>

### try-catch方式处理异常 ###

定义格式

try {
        
    	可能出现异常的代码;
    } catch(异常类名 变量名) {
        
    	异常的处理代码;
    }

执行流程

*  程序从 try 里面的代码开始执行
 *  出现异常，就会跳转到对应的 catch 里面去执行
 *  执行完毕之后，程序还可以继续往下执行

public class ExceptionDemo01 {
        
        public static void main(String[] args) {
        
            System.out.println("开始");
            method();
            System.out.println("结束");
        }
    
        public static void method() {
        
            try {
        
                int[] arr = {
        1, 2, 3};
                System.out.println(arr[3]);
                System.out.println("这里能够访问到吗");
            } catch (ArrayIndexOutOfBoundsException e) {
        
                System.out.println("你访问的数组索引不存在，请回去修改为正确的索引");
            }
        }
    }

![在这里插入图片描述][544978b038464fad93582000fd056a22.png]  
注意

1.  如果 try 中没有遇到问题，怎么执行？
    
    会把try中所有的代码全部执行完毕,不会执行catch里面的代码
2.  如果 try 中遇到了问题，那么 try 下面的代码还会执行吗？
    
    那么直接跳转到对应的catch语句中,try下面的代码就不会再执行了  
    当catch里面的语句全部执行完毕,表示整个体系全部执行完全,继续执行下面的代码
3.  如果出现的问题没有被捕获，那么程序如何运行？
    
    那么try…catch就相当于没有写.那么也就是自己没有处理.  
    默认交给虚拟机处理.
4.  同时有可能出现多个异常怎么处理？
    
    出现多个异常,那么就写多个catch就可以了.  
    注意点:如果多个异常之间存在子父类关系.那么父类一定要写在下面
    
    ### Throwable成员方法 ###
    
    常用方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public String getMessage()</td> 
   <td>返回此 throwable 的详细消息字符串</td> 
  </tr> 
  <tr> 
   <td>public String toString()</td> 
   <td>返回此可抛出的简短描述</td> 
  </tr> 
  <tr> 
   <td>public void printStackTrace()</td> 
   <td>把异常的错误信息输出在控制台</td> 
  </tr> 
 </tbody> 
</table>

### 自定义异常 ###

*  自定义异常概述
    
    当Java中提供的异常不能满足我们的需求时,我们可以自定义异常
 *  实现步骤
    
    1.  定义异常类
    2.  写继承关系
    3.  提供空参构造
    4.  提供带参构造  
        **代码实现**

异常类

public class AgeOutOfBoundsException extends RuntimeException {
        
        public AgeOutOfBoundsException() {
        
        }
    
        public AgeOutOfBoundsException(String message) {
        
            super(message);
        }
    }

学生类

public class Student {
        
        private String name;
        private int age;
    
        public Student() {
        
        }
    
        public Student(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            if(age >= 18 && age <= 25){
        
                this.age = age;
            }else{
        
                //如果Java中提供的异常不能满足我们的需求,我们可以使用自定义的异常
                throw new AgeOutOfBoundsException("年龄超出了范围");
            }
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

测试类

public class ExceptionDemo12 {
        
        public static void main(String[] args) {
        
            // 键盘录入学生的姓名和年龄,其中年龄为 18 - 25岁,
            // 超出这个范围是异常数据不能赋值.需要重新录入,一直录到正确为止。
    
            Student s = new Student();
    
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入姓名");
            String name = sc.nextLine();
            s.setName(name);
           while(true){
        
               System.out.println("请输入年龄");
               String ageStr = sc.nextLine();
               try {
        
                   int age = Integer.parseInt(ageStr);
                   s.setAge(age);
                   break;
               } catch (NumberFormatException e) {
        
                   System.out.println("请输入一个整数");
                   continue;
               } catch (AgeOutOfBoundsException e) {
        
                   System.out.println(e.toString());
                   System.out.println("请输入一个符合范围的年龄");
                   continue;
               }
               /*if(age >= 18 && age <=25){
                   s.setAge(age);
                   break;
               }else{
                   System.out.println("请输入符合要求的年龄");
                   continue;
               }*/
           }
            System.out.println(s);
    
        }
    }

[9f1746e06aed44f7a5272e01dbc05e07.png]: https://img-blog.csdnimg.cn/9f1746e06aed44f7a5272e01dbc05e07.png
[544978b038464fad93582000fd056a22.png]: https://img-blog.csdnimg.cn/544978b038464fad93582000fd056a22.png