一.Exception
自定义普通的异常:如果说输入的数字不符合我们的功能，然后就报异常。
* 1.创建一个类继承Exception类。Exception类是编译时异常。
* 2.写两个构造函数，一个有参数的，一个无参数的。
package Exception; import java.util.Scanner; /* * 自定义普通的异常:如果说输入的数字不符合我们的功能，然后就报异常。 * 1.创建一个类继承Exception类。Exception类是编译时异常。 * 2.写两个构造函数，一个有参数的，一个无参数的。 * */ public class demoException { public static void main(String[] args) { try { test1(); } catch (NumException e) { // TODO Auto-generated catch block e.printStackTrace(); } } class NumException extends Exception{ //String message="输入数字有误!" public NumException(String message){ super(message); //把异常信息传给父类，那么父类就可以获取了。 } } public static void test1 ()throws NumException { System.out.println("请选择功能：1.登录 2.注册 3.退出"); Scanner scanner=new Scanner(System.in);//创建一个扫描器类对象 int num=scanner.nextInt();//获取输入的整数 switch (num) { case 1: System.out.println("开始登录!"); break; case 2: System.out.println("开始注册"); break; case 3: System.out.println("退出！"); break; default: break; } } }
二.Throw
* 手动抛出异常：可以根据你的意思来抛出异常
*
* throw跟throws的区别：
* 1.throw是在方法体中，throws是在方法声明上。
* 2.throw是抛出异常对象。throws是抛出异常类名。
* 3.throw是可以根据你的标准来抛出异常。
package Exception; /* * 手动抛出异常：可以根据你的意思来抛出异常 * * throw跟throws的区别： * 1.throw是在方法体中，throws是在方法声明上。 * 2.throw是抛出异常对象。throws是抛出异常类名。 * 3.throw是可以根据你的标准来抛出异常。 */ public class demoThrow { public static void main(String[] args) { // try { // cun(1000); // } catch (Exception e) { // // TODO Auto-generated catch block // e.printStackTrace(); // } // cun3(-1000); System.out.println("存钱结束"); } public static void cun(double money)throws Exception { if(money<0) { throw new Exception("钱不能是负数");//编译时抛出异常 } System.out.println("存了"+money); } public static void cun2(double qian) throws Exception { if(qian<0){ throw new Exception("存钱不能为负数");//抛的编译时异常 } System.out.println("存了"+qian); } //它是运行时异常，所以不需要处理，可以运行，但是如果有异常，最后还是有异常。 public static void cun3(double qian) { if(qian<0){ throw new RuntimeException("存钱不能为负数");//抛的编译时异常 } System.out.println("存了"+qian); } }
三.Throws
* throws抛出异常的特点：
* 1.抛出异常要一直抛出，直到抛到最终点，抛给main函数。
* 2.如果有异常，结果还是有异常，只不过可以运行。
* 3.抛出异常可以让编译时异常可以运行。
* 4.抛出异常，不会执行后面的代码。
package Exception; import java.io.FileNotFoundException; import java.io.FileReader; /* * throws抛出异常的特点： * 1.抛出异常要一直抛出，直到抛到最终点，抛给main函数。 * 2.如果有异常，结果还是有异常，只不过可以运行。 * 3.抛出异常可以让编译时异常可以运行。 * 4.抛出异常，不会执行后面的代码。 */ public class demoThrows { public static void main(String[] args) throws FileNotFoundException,ArithmeticException{ //test1(); test2(); } public static void test2() throws ArithmeticException{ int a=1/0; } public static void test1() throws FileNotFoundException{ /* * FileReader:字符输入流 读取文件 * 默认路径是在项目下面 */ FileReader fileReader=new FileReader("aa2.txt"); System.out.println(2); } } //Exception in thread "main" java.io.FileNotFoundException: aa2.txt (系统找不到指定的文件。) //at java.io.FileInputStream.open0(Native Method) //at java.io.FileInputStream.open(Unknown Source) //at java.io.FileInputStream.<init>(Unknown Source) //at java.io.FileInputStream.<init>(Unknown Source) //at java.io.FileReader.<init>(Unknown Source) //at Exception.demoThrows.test1(demoThrows.java:24) //at Exception.demoThrows.main(demoThrows.java:16)
四.tryCatch
* 抓异常的格式：
* try{
* 这里面放可能出现异常的代码;
* }catch(异常的类名 对象名){
* 有异常以后，处理异常的代码;
* 如果没有异常，就不会执行；
* }
*
*
*
* try catch的特点：
* 1.抓异常以后，不用再抛出
* 2.抓异常以后，后面的代码还可以执行，try里面紧跟的代码是不能执行的。
*
* printStackTrace():打印输出异常类名，异常信息和异常行号
*/
package Exception; import java.io.FileNotFoundException; import java.io.FileReader; /* * 抓异常的格式： * try{ * 这里面放可能出现异常的代码; * }catch(异常的类名 对象名){ * 有异常以后，处理异常的代码; * 如果没有异常，就不会执行； * } * * * * try catch的特点： * 1.抓异常以后，不用再抛出 * 2.抓异常以后，后面的代码还可以执行，try里面紧跟的代码是不能执行的。 * * printStackTrace():打印输出异常类名，异常信息和异常行号 */ public class demoTryCatch { public static void main(String[] args) { //test1(); test2(); } public static void test2(){ try { int a=1/0; System.out.println(1); } catch (ArithmeticException e) { //从这开始两条路 e.printStackTrace();//打印输出异常类名，异常信息和异常行号 } System.out.println(2); } public static void test1() { try { FileReader fileReader=new FileReader("a.txt"); System.out.println("1111"); //上面有异常，22不会执行；如果没有异常，会执行。 } catch (FileNotFoundException e) { e.printStackTrace();//打印输出异常类名，异常信息和异常行号 } System.out.println("22222"); } // java.io.FileNotFoundException: a.txt (系统找不到指定的文件。) // 22222 // at java.io.FileInputStream.open0(Native Method) // at java.io.FileInputStream.open(Unknown Source) // at java.io.FileInputStream.<init>(Unknown Source) // at java.io.FileInputStream.<init>(Unknown Source) // at java.io.FileReader.<init>(Unknown Source) // at Exception.demoTryCatch.test1(demoTryCatch.java:29) // at Exception.demoTryCatch.main(demoTryCatch.java:25) }
五.TryCatchCatch
* 处理多个异常的格式：
* try{
* 可能出现异常的代码;
* 可能出现异常的代码;
* 可能出现异常的代码;
* }catch(){
* 处理一个异常信息
* }catch(){
* 处理另一个异常信息
* }.....
*
package Exception; import java.io.FileNotFoundException; import java.io.FileReader; /* * 处理多个异常的格式： * try{ * 可能出现异常的代码; * 可能出现异常的代码; * 可能出现异常的代码; * }catch(){ * 处理一个异常信息 * }catch(){ * 处理另一个异常信息 * }..... * */ public class demoTryCatchCatchCatch { public static void main(String[] args) { // try { // FileReader fileReader=new FileReader("a.txt"); // Thread.sleep(1000); // } catch (Exception e) { // e.printStackTrace(); // } test1(); } public static void test3() throws FileNotFoundException, InterruptedException{ FileReader fileReader=new FileReader("aa.txt"); Thread.sleep(100); } //这是新的 public static void test2(){ try { FileReader fileReader=new FileReader("aa.txt"); Thread.sleep(100); } catch (FileNotFoundException | InterruptedException e) { e.printStackTrace(); } } //这是以前大众的 public static void test1(){ try { FileReader fileReader=new FileReader("aa.txt"); Thread.sleep(100); }catch (FileNotFoundException e) { e.printStackTrace(); }catch (InterruptedException e) { e.printStackTrace(); }catch(Exception e){ e.printStackTrace(); } } }
六.Finally
* 格式：
* try{
*
* }catch(){
*
* }catch(){
*
* }.....{
*
*
* }finally{
* 不管有没有异常，都会执行! return都不能阻止它的脚步
* 除非System.exit(0);结束jvm
* }
*
* final跟finally的区别：
* final:
* 1.修饰类，类不可以被继承
* 2.修饰函数，函数不可以被重写，复写，覆盖。可以重载。
* 3.修饰变量，变量是常量。
*
* finally:
* 1.是跟try catch组合，不管有没有异常都会执行。
*/
package Exception; import java.io.FileNotFoundException; import java.io.FileReader; /* * 格式： * try{ * * }catch(){ * * }catch(){ * * }.....{ * * * }finally{ * 不管有没有异常，都会执行! return都不能阻止它的脚步 * 除非System.exit(0);结束jvm * } * * final跟finally的区别： * final: * 1.修饰类，类不可以被继承 * 2.修饰函数，函数不可以被重写，复写，覆盖。可以重载。 * 3.修饰变量，变量是常量。 * * finally: * 1.是跟try catch组合，不管有没有异常都会执行。 */ public class demoFinally { public static void main(String[] args) { try { FileReader fileReader=new FileReader("aa.txt"); System.exit(0); //结束jvm // return ; //结束函数 } catch (FileNotFoundException e) { e.printStackTrace(); }finally { System.out.println("执行了finally!"); } System.out.println("game over!"); } //可以重载：函数名一致，参数类型或者参数个数不一致。 public final void test1(){ try { // FileReader fileReader=new FileReader("aa.txt"); int a=1/0; } finally { System.out.println("执行了finally"); } } public final void test1(int a){ } }
七.getMessage
* 获取异常信息三种方式：
* 1.getMessage() : 获取异常信息
* 2.toString() : 获取异常类名和异常信息
* 3.printStackTrace():打印输出异常类名，异常信息和异常行号。是void型的函数
package Exception; /* * 获取异常信息三种方式： * 1.getMessage() : 获取异常信息 * 2.toString() : 获取异常类名和异常信息 * 3.printStackTrace():打印输出异常类名，异常信息和异常行号。是void型的函数 */ public class demoGetMessage { public static void main(String[] args) { try { int i=1/0; } catch (ArithmeticException e) { // System.out.println("有异常，不能除以0"); // String message=e.getMessage();//获取异常信息 // System.out.println("message="+message); //获取异常类名和异常信息 String string=e.toString();//对象变成字符串，返回对象的字符串表示形式 System.out.println("string="+string); e.printStackTrace(); } } }