异常和IO

1.异常的概述分类

　　异常就是java程序在运行过程中出现的错误

2.jvm默认是如果处理异常的

　　main方法收到问题时，有两种是处理方式

　　自己将问题处理，然后运行

　　自己没有针对问题的处理方式，只有交给调用main的jvm来处理，并将异常名称，异常信息，异常出现的位置

　　　　打印在了控制台上，同时将程序停止运行（也就是报错）。

 

3.try...catch的方式处理异常

　　try时用来检测异常

　　catch是用来捕获异常

　　finally 释放资源

 

    int i = 5;
    int b = 0;
    try {
        int c = i/5;
    } catch (Exception e) {
            System.out.println(e.getMessage());        // 查看异常信息
        }

 

　　　　try...catch的方式处理多个异常

       JDK7以后处理多个异常的方式及注意事项

　　　　　  int i = 5;
        int b = 0;
        try {
            int c = i / 5;
        } catch (ArithmeticException e) {//只可以捕获除零错误
            System.out.println("除数不能为零");
        } catch (ArrayIndexOutOfBoundsException e) {//只可以捕获下标越界
            System.out.println("索引越界了");

        } catch (Exception e) { // Exception e = new NullPointerException();
            // 如果把所有的错误都放入Exception里面，完全可以接收异常信息，但是不利于错误的查找
            System.out.println("出错了");
        }
        System.out.println("over");

 

　　finally关键字

　　　　被finally控制的语句体一定会执行

　　　　特殊情况：执行到finally 之前 jvm退出了System.exit（0)）

　　finally的作用：用于释放资源，在IO流操作和数组库操作中会见到

　　IO流是需要打开的，打开之后需要关闭，在finally里面关闭

　　finally强大到用return结束方法也会执行

 

 

　　　　

 

                int i = 5;
        int b = 0;
        try {
            int c = i / 5;    
            //直接退出java虚拟机这是系统级别的退出，jvm不在运行
            System.exit(0);
        } catch (Exception e) {
            System.out.println("出错了");
        }finally {
            //try当中无论是渝澳catch，还是return语句他都会执行
            //除非退出java虚拟机
　　　　　　　　　//当出现java虚拟机退出时，finally中的语句就不会运行了，java程序直接终止运行

            System.out.println("aaaaaaaaaaaaaaaaaaaa");
        }
        System.out.println("over");

 

 

4.编译期异常和运行期异常的区别

　　java中异常被分为两类，编译器异常和运行时异常，

　　　　当上面出现了add或者surround的时候，就是程序出现了编译器的异常信息，解决方法时要么使用throws或者时使用trycatch进行包围，才能使程序正常运行　　　　

　　　编译时异常:在编译某个程序的时候,有可能会有这样那样的事情发生,比如文件找不到,这样的异常就必须在编译的时候处理

　　　　　如果不处理编译通不过

 　　运行时异常:就是程序员所犯得错误,需要回来修改代码

　　　　　 就像空指针的时候你不赋值为null.索引越界异常，你不越界

 

5.Throwable的几个常见方法

　　getMessage（）　　获取异常信息，返回字符串

　　toString（）　　　　获取异常类名和异常信息，返回字符串

　　printStackTrace（）  获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void

　　

    public static void main(String[] args) throws Exception {
        Student s = new Student();
        s.setAge(-13);    
    }




    public void setAge(int age)     throws Exception {
        if(age > 0 && age < 150) {
        this.age = age;
        }else {
            throw new RuntimeException("年龄输入有误");
        }
    }

 

 

6.throw 的概述 以及和 throws 的区别

　　1.在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就把异常对象抛出

 

　　2.一个方法在使用throws进行抛出异常时，如果其他方法调用了该方法，那么调用方法必须也要抛出对应的异常，

　　　　或者是使用try...catch 语句进行捕获该异常

 

　　throws：

　　　　用在方法声明的后面，跟的是异常类名

　　　　可以跟多个异常类名，用逗号隔开

　　　　表示抛出异常，有该方法的调用者来处理

　　throw

　　　　用在方法体，跟的是异常对象名

  /**
     *
     * @param args
     * @throws AgeOutOfBoundsException  自定义异常
     */
    public static void main(String[] args) throws AgeOutOfBoundsException {
        Person p = new Person();
        // 捕获异常
       try{
           p.setAge(17);
           System.out.println(p.getAge());
       }catch (Exception e){
           System.out.println("年龄非法");
       }
    }
}

package com.jhedu.day20;
public class Person {
    private String name;
    private int age;
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) throws AgeOutOfBoundsException {
        if(age >0 && age <= 150) {
            this.age = age;
        }else {
            throw new AgeOutOfBoundsException("年龄非法");
        }
    }
}

package com.jhedu.day20;
public class AgeOutOfBoundsException extends Exception {
    // 空参数的构造方法
    public AgeOutOfBoundsException() {
        super();   // 调用父类Exception的构造方法
    }
    // 有参数的构造方法
    public AgeOutOfBoundsException(String message) {
        super(message);  // 调用父类Exception的有参数构造方法
    }

 

　　　　只能抛出一个异常对象名

　　　　表示抛出异常，有方法体内的语句处理

　

7.为什么需要自定义异常

　　异常有很多子类就是为了让你更好的知道抛出的是啥异常，为了有利于你排错，抱不同异常代表不同的错误，看了名字就知道犯了什么错误，就是为了有个名字而已，所作的事情父类都去做了。

 

8.异常的注意事项以及如何使用异常处理

　　1.子类重写父类方法时，子类的方法必须抛出相同的异常或父类异类的子类。

　　2.如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或是他的子类，子类不能抛出父类没有的异常

　　3.如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，如果子类方法内有异常发生，那么子类只能try，不能throws

　　

　　如何使用异常处理：如果该功能内部可以将问题处理，用try，如果处理不了，交给调用者处理。。这是throws

 

 

　　区别：后续程序需要继续就运行try

　　　　　后续程序不需要运行就throws

　　　　如果jdk没有提供相对相应的异常，需要自定义异常