码迷,mamicode.com
首页 > 编程语言 > 详细

java基础异常(毕向东老师)

时间:2015-12-22 23:04:38      阅读:464      评论:0      收藏:0      [点我收藏+]

标签:

异常:不正常。在运行时期发生的一些不正常情况。就是异常。
异常的由来。程序运行是总会
class ExceptionDemo
{
public static void main(String[] args)
{
int[] arr=new int[2];
System.out.println(arr[2])
}
}


异常情况有多钟,都需要分别描述,意味着异常情况应该会有一个体系。
多一个异常具备共性不断地向上抽取,就形成了体系。
异常还有一个父类。通过查阅API,发现异常体系是这样的:
Throwable
|--Error严重的问题,一般是由jvm从底层抛出来的问题,通常不需要处理
直接修改程序就可以了。
|--Exception是可以定义针对性的处理方式对这种情况进行处理、
不正常情况分两种,一种是可以解决的Exception,一种是严重性的Error。
无论是error还是Exception ,他们的子类名字的后缀都是父类名。
int []arr=new int(1024*1024*700);//OutOfMemoryError;

虚拟机在内存中分配空间,(名称信息都具备)底层开辟空间失败,将异常抛给调用者。
发生问题之后不用再运算了。将发生的问题抛给调用者知道。抛给了虚拟机。
谁调用主函数交给谁。默认的处理方式:直接将问题(名称,信息,位置打包发给调用者。)

System.out.println(arr[2]);//new ArrayIndexOutOfException();
这个异常体系最大的特点在于该体系中的类和对象都具备可抛性。
可抛性的体现就是无论是类或者对象都可以被throws或者throw所操作
throws操作类。throw操作对象。
通常情况下:
class Demo
{
int div(int a,int b)throws Exception//多了一个标识
{

if(b<0){
throw new FuShuException("错误,不允许除数为负数");
throw new FuShuExceptin(b);
}
if(b==0)//要想手动抛出一个异常对象,必须的用throw关键字.
throw new ArithmeticException("完啦,被零除啦!")
return a/b;//new ArithmeticException("by zero")

}
}

class ExceptionDemo
{
public static void main(String[] args)throws Exception///这面包有可能坏了
//(一个标签。)
{
Demo d=new Demo();//创建对象。
try{
int x=d.div(4,0);
System.out.println("x="+x);
}
catch(Exception e)//引用型的变量。//该变量用于接收抛出的异常。

{
//Exception e=new ArithmeticException();
System.out.println("啊,异常了!");
//调用方法去。(他很张凯迪,但是他爹不张凯迪)

System.out.println("message"+e.getMessage());

System.out.println("toString"+e.toString());

e.printStackTrace();//打印名字,信息,位置。
}
//ArithmeticException:/by zero;调用div,他抛到了这里。
默认的处理方式:抛给jvm(就是名称,信息,位置打包发给调用者,都打印在控制台上;结束
程序)

System.out.println("over");

}
}


异常是可处理的:
处理方式:
1,声明抛出。告诉调用者功能会有问题,通过throws关键字将问题声明在功能上。
2,进行捕捉。可以使用针对性的捕捉代码块完成。
try{
//需要被检测的代码
}
catch(异常类 变量)
{
//异常处理代码
}
finally
{
//一定会被执行的代码
}

//程序会继续往下执行。

throws throw关键字有什么区别?
throws用在函数上,用于功能声明异常,后面跑出的是异常类,可以跑出多个,只要用逗号隔
开就可以。
throw 只能用在函数内,用于抛出异常对象,额外特点,一旦执行,就可以结束功能。

自定义异常:对于常见的不正常情况,java都有对应的描述。比如角标越界
或者空指针等。对于自定义的程序中出现的特有问题,java并没有给出相应的
描述。这是需要我们按照面向对象的思想对这个问题进行描述,像异常一样
将其封装成对象。
定义的方式;
1,定义的方式:定义一个类,对问题进行描述。
2,必须要让这个类继承异常类,具备可抛性。
class FuShuException extends Exception
{
private int num;
FuShuException()
{
super();
}
FuShuException(String message)
{
super(message);
}
FuShuException(int num)
{
this.num=num;
}
public int getNum()
{
return num;
}
}
异常的细节:
1,定义功能,功能内部因为传入参数问题,导致了功能会出现问题。
这时为了解决这个问题
通常我们都会将这个问题通过throws声明在函数上。
目的:为了调用者在使用这个功能的时候,能明确处理方式。也即是说throws跑出的目的是为

让调用者预先定义好的问题的处理方式。
2,如果一个功能抛出多个异常。
那么调用该功能时,需要有多个catch进行每个异常的针对性处理。
如果多个catch中有父类异常,一定要定义在最下面。否则编译失败。
3,特殊部分:
函数内throw抛出异常对象,函数上一定要用throws声明。否则编译失败。
调用到声明异常的函数,要进行声明throws声明抛出,或者trycatch捕捉,否则,编译失败。
注意:异常分两种。
1,编译时被编译器检测的异常。
通常都需要此案写针对性的代码进行处理。
2,编译时不被检测的异常。这种异常出现,编译时期是不在检查之列。这种异常称为运行时
异常。
也就是说函数内throw抛出运行时异常,不需要在函数上声明。即使声明了调用者也不用
一定给出预先处理方式,因为她不会导致编译失败。
为了对代码进行修正。
区分方式:Exception中一个特殊的子类:RuntimeException就是运行时异常。
RuntimeException,Exception和其子类都不需要编译时检测。
意味着:我们在自定义异常时,可以继承Exception,称为编译时被检测的异常。
也可以继承RunTimeException,称为运行时异常。

 

 

class Demo
{
int div(int a,int b)throws ArithmeticException(Exception1,Exception2,Exception3)
{
return a/b;
int div(int a,int b)throws Exception
{
if(b==0)
{
throw new Exception("异常");
}
int [] arr=new int[a];
if(b>=a)
throw new ArrayIndexOutOfBoundsException("角标越界了")
System.out.println(arr[b])
}
}
class Exception4
{
public static void main(String[] args)
{
Demo d=new Demo();
int num=d,div(4,1);
System.out.println("num="+num);
/*
try{
int x=d.div(4,0);
}
catch(Exception1 e)
{
}
catch(Exception2 e)
{
}
catch(Exception3 e)
{
}*/
}
}

}

//毕老用电脑上课。
//在上课过程中出现故障。比如电脑蓝屏,冒烟。
class LanPingException(string message)
{
LanPingException()
{
super();
}
MaoYanException(String)
}
class Computer

{
private int state=1;
public void run()
{
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 comp;
Teacher(String name)
{
this.name=name;
comp=new Computer();
}
public void prelect()
{
try{
comp.run();

System.out.println(name+"讲课");
}catch(LanPingException e)
{
//重启电脑
comp.reset();
prelect();

}catch(MaoYanException e)
{
test();
throw e;
throw new
}
}
public void test()
{
System.out.println("大家练习");
}
class Exception
{
public static void main(String[] args)
{
Teacher t=new Teacher("毕老师");
t.prelect();
}
}

//

try{}
catch(异常类)
{
异常处理;
}
finally{
一定会被处理的代码。
}
//catch里写return语句,finally还是会被执行。
void add(data)
{
//1连接数据库
//2存储数据。存储失败会发生异常。
//3关闭数据库连接。(不消耗数据库资源)
}
//把连接和处理放在try里,catch (数据库异常 e)
{
异常处理
}
finally{
// 数据库必须关闭。
//主要用于释放资源,无论是否发生异常,有些动作一定要被执行。
}

System.exit(0);//退出虚拟机,这时finally也不会执行。
在进行异常捕捉时,代码块的不同组合。
1,try catch finally
2,try catch//没有需要一定被执行的代码。通常是不需要关闭资源的动作。
3,try finally。处理异常只有catch能完成。//异常并没有被处理,但是却涉及到了资源的
调用,资源需要被关闭,所以就有了将异常进行对外声明,因为没有catch,但是资源是在功
能内部打开的,必须在功能内部关闭,就有了try和finally的组合。


//Exception 覆盖中的细节。
子类在覆盖父类时,如果父类中被覆盖的方法抛出了异常,那么子类覆盖的方法们只能抛出相
同的异常,或者该异常的子类。

如果父类的覆盖方法抛出了多个异常,子类在覆盖时,只能抛出这些异常的子集。
3,如果被覆盖的方法没有抛出异常,子类也不允许抛出异常,如果子类真的出现异常,只能
在子类方法内进行try处理,绝对不允许throws声明。万一处理不了呢?你可以选择抛出运行
时异常。
interface Inter
{
void show();

}
class InterImpl implements Inter
{
public void show()
{
try{
throw new Exception();
}
catch(Exception e)
{
throw new RuntimeException("xxx异常信息");
}
}
}

java基础异常(毕向东老师)

标签:

原文地址:http://www.cnblogs.com/kaidi1994/p/5068317.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!