------- android培训、java培训、期待与您交流! ----------
本节考点:
一、throws和throw的区别:
1. throws用于标识函数暴露出的异常类,并且可以抛出多个,用逗号分隔。
2. throw用于抛出异常对象。
3. thorws用在函数上,后面跟异常类名。
4. throw用在函数内,后面跟异常对象。
2. throw用于抛出异常对象。
3. thorws用在函数上,后面跟异常类名。
4. throw用在函数内,后面跟异常对象。
二、try、catch、finally分别在什么情况下使用?
* (1)try语句:
* 某段代码中可能抛出异常,将其放入try语句,用来检测异常。
* 一旦发生异常就会跳转到catch,否则不会执行catch
* (2)catch语句:
* 除非try语句中的代码发生异常,否则这里的代码不会执行,用来接收并处理
* try语句中发生的异常,参数中的异常类型必须是Throwable类的子类对象。
* (3)finally语句:
* finally所指定的代码一定会执行,它提供了统一的出口,用来存放
* 一定会执行的语句,比如关闭线程等。
* (1)try语句:
* 某段代码中可能抛出异常,将其放入try语句,用来检测异常。
* 一旦发生异常就会跳转到catch,否则不会执行catch
* (2)catch语句:
* 除非try语句中的代码发生异常,否则这里的代码不会执行,用来接收并处理
* try语句中发生的异常,参数中的异常类型必须是Throwable类的子类对象。
* (3)finally语句:
* finally所指定的代码一定会执行,它提供了统一的出口,用来存放
* 一定会执行的语句,比如关闭线程等。
注意:
finally代码块只有一种情况不会被执行,就是在之前执行了System.exit(0)
三、final,finally,finalize区别。
final是最终的意思。它可以用于修饰类,成员变量,成员方法。
它修饰的类不能被继承,它修饰的变量时常量,它修饰的方法不能被重写。
finally:是异常处理里面的关键字。
它其中的代码永远被执行。特殊情况:在执行它之前jvm退出。System.exit(0);
finalize:是Object类中的一个方法。
它是于垃圾回收器调用的方式。
四、假如catch中有return语句, finally里中的代码会执行吗?是在return前,还是在return后呢?
会,在return前执行finally里面的代码。
final是最终的意思。它可以用于修饰类,成员变量,成员方法。
它修饰的类不能被继承,它修饰的变量时常量,它修饰的方法不能被重写。
finally:是异常处理里面的关键字。
它其中的代码永远被执行。特殊情况:在执行它之前jvm退出。System.exit(0);
finalize:是Object类中的一个方法。
它是于垃圾回收器调用的方式。
四、假如catch中有return语句, finally里中的代码会执行吗?是在return前,还是在return后呢?
会,在return前执行finally里面的代码。
3-1 异常的概念
3-1-1 异常的体系
异常:是在运行时期发生的不正常情况。
在java中用类的形式对不正常情况进行了描述和封装对象。描述不正常的情况的类,就称为异常类。
1. 以前正常流程代码和问题处理代码相结合,现在将正常流程代码和问题处理代码分离,提高阅读性。
2. 其实异常就是java通过面向对象的思想将问题封装成了对象,用异常类对其进行描述。
3. 不同的问题用不同的类进行具体的描述。比如角标越界、空指针异常等等。
4. 问题很多,意味着描述的类也很多,将其共性进行向上抽取,形成了异常体系。
不正常情况分成了两大类:
Throwable:无论是error,还是异常、问题,问题发生就应该可以抛出,让调用者知道并处理。
//该体系的特点就在于Throwable及其所有的子类都具有可抛性。
可抛性到底指的是什么呢?怎么体现可抛性呢?
其实是通过两个关键字来体现的。
throws throw,凡是可以被这两个关键字所操作的类和对象都具备可抛性。
2. 其实异常就是java通过面向对象的思想将问题封装成了对象,用异常类对其进行描述。
3. 不同的问题用不同的类进行具体的描述。比如角标越界、空指针异常等等。
4. 问题很多,意味着描述的类也很多,将其共性进行向上抽取,形成了异常体系。
不正常情况分成了两大类:
Throwable:无论是error,还是异常、问题,问题发生就应该可以抛出,让调用者知道并处理。
//该体系的特点就在于Throwable及其所有的子类都具有可抛性。
可抛性到底指的是什么呢?怎么体现可抛性呢?
其实是通过两个关键字来体现的。
throws throw,凡是可以被这两个关键字所操作的类和对象都具备可抛性。
|--1,一般不可处理的:Error
特点:是由jvm抛出的严重性问题。
这种问题发生,一般不针对性处理,直接修改程序。
|--2,可以处理的:Exception
该体系的特点:
子类的后缀名都是用其父类名作为后缀,阅读性很强。
特点:是由jvm抛出的严重性问题。
这种问题发生,一般不针对性处理,直接修改程序。
|--2,可以处理的:Exception
该体系的特点:
子类的后缀名都是用其父类名作为后缀,阅读性很强。
Throwable中的方法:
1. getMessage():获取异常信息,返回字符串。
2. toString():获取异常类名和异常信息,返回字符串。
3. printStackTrace():获取异常类名和异常信息,以及异常出现在程序中的位置,返回值void。
4. printStackTrace(PrintStream s):通常用该方法将异常内容保存在日志文件中,以便查阅。
2. toString():获取异常类名和异常信息,返回字符串。
3. printStackTrace():获取异常类名和异常信息,以及异常出现在程序中的位置,返回值void。
4. printStackTrace(PrintStream s):通常用该方法将异常内容保存在日志文件中,以便查阅。
<span style="font-family:Microsoft YaHei;font-size:14px;">class Chufa
{
public int Shabi(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException
{
int[] arr = new int[a];
System.out.println(arr[3]);
return a/b;
}
}
class ExceptionDemo
{
public static void main(String[] args)
{
Chufa c = new Chufa();
try
{
int result = c.Shabi(4,0);
System.out.println("结果:"+result);
}
catch (ArithmeticException a)
{
System.out.println(a.toString());
System.out.println("除数为零");
}
catch (ArrayIndexOutOfBoundsException a)
{
System.out.println(a.toString());
System.out.println("角标越界异常");
}
System.out.println("game over");
}
}</span>
3-1-2 自定义异常
可以自定义出的问题称为自定义异常。
对于角标为负数的情况,准备用负数角标异常来表示,负数角标这种异常在java中并没有定义过。
那就按照java异常的创建思想,面向对象,将负数角标进行自定义描述,并封装成对象。
那就按照java异常的创建思想,面向对象,将负数角标进行自定义描述,并封装成对象。
这种自定义的问题描述称为自定义异常。
注意:
如果让一个类成为异常类,必须要继承异常体系,因为只有成为异常体系的子类才有资格具备可抛性,才可以被两个关键字所操作,throws、throw。
自定义类继承Exception或者其子类,通过构造函数定义异常信息。
示例:
Class DemoException extends Exception
{
DemoException(String message)
{
super(message);
}
}
通过throw将自定义异常抛出。
Class DemoException extends Exception
{
DemoException(String message)
{
super(message);
}
}
通过throw将自定义异常抛出。
throws和throw的区别:
1. throws用于标识函数暴露出的异常类,并且可以抛出多个,用逗号分隔。
2. throw用于抛出异常对象。
3. thorws用在函数上,后面跟异常类名。
4. throw用在函数内,后面跟异常对象。
2. throw用于抛出异常对象。
3. thorws用在函数上,后面跟异常类名。
4. throw用在函数内,后面跟异常对象。
定义功能方法时,需要把出现的问题暴露出来让调用者去处理,那么就通过throws在函数上标识。
在功能方法内部出现某种情况,程序不能继续运行,需要进行跳转时,就用throw把异常对象抛出。
在功能方法内部出现某种情况,程序不能继续运行,需要进行跳转时,就用throw把异常对象抛出。
示例:
<span style="font-family:Microsoft YaHei;font-size:14px;">class myException extends Exception
{
myException(String message)
{
super(message);
}
}
class Chufa
{
public int Chu(int a,int b) throws myException
{
if (b < 0)
{
throw new myException("除数为负数");
}
if (b == 0)
{
throw new myException("除数为0");
}
return a/b;
}
}
class MyExceptionDemo
{
public static void main(String[] args)
{
Chufa a = new Chufa();
try
{
int result = a.Chu(4,0);
System.out.println("结果为:"+result);
}
catch (myException m)
{
System.out.println(m.toString());
System.out.println("异常信息为:"+m.getMessage());
}
System.out.println("game over");
}
}</span>
异常的分类:
1,编译时被检测异常:只要是Exception和其子类都是,除了特殊子类RuntimeException体系。
这种问题一旦出现,希望在编译时就进行检测,让这种问题有对应的处理方式。
这样的问题都可以针对性的处理。
1,编译时被检测异常:只要是Exception和其子类都是,除了特殊子类RuntimeException体系。
这种问题一旦出现,希望在编译时就进行检测,让这种问题有对应的处理方式。
这样的问题都可以针对性的处理。
2,编译时不检测异常(运行时异常):就是Exception中的RuntimeException和其子类。
这种问题的发生,无法让功能继续,运算无法运行,更多是因为调用的原因导致的或者引发了内部状态的改变导致的。
那么这种问题一般不处理,直接编译通过,在运行时,让调用者调用时的程序强制停止,让调用者对代码进行调整。
所以自定义异常时,要么继承Exception,要么继承RuntimeException。
这种问题的发生,无法让功能继续,运算无法运行,更多是因为调用的原因导致的或者引发了内部状态的改变导致的。
那么这种问题一般不处理,直接编译通过,在运行时,让调用者调用时的程序强制停止,让调用者对代码进行调整。
所以自定义异常时,要么继承Exception,要么继承RuntimeException。
异常处理的捕捉形式:
可以对异常进行针对性处理的方式。
具体格式是:
try{
//需要被检测异常的代码。
}
catch(异常类 变量) //该变量用于接收发生的异常对象
{
//处理异常的代码。
}
finally{
//一定会执行的代码;
}
可以对异常进行针对性处理的方式。
具体格式是:
try{
//需要被检测异常的代码。
}
catch(异常类 变量) //该变量用于接收发生的异常对象
{
//处理异常的代码。
}
finally{
//一定会执行的代码;
}
注意:
finally代码块只有一种情况不会被执行,就是在之前执行了System.exit(0)。
处理过程:
try中检测到异常会将异常对象传递给catch,catch捕获到异常进行处理。
finally里通常用来关闭资源。比如:数据库资源,IO资源等。
需要注意:try是一个独立的代码块,在其中定义的变量只在该变量块中有效。
如果在try以外继续使用,需要在try外建立引用,在try中对其进行初始化。IO,Socket就会遇到。
try中检测到异常会将异常对象传递给catch,catch捕获到异常进行处理。
finally里通常用来关闭资源。比如:数据库资源,IO资源等。
需要注意:try是一个独立的代码块,在其中定义的变量只在该变量块中有效。
如果在try以外继续使用,需要在try外建立引用,在try中对其进行初始化。IO,Socket就会遇到。
异常处理的原则:
1,函数内容如果抛出需要检测的异常,那么函数上必须要声明。
否则,必须在函数内用try/catch捕捉,否则编译失败。
否则,必须在函数内用try/catch捕捉,否则编译失败。
2,如果调用到了声明异常的函数,那么try/catch,要么throws,否则编译失败。
3,什么时候catch,什么时候throws呢?
功能内容可以解决,用catch。
解决不了,用throws告诉调用者,由调用者解决。
功能内容可以解决,用catch。
解决不了,用throws告诉调用者,由调用者解决。
4,一个功能如果抛出了多个异常,那么调用时,必须有对应多个catch进行针对性处理。
内部有几个需要检测的异常,就抛几个异常,抛出几个,就catch几个。
内部有几个需要检测的异常,就抛几个异常,抛出几个,就catch几个。
示例:
<span style="font-family:Microsoft YaHei;font-size:14px;">class Chufa
{
public int div(int a,int b) throws FushuException
{
if(b < 0)
throw new FushuException("除数为负数");
return a/b;
}
}
class FushuException extends Exception
{
FushuException(String message)
{
super(message);
}
}
class FinallyDemo
{
public static void main(String[] args)
{
Chufa c = new Chufa();
try
{
int result = c.div(4,-1);
System.out.println("结果:"+result);
}
catch (FushuException f)
{
System.out.println(f.toString());
}
finally
{
System.out.println("game over");
}
}
}</span>
try catch finally 代码块组合特点:
1,try catch finally
2,try catch(多个)当没有资源需要释放时,可以不用定义finally。
3,try finally 异常无法直接catch处理,但是资源必须关闭。
1,try catch finally
2,try catch(多个)当没有资源需要释放时,可以不用定义finally。
3,try finally 异常无法直接catch处理,但是资源必须关闭。
示例:
void show() throws Exception{
try{
//开启资源
throw new Exception();
}finally{
//关闭资源
}
}
try{
//开启资源
throw new Exception();
}finally{
//关闭资源
}
}
<span style="font-family:Microsoft YaHei;font-size:14px;">class BlueScreenException extends Exception
{
BlueScreenException(String message)
{
super(message);
}
}
class SmokeException extends Exception
{
SmokeException(String message)
{
super(message);
}
}
class Computer
{
private int state = 2;
public void run() throws BlueScreenException,SmokeException
{
if(state == 2)
throw new BlueScreenException("电脑蓝屏");
if(state == 3)
throw new SmokeException("电脑冒烟");
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();
}
catch (BlueScreenException b)
{
comp.reset();
}
catch (SmokeException s)
{
comp.reset();
}
System.out.println("讲课");
}
}
class ExerciseException
{
public static void main(String[] args)
{
Teacher t = new Teacher("毕老师");
t.prelect();
}
}</span>
异常的注意事项:
1,RuntimeException以及其子类如果在函数中被throw抛出,可以不用在函数上声明。
1,RuntimeException以及其子类如果在函数中被throw抛出,可以不用在函数上声明。
2,子类在覆盖父类方法时,父类的方法如果抛出了异常,那么子类的方法只能抛出父类的异常或者该异常的子类。
3,如果父类抛出多个异常,那么子类只能抛出父类异常的子集。
简单说:子类覆盖父类只能抛出父类的异常或者子类的子集。
3,如果父类抛出多个异常,那么子类只能抛出父类异常的子集。
简单说:子类覆盖父类只能抛出父类的异常或者子类的子集。
注意:
如果父类的方法没有抛出异常,那么子类覆盖时绝对不能抛,就只能try。
3-2 Object类
Object :所有类的根类。
Object是不断抽取而来,具备着所有对象都具备的共性内容。
Object是不断抽取而来,具备着所有对象都具备的共性内容。
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Person{
private int age ;
Person( int age){
this.age = age;
}
}
class Demo{
}
class ObjectDemo{
public static void main(String[] args){
Person p1 = new Person(20);
Person p2 = new Person(20);
Person p3 = p1;
Demo d = new Demo();
System. out.println(p1 == p2);//false
System. out.println(p1.equals(p2));//false
System. out.println(p1.equals(p3));//true
System. out.println(p1.equals(d));//false
}
}</span></span>
Object类的toString方法默认返回的内容是“对象所属的类名+@+对象的哈希值(十六进制)”
下面例子中两句输出语句结果相同
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Person{
private int age ;
Person( int age){
this.age = age;
}
public int hashCode(){
return age ;
}
}
class ObjectDemo{
public static void main(String[] args){
Person p1 = new Person(20);
System. out.println(p1);
System. out.println(p1.getClass().getName() + "$" + Integer.toHexString(p1.hashCode()));
}
}</span></span>
3-3 包
3-3-1 包(package)
1、对类文件进行分类管理。
2、给类提供多层命名空间。
3、写在程序文件的第一行。
4、类名的全称的是 包名.类名。
5、包也是一种封装形式。
2、给类提供多层命名空间。
3、写在程序文件的第一行。
4、类名的全称的是 包名.类名。
5、包也是一种封装形式。
示例:
<span style="font-family:Microsoft YaHei;font-size:14px;">package package1;
/*
使用包来保存编译之后的class文件,编译时使用命令
javac -d . TestPackage.java 即可保存在首句已定义的文件名中,并新建文件夹
其中的 . 可以替换为“c:\workspace”之类的文件夹名称
如果两个文件将会编译在同一个包,则不存在相互访问的问题,直接编译其中一个就行了
*/
public class TestPackage
{
public static void main(String[] args)
{
package2.Demo a = new package2.Demo();
a.show();
System.out.println("shabi");
}
}
</span>
包与包之间的类进行访问,被访问的包中的类必须是public的,被访问的包中的类的方法也必须是public的。
被访问的包中的类权限必须是public的。
类中的成员权限:public或者protected
protected是为其他包中的子类提供的一种权限。
类中的成员权限:public或者protected
protected是为其他包中的子类提供的一种权限。
3-3-2 Jar包
Java的压缩包。
方便项目的携带。
方便于使用,只要在classpath设置jar路径即可。
数据库驱动,SSH框架等都是以jar包体现的。
方便项目的携带。
方便于使用,只要在classpath设置jar路径即可。
数据库驱动,SSH框架等都是以jar包体现的。
Jar包的操作
通过jar.exe工具对jar的操作。
创建jar包
jar -cvf mypack.jar packa packb
查看jar包
jar -tvf mypack.jar [>定向文件]
解压缩
jar -xvf mypack.jar
自定义jar包的清单文件
jar –cvfm mypack.jar mf.txt packa packb
创建jar包
jar -cvf mypack.jar packa packb
查看jar包
jar -tvf mypack.jar [>定向文件]
解压缩
jar -xvf mypack.jar
自定义jar包的清单文件
jar –cvfm mypack.jar mf.txt packa packb