异常（抛出异常：throws）

throws(抛出异常)

处理异常的第二种方式: throws:抛出异常

为什么要使用throws?

当我们处理异常,如果没有一些权限处理异常,那我们就不处理了,通过开发工具,提示抛出异常,这个时候就可以使用throws.

注意：不建议在main方法中抛出异常

面试题:
throws和throw的区别?(100%会问到!)
throws:用法:一般在方法声明上抛出
抛出的是一个异常类名,可以抛出多个异常,中间用逗号隔开
throws表示抛出异常,这段代码可能会抛出异常( 指的是抛出异常的可能性)
一般情况:throws用的比较多
throw:一般在方法中进行抛出
抛出的是一个异常对象(匿名对象的方式)
throw:表示抛出:肯定的抛出异常(具体异常),走到这块代码,一定会执行throw中的异常，在语句中进行处理
代码：

   public static void main(String[] args) throws Exception {
      method1();
      method2();
}
  public static void method1() throws Exception{
      int a = 10;
      System.out.println(a/0);
  }
  public static void method2() throws Exception{
      int a = 10;
      int b = 0;
      if(b==0){
          throw new Exception();
      }else{
          System.out.println(a/b);
      }
  }

结果：

Exception in thread “main” java.lang.ArithmeticException: / by zero
at Throws.demo.ThrowsDemo.method1(ThrowsDemo.java:82)
at Throws.demo.ThrowsDemo.main(ThrowsDemo.java:77)

面试题：
final,finalize,finally三者之间的区别?(100%问到)
final:最终的,终态的
final修饰类:该类不能被继承
final修饰成员变量:该变量是自定义常量
final修饰成员方法:该方法不能被重写

finalize:和垃圾回收期有关系:运行垃圾回收器的方法:gc().调用gc(),实质是调用了通过重写了Object中的finalize方法
finally:出现在IO流中或者数据中,用来释放资源的!

       注意:1)finally中的代码是一定会执行的,一般用在IO流中和数据库中;
            2)如果在执行finally中的代码之前,JVMjava虚拟机退出了,那么finally中的释放资源是不会执行的    

面试题:
如果catch有return语句,finally中的会执行吗?如果会,是在return前执行还是在return后执行?

  会执行finally中的代码,是在return前执行

例：
public static void main(String[] args) {
System.out.println(getInt());
}

public static int getInt(){

    int a = 10 ;
    try {
        a = 20 ;
        System.out.println(a/0);
    } catch (Exception e) {
        a = 30 ;//回路经
        return a ;
        /**
         * 当代码走到这一块,a = 30 ; return a ====>return 30 ,这里面形成了一回路径,
         * 但是,一看这里有finally,所以会执行finally中的代码,a =40 ,
         * 最终返回return a====>return前面的语句:30
         * */
    }finally{
        a = 40 ;

// return a ;//40
}
return a ;//30
}

异常类中的注意事项:

1)子类重写父类中的方法,如果父类中方法抛出一个异常,那么子类重写父类该方法时抛出异常,要么跟父类中异常保持一致,
        要么要是他的异常类的子类
    2)如果被重写的方法,没有抛出异常,那么子类重写这个 方法,也不能抛出异常,不能throws,只能try...catch(这种情况只能子类中进行捕获异常);

代码：

static class  fu{
     public void show() throws Exception{

     }

     public static void method(){

     }
 }
 static class zi extends fu{
     public void show() throws Exception{

     }

     public static void method(){
         String s = "2017-8-10";

         SimpleDateFormat sdf = new SimpleDateFormat("y-M-d  HH-mm-ss");

         try {
            sdf.parse(s);
        } catch (ParseException e) {
            e.printStackTrace();
        }
     }
 }
 public static void main(String[] args) {
    zi.method();
}

结果：

java.text.ParseException: Unparseable date: “2017-8-10”
at java.text.DateFormat.parse(DateFormat.java:357)
at Throws.demo.ThrowsDemo2$zi.method(ThrowsDemo2.java:35)
at Throws.demo.ThrowsDemo2.main(ThrowsDemo2.java:42)

有时候在实际开发中,可能会需要自己定义一个异常类
不是说起以类名就是可以当作异常类,必须自定义的类继承Exception或者RuntimeException,那么这样的类,才是自己定义的异常类

代码：

public class MyException extends Exception{
public MyException(){

  }
  public MyException(String s){
      super(s);
  }

}

public class Teacher {
public static void check(int i)throws MyException{
if(i>100 ||i<0){
System.out.println(“成績必須在0-100之間”);
}else{
System.out.println(“符合規則”);
}
}
}

public class Sdudent {
public static void main(String[] args) {
Scanner sc = new Scanner (System.in);
System.out.println(“請輸入你的成績:”);

    int a = sc.nextInt();

    Teacher t = new Teacher();
    try{
        t.check(a);
    }catch(MyException me){
        me.printStackTrace();
    }
}

}

结果;

請輸入你的成績:
300
成績必須在0-100之間