day 13：Java中的异常(excptions)

package bamzhy.day13;
/*
thowable类时java语言中所有错误或异常的超类
两个子类的实例error和exception
exception是指一些相对来说不那么严重的我们自己能够解决的异常状况
一种是可以被遇见到的，另一种的在运行过程中不太好遇见到但又确实有可能发生的
当发生异常时，默认的执行流程：
1、首先从异常发生的地方终止我们的代码执行
2、转而执行虚拟机应对异常的代码，就是首先检测到发生了这种异常并将这种情况封装成异常对象
3、将异常对象的相关信息输出到控制台
异常的意义在于我们可以自己处理处理异常情况，比如说我们在异常发生的时候收集异常信息以供我们分析程序的代码逻辑，找BUG
 */
public class ExceptionDemo1 {
    public static void main(String[] args) {
        //java.lang.ArithmeticException: / by zero
        System.out.println(1/0);
        System.out.println("发生除零异常了");
    }
}
import java.lang.reflect.Array;

/*
java中提供了try-catch语句让开发人员可以有机会来处理自己程序中的异常
try{
//在try代码块中书写可能发生异常的代码，一旦发生异常就跳转到catch语句当中
}catch（）{
//在这里处理我们的异常
}

try{
}catch(){
}catch(){
}catch{
 }
 1、当发生异常时，首先由java虚拟机捕获异常，并构造异常对象
 2、根据发生异常的具体异常类型，匹配catch代码中的异常参数类型，并跳转到类型匹配的catch分支中执行相应代码
 3、注意：同一个try语句对应的多分支catch语句块时只会执行其中一个catch语句块
 当虚拟机匹配不到当前的异常类型所对应的catch分支时，转而回到默认处理流程
 当有多个catch分支的时候，如果catch分支所对应的异常类型之间出现了类型兼容的情况，
 那么就需要注意catch分支的书写的先后顺序了
 通常大类型写在小类型之后
 */
public class ExceptionDemo2 {
    public static void main(String[] args) {
        int i=1;
        int []a={1,2,3};
        try{
            //在try代码块中，一旦发生异常，发生异常的代码之后的语句并不会执行，而是
            //跳转到相应的catch语句块中
            System.out.println(1/0);
            System.out.println("array 3="+a[3]);
            a=null;
            System.out.println("array 0="+a[0]);
            System.out.println("try block after exception");
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("catch block"+"发生数组越界异常了");
        }catch(ArithmeticException e){
            System.out.println("catch block"+"发生除零异常了");
        }catch(Exception e){
            System.out.println("ExceptionDemo2 Catch Block");
        }
        System.out.println("异常处理完毕，继续执行接下来的代码");
    }
}
package bamzhy.day13;

import java.text.SimpleDateFormat;
import java.util.Date;

/*
编译时异常和运行时异常
实现和时间相关的功能：Date，SimpleDateFormate,Calendar
 */
public class ExceptionDemo4 {
    public static void main(String[] args) {
        int []a={2,3,4};
        int i=0;
        String s="2018-01-01 :00:00";
        SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //编译时异常（checkable exception）这种异常往往是容易发生的，并且可以预见到的
        Date date=null;
        //但是对于运行时异常而言，因为编译器通常预见不到这种异常情况，所以不会强制要求，将可能发生运行时异常的语句放到trycatch语句中
//        i=10;
//        System.out.println(a[10]);
        //对于编译时异常，编译器强制要求我们提前处理好异常
        try{
            date=format.parse(s);
        }catch(Exception e){
            System.out.println("解析时间的时候发生异常");
        }
        System.out.println(date);
    }
}
package bamzhy.day13;
/*
异常对象常用api，可以通过以下三个api获取异常对象信息
getMessage();是从调用线程的消息队列里取得了一个消息并将其放于指定的接口
toString();通常，ToString方法会返回一个“以文本方式表示”此对象的字符串。
printStackTrace();在命令行打印异常信息在程序中出错的位置及原因。
 */
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo5 {
    public static void main(String[] args) {
        String s="2018-01-15";
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try{
            Date date=sdf.parse(s);
        }catch(ParseException e){
            //ava.text.DateFormat.parse
            //ParseException解析错误
            System.out.println("解析时间出异常了");
//            e.printStackTrace();
            //Unparseable date: "2018-01-15"
            System.out.println(e.getMessage());
            //java.text.ParseException: Unparseable date: "2018-01-15"
            System.out.println(e.toString());
        }
    }
}
package bamzhy.day13;
/*
异常处理的第二种方式：抛出异常、抛给谁呢？抛给方法调用者
throw关键字：
1、将异常的发生和异常的处理分离开来（有时候在发生异常的地方我们也许并不知道该怎么去处理）
2、从语法上强制调用者来处理被调用方法中可能抛出的异常
    throws关键字针对可检查异常才有用
3、throws关键字后面可以声明抛出多种类型的异常，但是一旦声明那么调用者对每一种异常都必须做处理
4、throws:用在方法后，可跟多个异常类名，由方法调用者处理，表示可能会抛出这些异常，但不一定会抛
5、用在方法体内，后跟异常对象名，只能抛出一个异常对象名，表示抛出异常，由方法体内的语句产生、执行throw语句必然抛出某种异常
 */

import java.rmi.activation.ActivateFailedException;
import java.rmi.activation.ActivationException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo6 {
    public static void main(String[] args) throws ActivationException{
        String s = "2018-01-15";
//        try {
//            Date date = parseTime(s);
//        } catch (ParseException e) {
//            e.printStackTrace();
//        } catch (ActivationException e) {
//            e.printStackTrace();
//        }
        nonNegtiveParameter(-1);
    }

    public static Date parseTime(String s) throws ParseException, ParseException {
        //异常列表 ParseException解析时出现意外错误；ParseException激活异常
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //由于异常时在main方法中发生，main是虚拟机调用的，因此此时若抛出异常虚拟机就会按照其默认处理流程来处理
        Date date = sdf.parse(s);
        return date;
    }
//对于该方法而言，如果所传参数小于0认为参数非法，抛出异常
    public static void nonNegtiveParameter(int i) throws ActivationException {
        if (i < 0) {
            throw new IllegalArgumentException();
        }
        System.out.println("i="+i);
    }
}

package bamzhy.day13;
/*
try{
}catch(Exception){
}finally{
}
被finally控制的语句块一定会执行（不管try内是否有抛出异常）
特殊情况，走到finally之前jvm退出了，finally语句块中的代码才不会运行
 */
public class ExceptionDemo7 {
    public static void main(String[] args) {
        int i=testFinally();
        System.out.println("i="+i);
    }
    public static int testFinally(){
        int i=0;
        try{
            //申请了操作系统的资源
            System.out.println(i/1);
            return i;
            //system.exit(0);//程序正常执行结束退出
            //使用该资源，释放该资源
        }catch(ArithmeticException e){
            e.getMessage();
        }finally {
            System.out.println("finally");
            i=100;
            return i;
        }
    }
}
package bamzhy.day13;
/*
    自定义异常
 */
public class ExceptionDemo8 {

    public static void main(String[] args){

        //我的业务逻辑是，只要输入参数超出了0-100，我需要抛出异常，并做相应的处理

        try {
            test(1000);
        } catch (MyException e) {
            e.printStackTrace();
            //你自己定义的处理方式
        }
    }
    
    public static void test(int i) throws MyException{

        if(i <0 || i > 100) {
            throw new MyException("fdsadfdsafds");
        }
    }
}

class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}