什么是异常：程序执行过程中的不正常情况
异常的作用：增强程序的健壮性
异常在java中以类的形式存在，每一个异常类都可以创建异常对象
可以使用UML图来描述异常的继承结构
UML是一种统一建模语言，图标式语言，可在面向对象的编程语言中使用，用来描述类与类之间的关系，程序的执行流程，对象的状态等。Java软件开发中，软件设计师、系统分析师、架构师设计类，java软件开发人员必须能够看懂
常用软件：Rational Rose、startUML…
Object下有Throwable
Throwable下有两个分支：Error(不可处理，直接退出JVM)和Exception(可处理的)
Exception下有两个分支：
（1）Exception的直接子类：编译时异常（受检异常、受控异常、CheckedException）
（2）RuntimeException：运行是异常（未受检异常、为受控异常、UncheckedException）
要求程序员在编写阶段必须预先对这些异常预先进行处理，如果不处理编译器会报错
编译时异常一般发生的概率你较高
在编写阶段程序员可以预先处理，也可以不管
运行时异常一般发生的概率比较低
我要评论public static void main(String[] args) throws ClassNotFoundException { //不建议在主方法上继续上抛 doSome(); } public static void main(String[] args){ try{ doSome(); }catch (ClassNotFoundException e){ e.printStackTrace(); //e引用保存的内存地址是那个new出来的异常对象的没存地址 } } 注意：
try{ FileInputStream fis = new FileInputStream("D:\\scripts\\IdeaProjects") fis.read(); }catch(FileNotFoundException e){ System.out.println("文件不存在"); }catch(IOException e){ e.printStackTrace(); } JDK8新特性
try{ }catch(FileNotFoundException | IOException e){ e.printStackTrace(); }
通常在finally语句块中完成资源的释放、关闭
finally中的代码比较有保障，是“一定”会执行的
即使try语句块中的代码出现异常，finally中的代码也会正常执行
try不能单独使用，try、finally可以联合使用：以下代码先执行try…再执行finally…最后执行return（方法结束）
try{ System.out.println("try..."); return; }finally{ System.out.println("finally..."); } public class ExceptionTest{ public static void main(String[] args){ FileInputStream fis = null;//声明位置放在try外面，这样在finally中才能使用 try{ FileInputStream fis = new FileInputInputStream("D:\\stripts") String s = null
s.toString(); //fis.close();流用完需要关闭，即使程序异常也需要关闭。但这里执行不到关闭流 }catch(FileNotFoundException e){ e.printStackTrace(); }catch(IOException e){ e.printStackTrace(); }finally{ //流的关闭放在这里比较保险 if(fis != null){ try{ fis.close(); }catch(IOException e){ e.printStackTrace(); } } } } try{ System.out.println("try..."); System.exit(0); //退出JVM后，finally语句中的代码将不再执行 }finally{ System.out.println("finally..."); } public class ExceptionTest{ public static void main(String[] args){ int result = m(); System.out.println(result); //100 } public static int m(); int i = 100; try{ return i; }finally{ i++; } } 通过反编译工具：DJ Java Decompiler
public static int m(){ int i =100; int j = i; i++; return j; } Java语法规则结论：
try{ }catch(FileNotFoundException e){ //打印异常堆栈追踪信息。实际开发中，建议使用这个 e.printStackTrace(); //获取异常简单的描述信息 String msg = e.getMassage(); } System.out.println("HelloWorld");//捕获异常后，程序不耽误执行，服务器不会遇到异常而宕机 public class ExceptionTest(){ public static void main(String[] args){ NullPointerException e = new NullPointerException("空指针异常"); String msg = e.getMessage(); System.out.println(msg);//空指针异常 //这里只是new了异常对象，并没有将异常对象抛出，JVM会认为只是一个普通的java对象 e.printStackTrace(); } }
如何查看异常的追踪信息，从而快速调试程序呢？
异常堆栈追踪信息从上往下一行一行的看，SUN写的代码不需要检查，问题出在自己编写的代码上
java后台打印异常堆栈追踪信息的时候，采用了异步线程的方式打印
SUN提供的JDK内置异常在实际开发中不够用，可以自定义异常类
步骤：
public class MyException extends Exception{//编译时异常 public MyException{ } public MyException(String s){ super(s); } } //public class MyException extends RunTimeException{}//运行时异常 public class ExceptionTest{ public static void main(String[] args){ //创建异常对象，灵位手动抛出 MyException e = new MyException("芜湖~~"); e.printStackTrace();//打印异常堆栈信息 Striong msg = e.getMessage();//获取简单异常信息 System.out.println(msg); } } 重点：自定义异常类，在程序中使用
public class MyStackOperationException extends Exception{ public MyStackOperationException{ } public MyStackOperationException(String s){ super(s); } } public class MyStack { private Object[] elements; private int index; public MyStack() { this.elements =new Object[10]; this.index = -1; } public void push(Object obj) throws MyStackOperationException{ if(index >=elements.length-1){ throw new MyStackOperationException("压栈失败，栈已满！") } index++; elements[index]=obj; System.out.println("压栈"+obj+"成功，栈帧指向"+index); } public void pop() throws MyStackOperationException{ if(index<0){ throw new MyStackOperationException("栈已空！") } System.out.println("弹栈"+elements[index]+"元素成功"); index--; System.out.println("栈帧指向"+index); } public Object[] getElements() { return elements; } public void setElements(Object[] elements) { this.elements = elements; } public int getIndex() { return index; } public void setIndex(int index) { this.index = index; } } public class MyStackTest { public static void main(String[] args) { MyStack stack = new MyStack(); // 压栈 try { stack.push(new Object()); stack.push(new Object()); stack.push(new Object()); stack.push(new Object()); stack.push(new Object()); stack.push(new Object()); stack.push(new Object()); stack.push(new Object()); stack.push(new Object()); stack.push(new Object()); // 这里栈满了 stack.push(new Object()); } catch (MyStackOperationException e) { // 输出异常的简单信息。 System.out.println(e.getMessage()); } // 弹栈 try { stack.pop(); stack.pop(); stack.pop(); stack.pop(); stack.pop(); stack.pop(); stack.pop(); stack.pop(); stack.pop(); stack.pop(); // 弹栈失败 stack.pop(); } catch (MyStackOperationException e) { System.out.println(e.getMessage()); } } } public class IllegalNameException extends Exception { public IllegalNameException() { } public IllegalNameException(String message) { super(message); } } public class UserService { /**
* 用户注册
* @param username 用户名
* @param password 密码
* @throws IllegalNameException 无效
*/ public void register(String username, String password) throws IllegalNameException { if (null == username || username.length() < 6 || username.length() > 14) { throw new IllegalNameException("用户名不合法"); } System.out.println("注册成功，欢迎"+username); } } public class Tset { public static void main(String[] args) { UserService userService = new UserService(); try { userService.register("日天家的猫猫","1234578"); } catch (IllegalNameException e) { System.out.println(e.getMessage()); } } }
重写之后的方法不能比重写之前的方法抛出更多的异常，可以更少
实际开发中方法覆盖时一般不做修改，直接复制
final 关键字
finally 关键字
finalize 标识符
本文地址：https://blog.csdn.net/RTyinying/article/details/107896903
如对本文有疑问， 点击进行留言回复！！
网友评论