异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

异常发生的原因有很多，通常包含以下几大类：

• 用户输入了非法数据。
• 要打开的文件不存在。
• 网络通信时连接中断，或者JVM内存溢出。

这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。-
要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：

• 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
• 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
• 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

错误种类：编译错误，运行错误。

编译错误

指的是代码的语法错误**

运行错误

运行时遇到的错误，一般称为异常，异常可以被处理也就是捕获。

异常机制

java推出异常机制为了让错误不影响整体的系统可用性，也就是虽然程序出点了一点问题，但是还是可以继续工作。

public class ExceptionTest2 {
public static void main (String[] args) {
  try {
    int len =getStrLength(null);
  } catch(NullPointerException e) {
    System.out.println("空指针异常");
  }
  System.out.println("程序执行到这");
}
public static int getStrLength(String str){
  return str.length();
}
}

不用异常让代码更健全：判断一下参数的合法性

public class ExceptionTest2 {
    public static void main(String[] args) {
       int len=getStrLength(null);
       System.out.println("程序执行到这："+len);}
    // 获取字符串的长度
    public static int getStrLength(String str) {
      if(str!=null){
        return str.length();}
       else{
         return 0;
       }
}
}

Java异常类

所有的异常类是从 java.lang.Exception 类继承的子类。
Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。
（java.lang.Exception ，java.lang.NullPointerException 是不需要import的）

常见的异常类

Java 根据各个类库也定义了一些其他的异常，下面的表中列出了 Java 的非检查性异常。

下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类。

异常方法

下面的列表是 Throwable 类的主要方法:

多重捕获

多个catch

public class ExceptionTest4 {
    public static void main(String[] args) {
        int num = 0;
        try {
          num = getInt("小王");
        } catch (NumberFormatException e) {
        } catch (NullPointerException e) {
        }
        System.out.println(num);
    }
    // 字符串转换为数字
    public static int getInt(String str) {
        return Integer.parseInt(str);
    }
}

由于这些Exceptions 都是继承于 Exception，所以可以直接用一个Exception 捕获所有异常

public class ExceptionTest4 {
    public static void main(String[] args) {
        int num = 0;
        try {
          num = getInt("小王");
        } catch (Exception e) {
        }
        System.out.println(num);
    }
    // 字符串转换为数字
    public static int getInt(String str) {
        return Integer.parseInt(str);
    }
}

抛出异常

手动抛出异常，如我们不知道怎么去处理一些超出预期的数据的时候，把异常给上层去处理，上层如果不知道，继续上抛。

throws/throw 关键字

import java.io.*;
public class className
{
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
}

使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。

一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。

  public void withdraw(double amount) throws RemoteException,InsufficientFundsException{
  }

异常的错误显示称为异常堆栈，在堆栈中可以看出错误的一些信息，哪一行，哪个方法调用等，要善于看异常堆栈。
RunTimeException 和其余的 Exception 有个不同点，那就是在我们抛出的时候，并不需要在方法上约定可能抛出的异常。

public class ExceptionTest8 {
    public static void main(String[] args) {
        int num = 0;
        try {
            num = getInt(null);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        System.out.println(num);
    }
    public static int getInt(String str) throws Exception {
        if (str == null) {
            throw new Exception("姓名不能为空");
        }
        return Integer.parseInt(str);
    }
}

finally关键字

finally 关键字用来创建在 try 代码块后面执行的代码块。
无论是否发生异常，finally 代码块中的代码总会被执行。
在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
finally 代码块出现在 catch 代码块最后，语法如下：

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}

注意下面事项：

• catch 不能独立于 try 存在。
• 在 try/catch 后面添加 finally 块并非强制性要求的。
• try 代码后不能既没 catch 块也没 finally 块。
• try, catch, finally 块之间不能添加任何代码。

  

  ```java import com.youkeda.service.UserService; import com.youkeda.model.User; import java.util.List; import java.util.ArrayList;

public class UserServiceImpl implements UserService {

private static List<User> USERS = new ArrayList<>();
static {
    User user = new User();
    user.setNickName("爱吹风的牛");
    user.setUserName("niu");
    user.setPassword("Niu123");
    USERS.add(user);
    user = new User();
    user.setNickName("我爱西红柿");
    user.setUserName("xihongshi");
    user.setPassword("Didi5");
    USERS.add(user);
}
public User login(String userName, String password) throws Exception {
    if (userName == null || password == null) {
        throw new Exception("用户名或者密码为空");
    }
    for (User user : USERS) {
        if (user.getUserName().equals(userName) && user.getPassword().equals(password)) {
            return user;
        }
    }
    return null;
}

}

<a name="eKYbz"></a>
# 自定义异常
在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。
- 所有异常都必须是 Throwable 的子类。
- 如果希望写一个检查性异常类，则需要继承 Exception 类。
- 如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。
在UserService中，login上抛出了Exception 这个实在搞不明白是啥异常，创建一个ParamNullException就清楚多了
```java
public class ParamNullException extends Exception {
}

public User login(String userName, 
                  String password) throws ParamNullException {
  if (userName == null || password == null) {
    throw new ParamNullException();
  }
  for (User user : USERS) {
    if (user.getUserName().equals(userName) && user.getPassword().equals(password)) {
        return user;
    }
  }
  return null;
}

通用异常

在Java中定义了两种类型的异常和错误。

• JVM(Java虚拟机) 异常：由 JVM 抛出的异常或错误。例如：NullPointerException 类，ArrayIndexOutOfBoundsException 类，ClassCastException 类。
• 程序级异常：由程序或者API程序抛出的异常。例如 IllegalArgumentException 类，IllegalStateException 类。