19.01
程序的异常：Throwable * 严重问题：Error 我们不处理。这种问题一般都是很严重的，比如说内存溢出。 * 问题：Exception * 编译期问题:不是RuntimeException的异常 必须进行处理的，因为你不处理，编译就不能通过。 * 运行期问题:RuntimeException 我们的代码不够严谨，需要修正代码的。
1.1 如何处理异常：
* A:try...catch...finally * B:throws 抛出 * * try...catch...finally的处理格式： * try { * 可能出现问题的代码; * }catch(异常名 变量) { * 针对问题的处理; * }finally { * 释放资源; * } * * 变形格式： * try { * 可能出现问题的代码; * }catch(异常名 变量) { * 针对问题的处理; * } * * 注意： * A:try里面的代码越少越好 * B:catch里面必须有内容，哪怕是给出一个简单的提示
public static void main(String[] args) { int a = 10; int b = 0; try { System.out.println(a / b); } catch (ArithmeticException ae) { System.out.println("除数不能为0"); } System.out.println("over"); }
public class day16_01 { /* * 我们自己如何处理异常呢? * A:try...catch...finally * B:throws 抛出 * * try...catch...finally的处理格式： * try { * 可能出现问题的代码; * }catch(异常名 变量) { * 针对问题的处理; * }finally { * 释放资源; * } * * 变形格式： * try { * 可能出现问题的代码; * }catch(异常名 变量) { * 针对问题的处理; * } * * 注意： * A:try里面的代码越少越好 * B:catch里面必须有内容，哪怕是给出一个简单的提示 */ public static void main(String[] args) { int a = 10; int b = 0; try { System.out.println(a / b); } catch (ArithmeticException ae) { System.out.println("除数不能为0"); } System.out.println("over"); } }
1.2 多个异常的处理：
b:写一个try，多个catch * try{ * ... * }catch(异常类名 变量名) { * ... * } * catch(异常类名 变量名) { * ... * } * ...
// 两个异常的处理 public static void method3() { int a = 10; int b = 0; int[] arr = { 1, 2, 3 }; try { System.out.println(arr[3]); System.out.println(a / b); } catch (ArithmeticException e) { System.out.println("除数不能为0"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("你访问了不该的访问的索引"); } System.out.println("over"); }
public class day16_01 { public static void main(String[] args) { // method1(); method3(); } // 两个异常的处理 public static void method3() { int a = 10; int b = 0; int[] arr = { 1, 2, 3 }; try { System.out.println(arr[3]); System.out.println(a / b); } catch (ArithmeticException e) { System.out.println("除数不能为0"); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("你访问了不该的访问的索引"); } System.out.println("over"); } // 一个异常 public static void method1() { int a = 10; int b = 0; try { System.out.println(a / b); } catch (ArithmeticException ae) { System.out.println("除数不能为0"); } System.out.println("over"); } }
1.3 多个异常间必须是平级关系。
try{ * * }catch(异常名1 | 异常名2 | ... 变量 ) { * ... * }
2 抛出 throws
有些时候，我们是可以对异常进行处理的，但是又有些时候，我们根本就没有权限去处理某个异常。 * 为了解决出错问题，Java针对这种情况，就提供了另一种处理方案：抛出。 * * 格式： * throws 异常类名 * 注意：这个格式必须跟在方法的括号后面。 * * 注意： * 尽量不要在main方法上抛出异常。 * 但是我讲课为了方便我就这样做了。 * * 小结： * 编译期异常抛出，将来调用者必须处理。 public static void method() throws ParseException { } * 运行期异常抛出，将来调用可以不用处理。 public static void method2() throws ArithmeticException { }
4. throws和throw的区别(面试题)
throws 1. 方法声明后面，跟的是异常类名 2.(抛多个)可以跟多个异常类名，用逗号隔开 3.(方法的调用者)表示抛出异常，由该方法的调用者来处理 4.(可能性)throws表示出现异常的一种可能性，并不一定会发生这些异常 throw 1.方法体内，跟的是异常对象名 2.（抛一个）只能抛出一个异常对象名 3.（方法体内的语句）表示抛出异常，由方法体内的语句处理 4.（一定抛出了某种异常）throw则是抛出了异常，执行throw则一定抛出了某种异常
public class day16_01 { /* * throw:如果出现了异常情况，我们可以把该异常抛出，这个时候的抛出的应该是异常的对象。 * throws和throw的区别(面试题) throws 1. 方法声明后面，跟的是异常类名 2.(抛多个)可以跟多个异常类名，用逗号隔开 3.(方法的调用者)表示抛出异常，由该方法的调用者来处理 4.(可能性)throws表示出现异常的一种可能性，并不一定会发生这些异常 throw 1.方法体内，跟的是异常对象名 2.（抛一个）只能抛出一个异常对象名 3.（方法体内的语句）表示抛出异常，由方法体内的语句处理 4.（一定抛出了某种异常）throw则是抛出了异常，执行throw则一定抛出了某种异常 */ public static void main(String[] args) { // method(); try { method2(); } catch (Exception e) { e.printStackTrace(); } } public static void method() { int a = 10; int b = 0; if (b == 0) { throw new ArithmeticException(); // throw } else { System.out.println(a / b); } } public static void method2() throws Exception { // throws int a = 10; int b = 0; if (b == 0) { throw new Exception(); } else { System.out.println(a / b); } } }
5. finally 被finally控制的语句体一定会执行---- 用于释放资源，在IO流操作和数据库操作中会见到
A:格式 * try...catch...finally...
import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class day16_01 { /* * finally:被finally控制的语句体一定会执行 * 注意：如果在执行到finally之前jvm退出了，就不能执行了。 * * A:格式 * try...catch...finally... * B:用于释放资源，在IO流操作和数据库操作中会见到 */ public static void main(String[] args) { String s = "2014-11-20"; SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date d = null; try { // System.out.println(10 / 0); d = sdf.parse(s); } catch (ParseException e) { e.printStackTrace(); System.exit(0); } finally { System.out.println("这里的代码是可以执行的"); } System.out.println(d); } }
5.2 1:final,finally和finalize的区别
1:final,finally和finalize的区别 * final：最终的意思，可以修饰类，成员变量，成员方法 * 修饰类，类不能被继承 * 修饰变量，变量是常量 * 修饰方法，方法不能被重写 * finally：是异常处理的一部分，用于释放资源。 * 一般来说，代码肯定会执行，特殊情况：在执行到finally之前jvm退出了 * finalize：是Object类的一个方法，用于垃圾回收
2:如果catch里面有return语句，请问finally里面的代码还会执行吗?
* 如果会，请问是在return前，还是return后。
* 会。前。
public class day16_01 { /* * 面试题： * 1:final,finally和finalize的区别 * final：最终的意思，可以修饰类，成员变量，成员方法 * 修饰类， 类不能被继承 * 修饰变量，变量是常量 * 修饰方法，方法不能被重写 * finally：是异常处理的一部分，用于释放资源。 * 一般来说，代码肯定会执行，特殊情况：在执行到finally之前jvm退出了 * finalize：是Object类的一个方法，用于垃圾回收 * * 2:如果catch里面有return语句，请问finally里面的代码还会执行吗? * 如果会，请问是在return前，还是return后。 * 会。前。 * * 准确的说，应该是在中间。 * * 3:try...catch...finally的格式变形 * A:try...catch...finally * B:try...catch * C:try...catch...catch... * D:try...catch...catch...finally * E:try...finally * 这种做法的目前是为了释放资源。 */ public static void main(String[] args) { System.out.println(getInt()); } public static int getInt() { int a = 10; try { System.out.println(a / 0); a = 20; } catch (ArithmeticException e) { a = 30; return a; /* * return a在程序执行到这一步的时候，这里不是return a而是return 30;这个返回路径就形成了。 * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40 * 再次回到以前的返回路径，继续走return 30; */ } finally { a = 40; return a;//如果这样结果就是40了。 } } }
6. 自己定义异常------java不可能对所有的情况都考虑到，所以，在实际的开发中，我们可能需要自己定义异常。
而我们自己随意的写一个类，是不能作为异常类来看的，要想你的类是一个异常类，就必须继承自Exception或者RuntimeException * * 两种方式： * A:继承Exception * B:继承RuntimeException
public class MyException extends Exception { public MyException() { } public MyException(String message) { super(message); } }
步骤：1.定义自定义测试类StudentDemo-------2.新建Teacher类--------3.MyException
package cc; import java.util.Scanner; /* * 自定义异常测试类 */ public class StudentDemo { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("请输入学生成绩："); int score = sc.nextInt(); Teacher t = new Teacher(); // 创建对象 try { t.check(score); } catch (MyException e) { e.printStackTrace(); } } }
package cc; import cc.MyException; public class Teacher { public void check(int score) throws MyException { if (score > 100 || score < 0) { throw new MyException("分数必须在0-100之间"); } else { System.out.println("分数没有问题"); } } // 针对MyException继承自RuntimeException // public void check(int score) { // if (score > 100 || score < 0) { // throw new MyException(); // } else { // System.out.println("分数没有问题"); // } // } }
package cc; import cc.MyException; //import cc.Teacher; /* * java不可能对所有的情况都考虑到，所以，在实际的开发中，我们可能需要自己定义异常。 * 而我们自己随意的写一个类，是不能作为异常类来看的，要想你的类是一个异常类，就必须继承自Exception或者RuntimeException * * 两种方式： * A:继承Exception * B:继承RuntimeException */ public class MyException extends Exception { public MyException() { } public MyException(String message) { super(message); } } // public class MyException extends RuntimeException { }
6.2 异常注意事项:
异常注意事项: * A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏) * B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常 * C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
package cc; /* * 异常注意事项: * A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏) * B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常 * C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws */ public class ExceptionDemo { } class Fu { public void show() throws Exception { } public void method() { } } class Zi extends Fu { @Override public void show() throws ArithmeticException { //重写父类的show（）方法并抛出异常 } @Override public void method() { //重写父类 } }