黑马程序员——java基础——异常

最新推荐文章于 2024-06-07 08:18:49 发布

Huberry

最新推荐文章于 2024-06-07 08:18:49 发布

阅读量545

点赞数

分类专栏：日记文章标签：黑马程序员 java 异常处理

本文链接：https://blog.csdn.net/Huberry/article/details/39079231

版权

日记专栏收录该内容

14 篇文章 0 订阅

订阅专栏

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、异常

1、异常概述

1)异常：就是程序在运行时出现不正常情况，是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

Java中的异常用对象来表示。Java对异常的处理是按异常分类处理的，不同异常有不同的分类，每种异常都对应一个类型(class)，每个异常都对应一个异常(类的)对象。

2)异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。

Java中的异常，主要有两个来源：一是Java运行时环境自动抛出系统生成的异常，而不管你是否愿意捕获和处理，它总要被抛出!比如除数为0的异常；二是程序员自己抛出的异常，这个异常可以是程序员自己定义的，也可以是Java语言中定义的，用throw 关键字抛出异常，这种异常常用来向调用者汇报异常的一些信息。

3)程序可能出现的错误或问题

a)用户输入错误导致的异常：如用户不正常使用程序，输入一些非法参数

b)设备硬件等发生的错误：如硬盘损坏等

c)物理限制：如存储空间不足等

d)代码错误：在程序编写的方法可能不正确，返回错误参数等。

2、异常体系

1)有两种对问题的划分方式：

一种是严重的问题；

一种是非严重的问题。

对于严重的问题，java通过Error类进行描述。对Error类一般不编写针对性的代码对其进行处理。

对于非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。

无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。

这也就构成了Java的异常体系：

Throwable

|---Error //通常出现重大问题如：运行的类不存在或者内存溢出等。

|---Exception //运行时出现的一起情况

|---RuntimeException //特殊异常类，抛时不需要声明

Exception和Error的子类名都是以父类名作为后缀。

2)异常体系的特点：

a)异常体系中的所有类以及建立的对象都具备可抛性。

b)也就是说可以被throw和throws关键字所操作。

c)只有异常体系具备这个特点。

3、异常有两种：

1)编译时被检测异常

该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表着可以被处理。

2)运行时异常(编译时不检测)

在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。如：RuntimeException以及其子类。

4、java异常类

1）Throwable类

Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类(或其子类之一)的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。

　　两个子类的实例，Error 和 Exception，通常用于指示发生了异常情况。通常，这些实例是在异常情况的上下文中新近创建的，因此包含了相关的信息(比如堆栈跟踪数据)。

　　2）Exception

　　Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件，表示程序本身可以处理的异常。

　　3）Error

　　Error 是 Throwable 的子类，表示仅靠程序本身无法恢复的严重错误，用于指示合理的应用程序不应该试图捕获的严重问题。

　　在执行该方法期间，无需在方法中通过throws声明可能抛出但没有捕获的 Error 的任何子类，因为Java编译器不去检查它，也就是说，当程序中可能出现这类异常时，即使没有用try...catch语句捕获它，也没有用throws字句声明抛出它，还是会编译通过。

　　4、RuntimeException

　　RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。Java编译器不去检查它，也就是说，当程序中可能出现这类异常时，即使没有用try...catch语句捕获它，也没有用throws字句声明抛出它，还是会编译通过，这种异常可以通过改进代码实现来避免。

5、异常的处理

1)java提供了特有的语句进行异常处理。

try{

需要被检测的代码。

}catch（异常类变量）{

处理异常的代码；（处理方式）

}finally{

一定会执行的语句；

}

2)对于可能出现异常的代码，有两种处理办法：

a)在方法中用try...catch语句捕获并处理异常，catach语句可以有多个，用来匹配多个异常。例如：

public void Demo(intx){
　　try{

...

}catch(Exceptione){
　　...
　　}finally{
　　...
　　}
　　}　　

b)对于处理不了的异常或者要转型的异常，在方法的声明处通过throws语句抛出异常。例如：

public void Demo()throws MyException{
　　...
　　if(....){
　　throw new MyException();
　　}
　　}

注意：

a）finally中定义的通常是关闭资源代码。因为资源必须释放。如果在一个功能中，定义了一些必须要执行的代码，可以用try{}finally{}的方式，将一定执行的代码放在finally代码块中。finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。

b）try语句不能单独存在, try、catch、finally三个代码块中变量的作用域分别独立而不能相互访问。如果要在三个块中都可以访问，则需要将变量定义到这些块的外面。

c）throw语句后不允许有紧跟其他语句，因为这些没有机会执行。如果一个方法调用了另外一个声明抛出异常的方法，那么这个方法要么处理异常，要么声明抛出。

d）若方法上抛出多个异常，需要有多个catch对每个异常进行捕捉处理，且父类异常写在后面。多个catch块时候，Java虚拟机会匹配其中一个异常类或其子类，就执行这个catch块，而不会再执行别的catch块。

3)throw和throws的用法

throw定义在函数内，用于抛出异常对象。

throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。

注意：RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。

4)对捕获到的异常对象进行常见方法操作：

String getMessage（）；//获取异常的信息。返回字符串。

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

printStackTrace();//获取异常类名和异常信息，以及异常出现在程序中的位置.返回值void.

//其实JVM默认的异常处理机制，就是在调用printStackTrace方法，打印异常的堆栈的跟踪信息。

printStackTrace(PrintStream s)//通常用该方法将异常内容保存在日志文件中，以便查阅。

6、自定义异常

1)为什么要自定义异常

因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对这些特有的问题可以按照java中的面向对象思想。将特有的问题，进行自定义的异常封装。定义类继承Exception或者RuntimeException，这就叫做自定义异常。

2)如何自定义异常

a)使用已有的异常类，假如抛出IOException、SQLException。

try{

程序代码

}catch(IOException ioe){
　　程序代码
}catch(SQLException sqle){
　　程序代码
}finally{
　　程序代码
}

　　b)自定义异常类

　　创建Exception或者RuntimeException的子类即可得到一个自定义的异常类。例如:

public class MyException extends Exception{

publicMyException(){}

publicMyException(String smg){

super(smg);

}

c)使用自定义的异常

　　用throws声明方法可能抛出自定义的异常，并用throw语句在适当的地方抛出自定义的异常。例如：

　　在某种条件抛出异常

public void test1() throws MyException{
　　...
　　if(....){
　　throw new MyException();
　　}
　　}

　　将异常转型(也叫转译)，使得异常更易读易于理解

　 public void test2() throwsMyException{
　　...
　　try{
　　...
　　}catch(SQLException e){
　　...
　　throw new MyException();
　　}
　　}

注：自定义异常：

必须是自定义类有继承关系，通常继承Exception。

继承Exception原因：

异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

只有这个体系中的类和对象才可以被throws和throw操作。

7、异常处理的原则和注意事项

1)问题在内部被解决就不需要声明。

2)catch是用于处理异常。如果没有catch就代表异常没有被处理，如果该异常是检测时异常。那么必须声明。

3)在子父类覆盖时：

a)子类抛出的异常必须是父类的异常的子类或者子集。

b)如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。

4)避免过大的try块，不要把不会出现异常的代码放到try块里面，尽量保持一个try块对应一个或多个异常。

5)细化异常的类型，不要不管什么类型的异常都写成Excetpion。

6)catch块尽量保持一个块捕获一类异常，不要忽略捕获的异常，捕获到后要么处理，要么转译，要么重新抛出新类型的异常。

7)不要把自己能处理的异常抛给别人。

8)不要用try...catch参与控制程序流程，异常控制的根本目的是处理程序的非正常情况。

二、包

1、package

在java中，管叫包，相当于文件夹。包里通常存放的是类文件，因为我们在编写程序的时候，难免会有类名相同的情况，就如我们人名一样。为了对类进行分类管理，java就有了包的出现，在不同包中可以有相同的类名，调用的时候连同包名一起就行。

包也是一种封装形式。在包中可以有很多类文件，但是只提供一个类文件，供外界使用。

2、包的作用

1）为避免多个类重名的情况，如果出现两个相同名字的类，可通过包将两者区分，从而避免冲突。

2）对类文件进行分类管理，可以将相关的一些类放在同一个包中。

3）给类提供多层命名空间，如a包中的Demo.class文件，如果要创建Demo对象，就要在使用时加上a.如：a.Demo demo=newa.Demo（）；

4）包的出现可以将java的类文件和源文件相分离。

3、规则

1）包必须写在程序的第一行。因为要先有包，才知道类文件的存放地方。

2）类的全称：包名.类名。

3）编译定义了包的程序文件时，在编译时要指定包的存储目录。

如：javac –d c:\mypack类名.java

4、包之间的访问

1）要访问其他包中的类，需要定义类的全称：包名.类名。

2）包如果不在当前路径，需要使用classpath设定环境变量，为JVM指明路径。

3）被访问的包中的类权限必须是public的。

4）类中的成员权限：public或者protected。protected是为其他包中的子类提供的一种权限。类公有后，被访问的成员也要公有才可以被访问。不同包中的子类可以直接访问父类中被protected权限修饰的成员。同一个包中，protected只作用为覆盖。

四种权限

	public	protected	defauld	Private
同一类中	可以	可以	可以	可以
同一包中	可以	可以	可以	不可以
子类	可以	可以	不可以	不可以
不同包中	可以	不可以	不可以	不可以