异常finally
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("除数为负数");
return a/b;
}
}
class ExceptionDemo5
{
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());
}
finally
{
System.out.println("finally");//finally中存放的是一定会被执行的代码
}
System.out.println("over");
}
}
第一个格式:
try
{
}
catch()
{
}
第二个格式:
try
{
}
catch()
{
}
finally
{
}
第三个格式:
try
{
}
finally
{
}
catch是用于处理异常的,如果没有catch就代表异常没有被处理过,如果该异常是检测时异常,那么必须声明。
class Demo
{
public void method() //throws Exception
{
try
{
throw new Exception();
}
finally
{
//关闭资源
}
}
}
要在函数上声明异常(throws Exception)编译才能通过。
异常在子父类覆盖中的体现
1,子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或该异常的子类
2,如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出父类异常的子集。(不超过父类就行)
3,如果父类或者接口的方法没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常。如果子类方法发生了异常,就必须进行try处理,绝对不能抛。
class AException extends Exception
{
}
class BException extends AException
{
}
class CException extends Exception
{
}
class Fu
{
void show()throws AException
{
}
}
class Zi extends Fu
{
void show()throws BException
{
}
}
class
{
public static void main(String[] args)
{
}
}
练习:
有一个圆形和长方形
都可以获取面积,对于面积如果出现非法数值,视为是获取面积出现问题
问题通过异常来表示
现有对这个程序进行基本设计
class NoValueException extends RuntimeException
{
NoValueException(String message)
{
super(message);
}
}
interface Shape
{
void getArea();
}
class Rec implements Shape
{
private int len,wid;
Rec(int len,int wid) //throws NoValueException
{
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(int radius)
{
if(radius<-0)
throw new NoValueException("出现非法值");
this.radius = radius;
}
public void getArea()
{
System.out.println("圆面积="+radius*radius*PI);
}
}
class ExceptionTest1
{
public static void main(String[] args)
{
Rec r = new Rec(8,4);
r.getArea();
Circle c = new Circle(-3);
c.getArea();
System.out.println("over");
}
}
异常总结:
是什么?是对问题的描述,将问题进行对象的封装
异常体系:
Throwable
|–Error
|–Exception
|–RuntimeException
异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛性
也就是说可以被throw和throws关键字所操作
throw和throws的用法:
throw定义在函数内,用于抛出异常对象
throws定义在函数上,,用于抛出异常类,可以抛出多个用逗号隔开
当函数内容有throw抛出异常对象,并未进行try处理,必须要在函数上声明,否则编译失败
注意,RunTimeException除外,也就是说,函数内如果抛出的RuntimeException异常,函数上可以不用声明。
如果函数声明了异常,调用者需要进行处理,处理方法可以throws可以try
异常有两种,
1编译时被检测异常,
该异常在编译时,如果没有处理(没有抛也没有try)那么编译失败
该异常被标识,代表着可以被处理
2运行时异常(编译时不检测)
在编译时,不需要处理,编译器不检查
该异常的发生,建议不处理,让程序停止,需要对代码进行修正。
finally只有在运行System.exit(0)时,不运行。
System.exit(0)代表系统退出,结束jvm。
自定义异常:
定义继承Exception或者RuntimeException
1,为了让该自定义类具备可抛性
2,让该类具备操作异常的共性方法
当要定义自定义异常的信息时,可以使用父类已经定义好的功能。
将异常信息传递给父类的构造函数。
class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}
自定义异常,按照java的面向对象思想,将程序中出现的特有问题进行封装。
异常的好处:
1,将问题进行封装
2,将正常流程代码和问题处理代码相分离,方便于阅读
异常的处理原则
1,处理方式有两种:try或者throws
2,调用到抛出异常的功能时,抛出几个,就处理几个。
一个try对应多个catch。
3,多个catch,父类的catch放到最下面
4,catch内,需要定义针对性的处理方式,不要简单的定义printStackTrace,输出语句。
也不要不写
当捕获到的异常,本功能处理不了时,可以继续在catch中抛出。
try
{
throw new AException();
}
catch(AException e )
{
throw e;
}
如果该异常处理不了,但并不属于该功能出现的异常
可以将异常转换后,在抛出和该功能相关的异常。
或者异常可以处理,但需要将异常产生后和本功能相关的问题提供出去。
让调用者知道,并处理。也可以将捕获异常处理后,转换新的异常
try
{
throw new AException();
}
catch(AException e )
{
//对AException处理
throw new BException();
}
异常的注意事项
在子父类覆盖时:
1,子类抛出的异常必须是父类的异常的子类或者子集
2,如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try不能抛。
参阅
ExceptionTest.java 老师用电脑上课
ExceptionTest1.java 图形面积
包
对类文件进行分类管理。
给类提供多层命名空间。
写在程序文件的第一行。
类名的全称的是:包名.类名。
包也是一种封装形式。
package pack;
class PackageDemo
{
public static void main(String[] args)
{
System.out.println("package");
}
}
//类名:pack.PackageDemo
//包名.类名
示例1:
package packa;
public class DemoA
{
public void show()
{
System.out.println("demoa show run");
}
}
package mypack;
class PackageDemo
{
public static void main(String[] args)
{
packa.DemoA d = new packa.DemoA();
d.show();
System.out.println("Hello Package!");
}
}
总结:
包与包之间的访问,被访问的包中的类以及类中的成员,需要public修饰
示例2:
package packa;
public class DemoA extends packb.DemoB
{
public void show()
{
method();
System.out.println("demoa show run");
}
}
package packb;
public class DemoB
{
protected void method()
{
System. out.println("demob show run" );
}
}
package mypack;
class PackageDemo
{
public static void main(String[] args)
{
packa.DemoA d = new packa.DemoA();
d.show();
packb.DemoB b = new packb.DemoB();
//b.method();//报错!无法访问DemoB中的protected修饰的method方法
System.out.println("Hello Package!");
}
}
总结:
不同包中的子类,还可以直接访问父类中被protected权限修饰的成员
四种权限:
为了简化类名的书写,使用一个关键字,import.
import 导入的是包中的类。
建议,不要写通配符“*”,需要用到包中的哪个类,就导入哪个类。
一个程序文件中只有一个package,但可以有多个import。