异常:就是程序在运行时出现不正常情况.
异常由来:问题也是现实生活中一个具体事务,也可以通过java类的形式进行描述,并封装成对象.其实就是java对不正常情况进行描述后的对象体现.
对于问题的划分:两种:一种是严重问题,一种非严重的问题.
对于严重的,java通过Error类进行描述.
对于Error一般不编写针对性的代码对其进行处理.
对于非严重的,java通过Exception类进行描述.
对于Exception可以使用针对性的处理方式进行处理.
无论Error或者Exception都具有一些共性内容.
比如:不正常情况的信息,引发原因等..
异常体系:
Throwable
|--Error
|--Exception
|--RuntimeException
异常处理的语句:
try
{
需要被检测的代码
}
catch()
{
处理异常的代码
}
finally
{
一定会执行的代码
}
有三种结合格式
第一个格式
try
{
}
catch ()
{
}
第二个格式
try
{
}
catch ()
{
}
finally
{
}
第三个格式
try
{
}
finally
{
}
注意:
1.finally中定义的通常是关闭资源代码.因为资源必须被释放.
2.finally只有一种情况不执行,当执行到System.exit(0);finally不会执行.
3.catch是用于处理异常.如果没有catch就代表该异常没有被处理过,如果该异常是检测时的异常,就必须声明.
对catch到的异常对象进行常见方法操作:
.getMassage():获取异常信息
.toString():异常名称 异常信息
.printStackTrace():最全面,异常信息,位置,名称
jvm默认的异常处理机制,就是调用printStackTrace打印
- class Demo
- {
- int div(int a,int b)
- {
- return a/b;
- }
- }
- class ExceptionDemo
- {
- public static void main(String[] args)
- {
- Demo d = new Demo();
- try
- {
- int x = d.div(4,0);
- System.out.println(x);
- }
- catch (Exception e)
- {
- System.out.println("除零啦");
- System.out.println(e.getMessage());//结果为 异常信息 /by zero
- System.out.println(e.toString());//结果为 异常名字:异常信息
- e.printStackTrace();//结果为 异常名称:异常信息,异常出现的位置
- //其实jvm的异常处理机制,就是在调用printStackTrace方
- 法,打印异常的堆栈跟踪信息
- }
- System.out.println("over");
- }
- }
异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛性,也就是可以被throw和throws关键字所操作.只有异常体系具备这个特点.
throw和throws用法:
throw定义在函数内,用于抛出异常对象.
thows定义在函数上,用于抛出遗产类,可以抛出多个,用逗号隔开.
当函数内容有throw抛出异常对象,并未进行try处理.必须要在函数上声明,否则编译失败.
注意,RuntimeException除外.也就是,函数内如果抛出的是RuntimeException异常,函数上可以不用声明.
多异常的处理.
1.声明异常时,建议声明更为具体的异常,这样处理的更为具体.
2.对方声明几个异常,就对应几个catch块.不要定义多余的catch块
如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面.
建立在进行catch处理时,catch中一定要定义具体处理方式.
不要简单定义一句e.printStackTrace.也不要简单的就书写一条输出语句.
如果函数声明了异常,调用者需要进行处理.处理方式可throws可try.
- class Demo
- {
- int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//在功能上通过throws关键字声明了该功能有可能会出现问题.
- {
- int[] arr = new int[a];
- System.out.println(arr[4]);
- return a/b;
- }
- }
- class ExceptionDemo1
- {
- public static void main(String[] args)
- {
- Demo d = new Demo();
- try
- {
- int x = d.div(4,0);
- System.out.println(x);
- }
- catch (ArithmeticException e)
- {
- System.out.println(e.toString());
- System.out.println("被零除了");
- }
- catch (ArrayIndexOutOfBoundsException e)
- {
- System.out.println(e.toString());
- System.out.println("角标越界了");
- }
- System.out.println("over");
- }
- }
Exception中有一个特殊的子类异常RuntimeException(运行时异常).
如果在函数内容抛出该异常,函数上可以不用声明,编译一样通过.
如果函数上声明了该异常.调用者可以不用进行处理.编译一样通过.
之所以不用在函数上声明,是因为不需要让调用者处理.
当该异常发生,希望该程序停住,以为在运行时,出现了无法继续运算的情况,希望停止程序后,对代码进行修正.
编译时被检测异常
该异常在编译时,如果没有处理()没有throws,也没有try),编译失败
该异常被标识,代表可以被处理.
编译时不检测(运行时异常,RuntimeException以及其子类))
在编译时,不需要处理,编译器不检查.
该异常发生,建议不处理,让程序停止,需要对代码进行修正.
-------------------------------------
自定义异常:
因为项目中会出现特有的问题,而这些问题并未被java所描述并封装对象,所以对于这些特有的问题可以按照java的对问题封装的思想,将特有的问题,进行自定义的异常封装.
定义类集成Exception或者RuntimeException
1.为了让该自定义类具备可抛性.
2.让该类具备操作异常的共性方法.
当要定义自定义异常的信息时,可以使用父类已经定义好的功能
将异常信息传递给父类的构造函数.
class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}
自定义异常时 : 如果该异常的发生 , 无法在继续进行运算 , 就让自定义异常继承 RuntimeException.异常的好处:
1.将问题进行封装.
2.将正常流程代码和问题处理代码相分离,方便与阅读
异常的处理原则:
1.处理方式有两种:try或者throws.
2.调用到抛出异常的功能时,抛出几个,就处理几个.
会出现一个try对应多个catch的情况.
3.多个catch,父类的catch放到最下面.
4.catch内,需要定义针对性的处理方式.不要简单的定义输出语句.也不要不写.
当捕获到的异常,本功能处理不了时,可以继续在catch中抛出,见下面
try
{
throw new AException();
}
catch (AException e)
{
throw e;
}
如果该异常处理不了,但并不属于该功能出现的异常.
可以将异常转换后,在抛出和该功能相关的异常.
或者异常可以处理,当需要将异常产生和本功能相关问题提供出去.
让调用者知道,并处理.也可以将捕获异常处理后,转换成新的异常抛出.
try
{
throw new AException();
}
catch (AException e)
{
//对Aexception处理完后.
throw new BException();
}
异常在子父类覆盖中的体现:
1.子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该异常的子类.
2.如果父类方法抛出多个异常,那么子类覆盖该方法时,只能抛出父类异常的子集.
3.如果父类或者接口的方法中没有异常抛出,那么子类覆盖方法时,也不可以抛出异常.如果子类方法发生了异常,就必须要进行try处理,绝对不能抛出.
异常练习1
- /*
- 毕老师用电脑上课.
- 开始思考上课中出现的问题.
- 比如问题是
- 电脑蓝屏
- 电脑冒烟
- 要对问题进行描述,封装成对象.
- 可是当冒烟发生后,出现讲课进度无法继续.
- 出现了讲师的问题:课时计划无法完成.
- */
- //定义一个电脑类
- class Computer
- {
- private int value = 3;
- void run()throws LanPingException,MaoYanException
- {
- if (value==2)
- throw new LanPingException("电脑蓝屏");
- if (value==3)
- throw new MaoYanException("电脑冒烟");
- System.out.println("电脑开机");
- }
- void restart()
- {
- value = 1;
- System.out.println("电脑重启");
- }
- }
- //教师类
- class Teacher
- {
- private Computer cp;
- private String name;
- Teacher(String name)
- {
- this.name = name;
- cp = new Computer();
- }
- public void inClass()throws NoPlanException
- {
- try
- {
- cp.run();
- }
- catch (LanPingException lp)
- {
- System.out.println(lp.toString());
- cp.restart();
- }
- catch (MaoYanException my)
- {
- test();
- throw new NoPlanException("课时无法进行"+my.getMessage());
- }
- System.out.println(name+"讲课");
- }
- public void test()
- {
- System.out.println("练习");
- }
- }
- //电脑冒烟的异常类
- class MaoYanException extends Exception
- {
- MaoYanException(String e)
- {
- super(e);
- }
- }
- //电脑蓝屏的异常类
- class LanPingException extends Exception
- {
- LanPingException(String e)
- {
- super(e);
- }
- }
- //讲课无法进行的异常类
- class NoPlanException extends Exception
- {
- NoPlanException(String e)
- {
- super(e);
- }
- }
- class ExceptionTest
- {
- public static void main(String[] args)
- {
- try
- {
- Teacher t = new Teacher("毕老师");
- t.inClass();
- }
- catch (NoPlanException np)
- {
- System.out.println(np.toString());
- System.out.println("换老师或者放假");
- }
- }
- }
- /*
- 有一个圆形和长方形.
- 都可以获取面积.对于面积如果出现非法的数值,视为获取面积出现问题.
- 问题通过异常来表示.
- 现在对这个程序进行基本设计
- */
- //圆形和长方形都能获取面积,把他抽取出来,作为一个共性的扩展功能,以接口的形式
- interface Area
- {
- public abstract void getArea();
- }
- //定义一个异常类继承RuntimeException
- class NoException extends RuntimeException
- {
- NoException(String msg)
- {
- super(msg);
- }
- }
- //长方形实现面积
- class Rec implements Area
- {
- private int len;
- private int wid;
- Rec(int len,int wid)throws RuntimeException
- {
- //抛出长宽小于等于0的异常
- if (len<=0||wid<=0)
- {
- throw new NoException("你输入的是无效数字");
- }
- this.len = len;
- this.wid = wid;
- }
- //覆盖父类方法
- public void getArea()
- {
- System.out.println(len*wid/2);
- }
- }
- class ExceptionTest
- {
- public static void main(String[] args)
- {
- new Rec(4,0).getArea();
- }
- }
Package 包:java中的文件夹
包的作用:对类文件(.class)进行分类管理.
给类提供多层命名空间.
注意:写在程序文件的第一行,包名.类名.
包也是封装的一种体现形式.
将编译好的类文件放在指定的path路径下:javac -d 目录名 类名
包与包之间进行访问,被访问的包中的类以及类中成员,需要public修饰.
不同包中的子类还可以直接访问父类中被protected权限修饰的成员.
包与包之间可以使用的权限只有两种,public protected.
权限修饰符的权限范围:
public protected default private
同一个类中 ok ok ok ok
同一个包中 ok ok ok no
子类 ok ok no no
不同包中 ok no no no
一个.java文件不能出现一个以上的public修饰的类,因为被public修饰的类名和文件名必须保持一致.出现两个或者两个以上时,无法确定文件名,编译不能通过.
为了简化类名书写,使用一个关键字,import.
import 导入的是包中的类
建议,不要写通配符 * ,需要用到包中那个类,就导入那个类.
建议定义包名不要重复,可以使用url来完成定义,url是唯一的.
jar包
java的压缩包
方便项目携带
方便于使用,只要在classpath设置jar路径即可
示例 1: 将两个类文件归档到一个名为 classes.jar 的归档文件中:
jar cvf classes.jar Foo.class Bar.class
示例 2: 使用现有的清单文件 'mymanifest' 并
将 foo/ 目录中的所有文件归档到 'classes.jar' 中:
jar cvfm classes.jar mymanifest 包或者类名。