java异常处理

1.运行时异常与一般异常（检查异常）的异同

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见的运行错误。Java编译器要求方法必须声明跑出可能发生的非运行时异常，但是并不要求必要声明跑出位被捕获的运行时异常。

 

2.异常的处理方法：

方法一：try/catch（捕获处理）：

 

注意，当try中的某条语句引发异常后，程序立即跳转到catch部分，查找和该异常类型相匹配的catch语句并执行catch{}中的所有语句，而位于try中的发生异常语句后面的所有语句（正常语句和会发生异常的语句）都不会执行。

如果有finally语句，无论是否有匹配的catch语句，也无论是否发生了异常，程序最终都会转到finally中来执行。

 

在java中，try和catch可以连用，try catch finally可以连用。但是try catch finally却不可以单独使用。如果在程序中只想try而不去catch也是可以的，但是try的后面必须跟有finally。例如下面题目：

关于捕获异常的语法描述，请选择正确答案

A。try可以单独使用

B、try catch必须配对使用

C。try finally可以配对使用

D。catch finally可以配对使用

E。在try catch之后如果定义了finally，则finally肯定执行

 

答案CE

 

方法二：throws（声明异常）

 

声明异常是指一个方法不处理它产生的异常，而是向上传递，谁调用这个方法，这个异常就由谁来处理。

 

如果要让下面的程序正常编译，需要对子类ThrowDemo中的重写方法myThow()做怎么的处理？

 

番外篇：java中子类重写父类方法时，返回类型要不要一样才算重写啊？
我见过两种版本啊，有的书上说要一样，有的书上说返回类型可以不同啊！
哎！！ 到底怎么样啊？ 高手解释，解释！谢谢了！！

重写：除了方法体里面的代码，其他的部分都要和父类中的一样（访问权限要比父类中定义的访问权限宽松，如父类中定义为public，那子类重写的方法也必须是public，不能是protected或者private）。
楼上说法不准确：重载方法区别在于参数个数和参数类型，不在于返回值。也就是，重载方法的返回值可以不一样，而重写方法的返回值必须一样。
给你总结区分一下：重写方法出现在子类中，只有在发生继承关系的前提下，在能出现重写方法，而且重写的是父类的方法。而重载方法出现在同一个类中，和继承没有关系，重载的是类自己的方法。

 

吼吼，基础还要继续加强喽，偶也分不清重写重载啦，以上百度说的很明白啦，学习了，接着学习异常

 

public class ThrowDemo extends Throw{
 void myThrow/* throws 表达式*/{
  try{
   myThow_1(7,0);
  }catch(ArithmeticException e){
   System.out.println();
  }
  throw new RuntimeException("运行时异常");
 }
 
 public static void main(String[] args){
  new ThrowDemo.myThow();
 }
}

class Throw{
 void myThow()throws ArithmeticException, InterrupteException{
  myThow_1(3,6)
 }
 int myThow_1()throws ArithemeticException{
  return x/y;
 }
}

A. 在myThow()后面需要声明ArithemeticException
B. 在myThow()后面需要声明InterrupteException
C. 在myThow()后面需要声明RuntimeException
D. 在myThow()后面需要声明ArithemeticException,A. 又要声明InterrupteException
E. 在myThow()后面不要需要声明任何异常并将throw new RuntimeException("运行时异常");这条语句去掉

 

分析：

父类中的重写方法可以指定所有的已检查异常或者指定已检查异常的一部分，这些已检查异常是重载方法在其throws子句中声明的。子类在重写该方法时不需要指定重写方法throws子句的任何已检查异常。所以本题中myThow()方法不用做任何的声明ArithemeticException和InterrupteException都是RuntimeException，并且在myThow()方法中捕获处理异常，所以不应该再抛出异常。答案E

 

 

 方法三：throw

当一方法发生异常时可以通过throw关键字来抛出异常，把异常抛给它上一级的调用者，抛出的可以shi异常引用，也可以是异常对象，它的语法格式如下：

throw 异常对象名;

或者

throw new 异常类名();

一条throw语句一旦被执行，程序立即转入相应的异常处理程序段，他后面的语句就不再执行了（这一点类似于return语句），而且它所在的方法也不再返回有意义的值。在一个方法中，throw语句可以有多条，但是每一次最多只能执行其中一条。在一般情况下，throw语句都会写在判断语句块中，以避免每次都执行该语句。

//代码剖析
public  class catchThows{
 static int x;
 public static void main(String[] args){
  double a = Math.random()*10;
  if(x>0){
   System.out.println(a/x);
  }else{
   throw new Exception;//抛出异常
  }
 }
}

 public void setX(int x){
  this.x = x; 
 }

 

从上面的运行结果可以看出，一个方法中如果使用throw来抛出异常，要么自己捕获它，要么声明抛出了一个异常。要声明抛出了异常，需要用throws关键字在方法的头部声明。如果我们将上面的代码修改成下面的代码，那么结果有会怎么样呢？

public  class catchThows_1{
 static int x;
 public static void main(String[] args){
  double a = Math.random()*10;
  if(x>0){
   System.out.println(a/x);
  }else{
   try{
    throw new Exception();//抛出异常
   }catch(Exception e){
    System.out.println("出现异常的原因是："+e.getMessage());
   }
   
  }
 }
 public void setX(int x){
  this.x = x; 
 }
}

运行结果如下：

出现异常的原因是：null

还有一种抛出异常的方法是让被调用的方法表示它将不处理异常，该异常将被抛出到他 的调用方法中。这点是和throws声明异常很相似的，但是他们的文职完全不同。具体代码如下：

public  class catchDemo{
 void findThows(){
  try{
   //抛出方法
   throw new ArithmeticException();
  }catch(ArithmeticException ae){
   throw ae;
  }
 }
 public static void main(String[] args){
  catchDemo ct = new catchDemo();
  //对方法进行异常处理
  try{
   ct.findThows();
  }catch(ArithmeticException ae){
   System.out.println(" 出现异常的原因是："+ae);
  }
  
 }
}

运行结果如下、

出现异常的原因是：java.lang.ArithmeticException