【JAVA学习笔记09】异常

异常

编译时异常：写代码的时候，不是程序逻辑的错误，（try catch ,throw finally）
运行时异常：是运行代码抛出的异常，是程序员自己的问题

代码

package com.situ.day08;

import org.junit.Test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ExceptionDemo {

    @Test
    public void test1(){
        try {
            FileInputStream fileinputstream = new FileInputStream("b.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println("ExceptionDemo.test1");
    }

    @Test
    public void test2(){

        try {
            show();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

    public void show() throws ClassNotFoundException {
        Class.forName("com.mysql.jdbc.Driver");

    }

    @Test
    public void test3(){
        try {
            FileInputStream fileInputStraem = new FileInputStream("a.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            System.out.println("finally");
        }
        System.out.println("ExceptionDemo.test2 try");
    }




}

异常作业

异常处理
一．填空题
1．一个try语句块后必须跟（ catch ）语句块，（ finally ）语句块可以没有
2．自定义异常类必须继承（ Exception ）类及其子类
3．异常处理机制允许根据具体的情况选择在何处处理异常，可以在（ try-catch ）捕获并处理，也可以用throws子句把他交给（ 上层（调用方） ）处理
二．选择题
1.finally语句块中的代码（ A ）
A．总是被执行
B．当try语句块后面没有catch时，finally中的代码才会执行
C．异常发生时才执行
D．异常没有发生时才被执行
2.抛出异常应该使用的关键字是（ A ）
A．throw B．catch C．finally D．throws
3.自定义异常类时，可以继承的类是（ C ）
A．Error B．Applet C．Exception及其子类 D．AssertionError
4.在异常处理中，将可能抛出异常的方法放在（ C ）语句块中
A．throws B．catch C．try D．finally
5.对于try{……}catch子句的排列方式，下列正确的一项是（ A ）
A．子类异常在前，父类异常在后
B．父类异常在前，子类异常在后
C．只能有子类异常
D．父类异常与子类异常不能同时出现
6.使用catch(Exception e)的好处是（ B ）
A．只会捕获个别类型的异常
B．捕获try语句块中产生的所有类型的异常
C．忽略一些异常
D．执行一些程序
三．简答题
1．try/catch/finally如何使用？
try：将可能出现异常的语句放在此处
catch: 当出现异常时在此处捕获异常
finally:无论是否出现异常都要执行
2．Throw/throws有什么联系和区别？
Throw:在语句中抛出异常
Throws:在方法中出现异常之后抛到调用方法中处理
联系：都是对于异常的处理。
3．如何自定义异常类？

1、所有的异常的都是Throwable的子类
2、如果写一个运行时异常，需要继承RuntimeException
3、如果要写一个编译时异常，继承Exception

4．谈谈final、finally的区别和作用
fianl: 修饰变量是定义常量、修饰类是不允许继承、修饰方法是不允许复写
finally：使用在异常处理中，无论是否出现异常都要执行。
5．如果try{}里有一个return语句，那么紧跟在这个try后的finally{}里的代码会不会被执行？
会运行
6．Error和Exception有什么区别？（重要）
当程序出现错误的时候就会抛出异常，异常需要被用户所捕获
Error:一般出现的是编译器的异常，不可恢复
Exception:一般是出现的代码异常，是可以被处理的，可以被恢复的

7．什么是RuntimeException？列举至少4个RuntimeException的子类
ArithmeticException;
NullPointerException;
ArraryIndexOutOfBoundsException
ClassCastException
StringIndexOutOfBoundsException

四．编程题
1．设计自己的异常类表示对负数求平方根的错误；在类Test的主方法中，从键盘输入一个数，若输入的数不小于0，则输出它的平方根；若小于0，则抛出自定义异常；在程序中处理异常并输出提示信息“输入错误，不能对负数求平方根”

package com.situ.day09.situ;

public class Test {
    public Test( ) {
    }

    public void test1(Integer a) throws YiChangException {
        if(a >0){
            Double num = Math.sqrt(a);
            System.out.println(num);
        }else{
            throw new YiChangException("错误" );
        }
    }

    public static void main(String[] args) {
        Test test = new Test();
        try {
            test.test1(16);

        } catch (YiChangException e) {
            e.printStackTrace();
        }

    }
}

package com.situ.day09.situ;

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

JDBC

public class JDBCDemo {
    @Test
    public void test1(){
        ResultSet resultSet = null;
        Connection connection = null;
        Statement statement = null;

        try {
            // 1.加载驱动Class.forName("”);
            Class.forName("com.mysql.cj.jdbc.Driver");
            // 2.获得链接对象Connection
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/java230701?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2b8", "root", "1234");
            // 3. 写sql语句
            String sql = "SELECT id,name,age,gender FROM student";
            // 4. 创建Statement(一艘船）
            statement = connection.createStatement();
            // 5.执行sql语句
            //   (1) 更新类（更改了表里面数据）：delete/update/insert     executeUpdate()
            //   返回值：int，表示你影响的行数
            //   (2)查询（没有改变表里面数据）:  select                   executeQuery()
            //   返回值：结果集ResultSet
             resultSet = statement.executeQuery(sql);
            List<Student> list = new ArrayList<>();
            while(resultSet.next()){ //判断下一个有没有，如果返回true而且指向下一个，没有返回false
                // 每遍历一行，就封装一个对象
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                int age = resultSet.getInt("age");
                String gender = resultSet.getString("gender");
                Student student = new Student(id, name, age, gender);
                list.add(student);

            }
            for (Student student : list) {
                System.out.println(student);

            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally { // 关闭链接
            if (resultSet != null){
                try {
                    resultSet.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(statement != null){
                try {
                    resultSet.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(connection != null){
                try {
                    connection.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

        }


    }