异常

异常

程序出现了不正常的情况。

即在程序运行过程中出现的问题则称为异常。

程序的异常：Throwable

Throwable类：所有异常和错误的祖宗类。

严重问题：Error （也就是错误）我们不处理。这种问题一般都是很严重的，比如说内存溢出。

问题：Exception（异常）

异常是JVM产生的，反馈给程序猿的，可以针对异常进行处理，如果不处理，程序直接奔溃。

编译期问题:

不是RuntimeException的异常 必须进行处理的，因为你不处理，编译就不能通过。

一般情况下,main 方法是不会声明抛出异常的,因为该方法抛出,直接抛出给了 JVM,JVM 的默认处理机制是终止程序运行,则这样处理,相当于没有处理!

运行期问题:

RuntimeException 这种问题我们可以不处理，

因为是你的问题，而且这个问题出现肯定是我们的代码不够严谨，需要修正代码的。

​

一般情况下,遇到 java 自身提供的运行时异常,都可以通过逻辑解决,避免异常产生.

常见运行时异常:空指针异常,索引越界异常,类型转换异常 ,除数为零异常

如何程序出现了问题，我们没有做任何处理，最终jvm会做出默认的处理。

把异常的名称，原因及出现的问题等信息输出在控制台。

同时会结束程序。

Throwable常用方法

void printStackTrace(); 打印异常的栈信息，追溯异常的来源。
String getMessage(); 获得异常的消息字符串
String toString(); 获得异常的详细消息字符串：包括异常类的类全名。

异常的处理方式

异常的处理方式 * JVM默认处理方式 throws 抛出 * 手动处理方式 try...catch...finallyJVM默认处理方式 * 将异常信息(异常类名,异常原因,异常位置)输出到控制台中 * 终止程序的运行。手动处理方式 * 捕获处理 * 抛出处理

我们自己如何处理异常呢?

A:try...catch...finally

B:throws 抛出

try...catch...finally的处理格式：

try {
​
可能出现问题的代码;
​
}catch(异常名 
变量) {
​
针对问题的处理;
​
}finally {
​
释放资源;
​
}

finally代码块的特点 只要代码执行流程进入的try代码块，不管是否出现异常，该代码块中的代码都会执行

如果不是systemt.extic(0),即使是return 该代码块中的代码都会执行。

finally代码块的作用

    * 用来释放资源，比如关闭io流，数据库相关资源。

变形格式：

try {
​
可能出现问题的代码;
​
}catch(异常名 变量) {
​
针对问题的处理;
​
}

• 注意：

• A:try里面的代码越少越好

• B:catch里面必须有内容，哪怕是给出一个简单的提示

public class ExceptionDemo {
 public static void main(String[] args) {
  // 第一阶段
  int a = 10;
  // int b = 2;
  int b = 0;
​
  try {
   System.out.println(a / b);
  } catch (ArithmeticException ae) {
   System.out.println("除数不能为0");
  }
​
  // 第二阶段
  System.out.println("over");
 }
}
​
​

多catch捕获处理格式

try {
​
} catch(异常类名 变量名){
​
} ...
 catch(异常类名 变量名){
​
}

• 格式说明

  • try代码块：编写可能出现异常的代码

  • catch代码块：处理异常的代码

• 代码执行流程

  • 先执行try代码块中的代码，

  • 如果try代码没有出现异常，则不会执行catch代码块中的代码

  • 如果try代码出现了异常，则代码的执行流程就跳转到catch代码块中

    ​

多catch捕获处理注意事项：

• 1:能明确的尽量明确，不要用大的来处理。

• 2:平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面。

注意：

• 一旦try里面出了问题，就会在这里把问题给抛出去，然后和catch里面的问题进行匹配，

• 一旦有匹配的，就执行catch里面的处理，然后结束了try...catch

• 继续执行后面的语句。

// 两个异常的处理
 public static void method3() {
  int a = 10;
  int b = 0;
  int[] arr = { 1, 2, 3 };
​
  try {
   System.out.println(arr[3]);
   System.out.println(a / b);
   // System.out.println(arr[3]);
  } catch (ArithmeticException e) {
   System.out.println("除数不能为0");
  } catch (ArrayIndexOutOfBoundsException e) {
   System.out.println("你访问了不该的访问的索引");
  }
​
  System.out.println("over");
 }
​
​
  // 一个异常
  int[] arr = { 1, 2, 3 };
  try {
   System.out.println(arr[3]);
  } catch (ArrayIndexOutOfBoundsException e) {
   System.out.println("你访问了不该的访问的索引");
  }
​
  System.out.println("over");
 }
​
​

编译时异常和运行时异常的区别

• 编译期异常：Java程序必须显式处理，否则程序就会发生错误，无法通过编译

• 运行期异常：无需显式处理，也可以和编译时异常一样处理

在try里面发现问题后，jvm会帮我们生成一个异常对象，然后把这个对象抛出，和catch里面的类进行匹配。

如果该对象是某个类型的，就会执行该catch里面的处理信息。

public class ExceptionDemo {
 public static void main(String[] args) {
  String s = "2014-11-20";
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  try {
   Date d = sdf.parse(s); // 创建了一个ParseException对象，然后抛出去，和catch里面进行匹配
   System.out.println(d);
  } catch (ParseException e) { 
      
   // ParseException e = new ParseException();
   
   // e.printStackTrace();
​
   // getMessage()
   // System.out.println(e.getMessage());
   // Unparseable date: "2014-11-20"
​
   // toString()
   // System.out.println(e.toString());
   // java.text.ParseException: Unparseable date: "2014-11-20"
   
   e.printStackTrace();
   //跳转到某个指定的页面(index.html)
  }
  
  System.out.println("over");
 }
}
​
​

有些时候，我们是可以对异常进行处理的，但是又有些时候，我们根本就没有权限去处理某个异常。

• 或者说，我处理不了，我就不处理了。

• 为了解决出错问题，Java针对这种情况，就提供了另一种处理方案：抛出。

抛出格式：

throws 异常类名

注意：这个格式必须跟在方法的括号后面。

抛出注意：

尽量不要在main方法上抛出异常。

但是我讲课为了方便我就这样做了。

抛出小结：

编译期异常抛出，将来调用者必须处理。

运行期异常抛出，将来调用可以不用处理。

throw:如果出现了异常情况，我们可以把该异常抛出，这个时候的抛出的应该是异常的对象。

throws和throw的区别

throws

用在方法声明后面，跟的是异常类名 可以跟多个异常类名，用逗号隔开 表示抛出异常，由该方法的调用者来处理 throws表示出现异常的一种可能性，并不一定会发生这些异常

throw

用在方法体内，跟的是异常对象名 只能抛出一个异常对象名 表示抛出异常，由方法体内的语句处理 throw则是抛出了异常，执行throw则一定抛出了某种异常

throw和throws关键字作用

 * throw：将异常对象抛出，抛给方法的调用者，结束当前方法的运行。
 * throws：用来声明方法可能会出现的异常，告诉方法调用者在调用方法时要注意处理异常。

throw和throws使用格式 * throw new 异常类名(); * throws 异常类名...throw和throws使用位置 * throw：使用方法体中 * throws：使用在方法声明上throw和throws使用注意事项 throw: 必须异常对象或异常子类对象 throws:可以声明多个异常，多个异常之间使用逗号分割。

public class ExceptionDemo {
 public static void main(String[] args) {
 
  try {
   method();
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
​
​
 public static void method() throws Exception {
  int a = 10;
  int b = 0;
  if (b == 0) {
   throw new Exception();
  } else {
   System.out.println(a / b);
  }
 }
​
​

finally

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

注意：如果在执行到finally之前jvm退出了，就不能执行了。

A:格式

try...catch...finally...

B:用于释放资源，在IO流操作和数据库操作中会见到

public class FinallyDemo {
 public static void main(String[] args) {
  String s = "2014-11-20";
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
​
  Date d = null;
  try {
   // System.out.println(10 / 0);
   d = sdf.parse(s);
  } catch (ParseException e) {
   e.printStackTrace();
   System.exit(0);//如果在执行到finally之前jvm退出了，就不能执行了。
  } finally {
   System.out.println("这里的代码是可以执行的");
  }
​
  System.out.println(d);
 }
​
​

final,finally和finalize的区别

final：最终的意思，可以修饰类，成员变量，成员方法

修饰类，类不能被继承

修饰变量，变量是常量

修饰方法，方法不能被重写

finally：是异常处理的一部分，用于释放资源。

一般来说，代码肯定会执行，特殊情况：在执行到finally之前jvm退出了

finalize：是Object类的一个方法，用于垃圾回收

如果catch里面有return语句，请问finally里面的代码还会执行吗?

如果会，请问是在return前，还是return后。

会。前。

准确的说，应该是在中间。

public class FinallyDemo2 {
 public static void main(String[] args) {
  System.out.println(getInt());
 }
​
 public static int getInt() {
  int a = 10;
  try {
   System.out.println(a / 0);
   a = 20;
  } catch (ArithmeticException e) {
   a = 30;
   return a;
   /*
    * return a在程序执行到这一步的时候，这里不是return a而是return 30;这个返回路径就形成了。
    * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
    * 再次回到以前的返回路径，继续走return 30;
    */
  } finally {
   a = 40;
   return a;//如果这样结果就是40了。
  }
  // return a;
 }
​

try...catch...finally的格式变形

A:try...catch...finally

B:try...catch

C:try...catch...catch...

D:try...catch...catch...finally

E:try...finally 这种做法的目前是为了释放资源。

异常类

必须继承自Exception或者RuntimeException

两种方式：

编译时异常继承 Exception，运行时异常继承 RuntimeException。

异常类注意事项:（只针对编译时异常）

A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)

B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常

C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,

如果子类方法内有异常发生,那么子类只能try,不能throws

public class ExceptionDemo {
​
}
​
class Fu {
 public void show() throws Exception {
 }
​
 public void method() {
 }
}
​
class Zi extends Fu {
 @Override
 public void show() throws ArithmeticException {
​
 }
​
 @Override
 public void method() {
  // String s = "2014-11-20";
  // SimpleDateFormat sdf = new SimpleDateFormat();
  // Date d = sdf.parse(s);
  // System.out.println(d);
 }
}
​

编译时异常和运行时异常

编译时异常的概念 * 除了运行时异常以外的所有异常都是编译时异常。 运行时异常的概念 * 只要是RuntimeException或RuntimeException的子类都是运行时异常。

编译时异常的特点 * 如果方法体中抛出的异常是编译时异常，则要求必须要处理。 * 如果方法声明中声明的异常是编译时异常，则要求方法调用者一定要处理。 运行时异常的特点 * 如果方法体中抛出的异常是运行时异常，则可以处理可以不处理。 * 如果方法声明中声明的异常是运行时异常，则方法调用者可以处理，可以不处理。

自定义异常步骤

• 新建一个类

  • 继承Exception

  • 继承RuntimeException

• 异常子类的命名规则

  • XxxxException

• 提供构造方法

  • 无参数构造方法

  • 有参数构造方法

    ​

自定义异常格式

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

/**
 * 自定义异常
 *
 */
public class NoAgeException extends RuntimeException {
    public NoAgeException(){
        
    }
    public NoAgeException(String message){
        super(message);
    }
    
}
​
public class Person {
    private int age;
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        // 判断年龄是否合法
        if(age < 0 || age > 200) {
            // 抛出一个异常
            throw new NoAgeException("你不是地球人，滚回火星去");
        }
        this.age = age;
    }
​
    public Person(int age){
        setAge(age);
        // this.age = age;
    }
​
    public Person() {
        super();
    }
​
    @Override
    public String toString() {
        return "Person [age=" + age + "]";
    }
}
​
public class ExceptionDemo08 {
    public static void main(String[] args) {
        // 创建Person对象
        Person p = new Person(100);
//      p.setAge(300);
        System.out.println(p);
    }
}

常见问题

• 程序出现问题的时候如何判断是错误还是异常？

  • 通过类名判断，如果是以Error是错误，如果是Exception是异常。

• 捕获异常时是不是捕获Exception即可？

  • 不是，因为在实际开发中一般都会针对不同的异常有不同的处理方式。

• 什么时候使用抛出处理？什么时候使用捕获处理?

  • 如果当前代码不是直接跟用户交互的，则可以捕获处理，也可以抛出处理，但是一般捕获处理完毕之后会将一个异常继续抛出，抛给上一层。

  • 如果当前代码是直接跟用户交互，则千万不能抛出处理，要捕获处理。

• 父类方法没有声明抛出异常，子类覆盖方法时发生了异常，怎么办？

  • 只能捕获处理，如果还想使用throw关键字抛出异常对象，那么只能抛出运行时异常。

• 为什么java编译器对运行时异常管理的如此松散？

  • 因为运行时异常可以通过程序猿良好的编程习惯避免。