先看一个示例：
class Demo {
int div(int a, int b) {
return a / b;
}
}
class ExceptionDemo {
public static void main(String[] args) {
Demo d = new Demo();
int x = d.div(4, 1);
System.out.println(x);
int y = d.div(4, 0);
System.out.println(y);
System.out.println("over");
}
}
运行结果为：
4
Exceptionin thread "main" java.lang.ArithmeticException: / by zero
at Demo.div(ExceptionDemo.java:14)
at ExceptionDemo.main(ExceptionDemo.java:6)
附注：当程序运行出现异常后，出现异常位置后的代码就不再运行
1.概念：就是程序在运行时出现的不正常情况
2.由来：问题也就是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象，其实就是java对不正常情况进行描述后的对象体现
3.异常的体系：
Throwable
·Error
----通常出现重大问题如：运行的类不存在或者内存溢出等
----不编写针对代码对其处理
·Exception
----在运行时运行出现的一起情况，可以通过针对性的处理方式进行处理
无论Error或者Exception都具有一些共性内容，比如：不正常情况的信息，引发原因等。
Exception和Error的子类名都是以父类名作为后缀
4.异常的处理格式：
java提供了特有的语句进行处理：
try{
需要被检测的代码；
}catch(异常类变量){
处理异常的代码；(处理方式)
}finally{
一定会执行的语句；
}
针对上面除法出现的异常，我们给出相应的解决方式：
class Demo {
//在功能上通过throws的关键字声明了该功能有可能会出现问题。
int div(int a, int b)throws Exception {
return a / b;
}
}
class ExceptionDemo {
public static void main(String[] args) {
Demo d = new Demo();
try{
int x = d.div(4, 1);
System.out.println(x);
int y = d.div(4, 0);
System.out.println(y);
System.out.println("over1");
}catch (Exception e) {
System.out.println("除0了");
//获取错误信息
System.out.println(e.getMessage());
//异常名称和异常信息
System.out.println(e.toString());
//异常名称，异常信息和异常出现的位置。jvm默认调用就是printStackTrace()
e.printStackTrace();
}
System.out.println("over2");
}
}
运行结果：
4
除0了
/ by zero
java.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zero
at Demo.div(ExceptionDemo.java:26)
at ExceptionDemo.main(ExceptionDemo.java:7)
over2
总结：当程序运行出现异常后，出现异常位置后的代码就不再运行，在函数上声明异常，便于提高安全性，让调用者进行处理。
5.Throwable中的方法
·getMessage()----获取异常信息，返回字符串
·toString()----获取类名和异常信息，返回字符串
·printStackTrace()----获取类名和异常信息，以及异常出现在程序中的位置,返回值void
·printStackTrace(PringStrean s)----通常用该方法将异常内容保存在日志文件中，以便查阅
6.对异常的处理：
★声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
★对方声明几个异常，就对应有几个catch块，不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
注意：在进行catch处理时，catch中一定要定义具体处理方式，不要简单定义一句 e.printStackTrace()，也不要简单的就书写一条输出语句。
示例：
class Demo {
//在功能上通过throws的关键字声明了该功能有可能会出现问题。
void div(int a, int b) throws ArithmeticException,
ArrayIndexOutOfBoundsException{
System.out.println(a/ b);
int[] arr = new int[a];
System.out.println(arr[4]);
}
}
class ExceptionDemo {
public static void main(String[] args) {
Demo d = new Demo();
try{
d.div(6,2);
System.out.println("-------");
//被零除了!!
d.div(5,0);
System.out.println("-------");
//角标越界啦！！
d.div(4,2);
}catch (ArithmeticException e) {
System.out.println(e.toString());
System.out.println("被零除了!!");
}catch (ArrayIndexOutOfBoundsException e) {
System.out.println(e.toString());
System.out.println("角标越界啦！！");
}catch (Exception e) {
System.out.println("hahah:"+ e.toString());
}
System.out.println("over");
}
}
运行结果：
3
0
-------
java.lang.ArithmeticException: / by zero
被零除了!!
over
7.自定义异常：
因为项目中会出现特有的问题，而这些问题并未被java所描述并封装，所以对于这些特有的问题可以按照java对问题封装的思想将特有问题进行自定义的异常封装。
当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作，要么在内部try…catch处理，要么在函数上声明让调用者处理
一般情况下，函数内出现异常，函数上需要声明
如果发现打印的结果中只有异常的名称，却没有异常的信息，是因为自定义的异常并为定义信息。
那么如何定义异常信息呢？
因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句，那么就可以直接通过getMessage()方法获取自定义的异常信息了。
自定义类继承Exception或者其子类
继承Exceprion的原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。只有这个体系中的类和对象才可以被throws和throw操作。
通过构造函数定义异常信息
throws和throw
throws用于标识函数暴露出的异常
throw用于抛出异常
throws和throw的区别：
throws用在函数上，后面跟异常类名
throw用在函数内，后面跟异常对象
示例：（对于除数是-1，也视为是错误的是无法进行运算的）
class FuShuException extends Exception{
private int value;
FuShuException(){
super();
}
FuShuException(String msg,int value){
super(msg);
this.value=value;
}
public int getValue(){
return value;
}
}
class Demo{
int div(int a,int b)throws FuShuException{
if(b<0)
//手动通过throw关键字抛出一个自定义异常对象
throw new FuShuException(“出现了除数是负数的情况----/by fushu”,b);
return a/b;
}
}
class ExceptionDemo{
public static void main(String[] args){
Demo d=new Demo();
try{
int x=d.div(4,-9);
System.out.println(x);
}catch(FuShuExceptione){
System.out.println(e.toString());
System.out.println(“错误的负数是：”+e.getValue());
}
System.out.println(“over”);
}
}
运行结果是：
FuShuException:出现了除数是负数的情况----/by fushu
错误的负数是：-9
over
8.RuntimeException讲解：
Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常，如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过；如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。
注意：
异常细节：自定义异常时：如果该异常的发生，无法在继续进行运算，就让自定义异常继承RuntimeException。
异常分两种:
1.编译时被检测的异常；2.编译时不被检测的异常（运行时异常，RuntimeException以及其子类）
示例：
class FuShuException extendsRuntimeException {
FuShuException(String msg) {
super(msg);
}
}
class Demo {
int div(int a, int b) throws ArithmeticException {
if(b < 0)
throw new ArithmeticException("出现了除数为负数了");
if(b == 0)
throw new ArithmeticException("被零除啦");
return a / b;
}
}
class ExceptionDemo {
public static void main(String[] args) {
Demo d = new Demo();
int x = d.div(4, 2);
System.out.println("x="+ x);
int y = d.div(4, -2);
System.out.println("y="+ y);
System.out.println("over");
}
}
运行结果：
x=2
Exceptionin thread "main" java.lang.ArithmeticException:出现了除数为负数了
at Demo.div(ExceptionDemo.java:20)
at ExceptionDemo.main(ExceptionDemo.java:6)
总结：
·RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明
·一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类
·如果父类抛出多个异常的一个子集，不能抛出新的异常
·介绍异常在分层设计时的层内封装
练习：（自定义异常，对上课可能出现的意外情况进行处理）
假设问题有：电脑蓝屏、电脑冒烟（要对问题进行描述，封装成类），当出现不同的问题，要进行相应的处理
代码实现如下：
class LanPingException extends Exception {
LanPingException(String msg) {
super(msg);
}
}
class MaoYanException extends Exception {
MaoYanException(String msg) {
super(msg);
}
}
class NoPlanException extends Exception {
NoPlanException(String msg) {
super(msg);
}
}
class Computer {
private int state = 3;
public void run() throws LanPingException, MaoYanException {
if(state == 2)
throw new LanPingException("蓝屏了");
if(state == 3)
throw new MaoYanException("冒烟了");
System.out.println("电脑运行");
}
public void reset() {
state= 1;
System.out.println("电脑重启");
}
}
class Teacher {
private String name;
private Computer cmpt;
Teacher(String name) {
this.name= name;
cmpt= new Computer();
}
public void prelect() throws NoPlanException {
try{
cmpt.run();
} catch (LanPingException e) {
System.out.println(e.getMessage());
cmpt.reset();
}catch (MaoYanException e) {
thrownew NoPlanException("课时无法继续.." + e.getMessage()+"..."+this.test());
}
System.out.println("继续讲课");
}
publicString test() {
return"学生自己练习";
}
}
class ExceptionDemo {
public static void main(String[] args) {
Teachert = new Teacher("王老师");
try{
t.prelect();
}catch (NoPlanException e) {
System.out.println(e.toString());
}
}
}
运行结果：
NoPlanException:课时无法继续..冒烟了...学生自己练习
9. finally代码块
定义一定执行的代码，通常用于关闭资源。（比如数据库的关闭，流的关闭等等）
示例：
class FuShuException extends Exception {
FuShuException(String msg) {
super(msg);
}
}
class Demo {
int div(int a, int b) throws FuShuException {
if(b < 0)
throw new FuShuException("除数为负数");
returna / b;
}
}
class ExceptionDemo {
public static void main(String[] args) {
Demo d = new Demo();
try{
int x = d.div(4, -1);
System.out.println("x="+ x);
}catch (FuShuException e) {
System.out.println(e.toString());
return;
//System.exit(0);//系统，退出。jvm结束。
}finally {
System.out.println("finally");//finally中存放的是一定会被执行的代码。
}
System.out.println("over");
}
}
运行结果：
FuShuException:除数为负数
finally
总结：
当System.exit(0);语句打开后，系统就会退出，jvm结束，finally语句不会执行。
当return语句关闭后，System.out.println("over");也会执行。
示例2：（关于数据库的使用）
class NoException extends Exception{
}
处理数据库的方法：
public void method()throws NoException{
//连接数据库;
//数据操作;//throw new SQLException();
//关闭数据库;//该动作，无论数据操作是否成功，一定要关闭资源。
try{
连接数据库;
数据操作;//throw new SQLException();
}catch(SQLException e){
会对数据库进行异常处理;
throw new NoException();
}finally{
关闭数据库;
}
}
10.try、catch、finally的组合形式
第一种格式：
try{
}catch(){
}
第二种格式：
try{
}catch(){
}finally{
}
第三种格式：
try{
}finally{
}
附注：catch是用于处理异常，如果没有catch就代表异常没有被处理过，如果该异常是检测时异常，那么必须声明.
11.异常在子父类覆盖中的体现：
⑴子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常或者该异常的子类
⑵如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
⑶如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常，就必须要进行try处理，绝对不能抛。
示例：
class AException extends Exception {}
class BException extends AException {}
class CException extends Exception {}
class Fu {
void show() throws AException, CException {}
}
class Zi extends Fu {
//子类覆盖父类方法时，抛出父类的异常或者该异常的子类
void show() throws AException, BException, CException {}
}
class Test {
voidfunction(Fu f) {
try{
f.show();
}catch (AException | CException e) {
e.printStackTrace();
}
}
}
练习：（有一个圆形和长方形，都可以获取面积，对于面积如果出现非法的数值，视为是获取面积出现问题，问题通过异常来表示）
代码如下：
interface Shape {
void getArea();
}
class NoValueException extendsRuntimeException {
NoValueException(String message) {
super(message);
}
}
class Rec implements Shape {
private int len, wid;
Rec(int len, int wid){
if(len <= 0 || wid <= 0)
throw new NoValueException("长方形出现非法值");
this.len= len;
this.wid= wid;
}
public void getArea() {
System.out.println(len* wid);
}
}
class Circle implements Shape {
private int radius;
public static final double PI = 3.14;
Circle(intradius) {
if(radius <= 0)
throw new NoValueException("圆形半径非法");
this.radius= radius;
}
public void getArea() {
System.out.println(radius* radius * PI);
}
}
class ExceptionDemo {
public static void main(String[] args) {
Recr1 = new Rec(3, 4);
r1.getArea();
Circlec1 = new Circle(4);
c1.getArea();
System.out.println("-------");
Recr2 = new Rec(3, -4);
r2.getArea();
Circlec2 = new Circle(-4);
c2.getArea();
}
}
运行结果：
12
50.24
-------
Exceptionin thread "main" NoValueException:长方形出现非法值
at Rec.<init>(ExceptionDemo.java:27)
at ExceptionDemo.main(ExceptionDemo.java:8)
二、包（package）
1.特点：
·对类文件进行分类管理
·给类提供多层命名空间
·卸载程序文件的第一行
·类名的全名是 包名.类名
·包也是一种封装形式
2.包之间的访问：
·被访问的包中类的权限必须是public的
·类中的成员权限：public或者protected
·protected是为其他包中的子类提供一种权限
3.四种权限:
import作用：
·简化包名
·一个程序文件中只有一个package，可以有多个import
·用来导入包中的类，不导入包中的包
·通常写importmypack.Demo（如果写importmypack.*的话，jvm会依次寻找，降低运行速度）
附注：（常用包）
java.lang： java的核心包 jdk1.2版本以后，该包中的类自动导入。
java.awt：用于制作图形界面。
java.io：用于操作设备上的数据。
java.util：这里定义是java的工具类。（集合，日期……）
java.net：用于网络通讯的。