java基础—— 第六章：java基础（异常机制、包）

本章概述：

第一部分：异常机制

异常描述

异常的特点

异常的处理

自定义异常

第二部分：包机制

包的作用

包的特点

包的书写格式

第三部分：jar包

jar工具

打jar包

 

 

 

 

 

第一部分：异常机制

1、异常描述：

1.1、异常是指程序运行时出现不正常的情况，是对问题的描述，将问题进行对象的封装

1.2、异常的由来

异常问题也是现实生活中的一个具体的事物，也可以通过Java类的形式进行描述，并封装成对象，是Java对不正常情况进行描述后的对象体现

2、异常的特点：

2.1、异常体系中所有类和建立的对象都具备可抛性，只有异常体系具备这一特点

2.2、问题的划分

在异常类的总接口（throwable）下，共分成两种异常子类：

（1）严重的异常（error）：一般不编写针对性的代码进行处理

（2）非严重的异常（Exception）：可以使用针对性的处理方式进行处理

3、对异常的处理

3.1、java专门定义了异常的处理语句：

try-catch-finally处理语句

格式：

try{

会出现异常的代码块

}catch(异常参数类型 参数名)

{

处理异常的代码块

}

finally{

一定要执行的语句（可用于回收资源）

执行finally前如果执行了系统退出语句System.exit(0)时，finally不会被执行

}

结合格式：

try{}catch(){}

try{}catch(){}finally{}

try{}finally{}

try{}catch(){}catch(){}···

···

代码演示：

 

//需求：异常演示

class ExceptionDemo
{
	Public static void main(String[] args) throws RuntimeException
	{
		int a =4,b = 0;
		
		//用try语句检查异常
		try
		{
			b = a/b;
		}
		//如果try语句中发生异常，catch语句可以捕获异常并提供异常处理块
		catch (Exception e)
		{
			//这是异常体系的共性方法，可以将异常信息输出
			e.printStackTrace();
		}
		//不管有没有发生异常，finally中的语句都会执行
		finally
		{
			System.out.println("finally");
		}
	}
}

 

 

 

3.2、throw和throws

3.2.1用法：

throws：在功能上通过throws关键字声明该功能有可能会出现异常

throw：通过关键字抛出一个异常对象

3.2.2两者的区别：

throw定义在函数内，用于抛出异常对象

throws定义在函数上，声明抛出异常，多个用逗号隔开

3.3、异常处理的两种方式：

（1）通过throws在函数或类上声明抛出异常

（2）通过try{}catch(){}语句进行具体处理

3.4、 对多异常的处理

（1）声明捕获的异常时，建议声明更具体的异常，这样可以处理得更具体

（2）对方声明了多个异常，有几个异常就有几个catch块（一个try对应多个catch），如果多个catch块中捕获的异常类之间有继承关系，应将捕获父类异常的catch语句放在捕获子类异常语句的后面，否则捕获子类异常语句永远也执行不到，编译会出错

3.5、处理原则：

（1）进行catch时，catch一定要定义具体处理方法，当捕获到的异常本功能处理不了时，可以在catch内继续抛出与下一级执行体功能相关的异常不要简单定义一条打印语句，也不要捕获异常后不处理

（2）处理本层问题后，反馈的问题应该是对下一层有实际意义的问题

3.6、 继承类处理异常的注意事项：

（1）如果子类继承的父类抛出异常，那么子类只能抛出父类抛出的异常或父类抛出的异常的子类异常

（2）父类抛出多个异常，子类只能抛出父类的异常的子集，或者不抛出异常

（3）如果父类没有抛出异常，则子类也不能抛出异常，子类可能发生的异常只能在类的内部处理

代码演示处理异常的子父类的顺序、处理异常的两种方式等：

 

//需求：异常演示

class ExceptionDemo
{
	Public static void main(String[] args) throws RuntimeException//在方法上声明抛出异常
	{

		//定义一个数组
		int[] arr = {0,33,8};
		
		//处理异常
		try
		{
			//操作了不存在的数组角标，抛出异常
			arr[3] = 23;
		}
		//定义了两个catch语句，子类异常放在父类异常后面，可以先针对性处理子类异常，否则子类异常永远也执行不到，系统会报异常
		catch (ArrayIndexOutOfBoundsException ex)
		{
			ex.printStackTrace();
		}
		catch(RuntimeException exc)
		{
			System.out.println(exc.toString());
		}
		finally
		{
			//在finally内部通过new创建了一个异常，通过throw方法将异常抛出
			throw new RuntimeException("FinallyException");		
		}
	}
}

 

 

4、可处理异常的两种表现形式：

4.1 运行时异常（RuntimeException）：

RuntimeException是Exception的一个子类，如果函数内抛出该异常或该类异常的子类，函数上不用声明，编译时不检测该异常体系，建议不处理该类异常，让程序停下，以检测代码的错误

4.2 编译时异常：

除RuntimeException外的Exception类异常，编译时会检测该类异常，如果发现有没有处理的该类异常则编译不能通过，所以这类异常必须要处理

5、自定义异常

5.1 在做项目开发时，会出现项目中的特有问题，可以将特有问题封装成自定义异常类

5.2 定义异常的方式：

继承异常体系（？extends throwable），使该类具备可抛性，让该类具有异常的共性方法

5.3 定义异常信息时，可以使用父类已经定义好的功能，将异常信息传递给父类

6、异常类的共性方法

getMassage() 获取异常信息

toString() 异常的字符串表示形式

printStackTrace(PrintStream) 将异常信息输出到指定输出流

···

7、定义异常的好处

7.1将问题进行封装

7.2将正常流程代码和问题代码分离开，方便阅读

 8、编译时，异常问题在最后报告，当编译时出现异常报告，表明语法异常已经基本解决了

代码演示：

 

//需求：异常演示

class ExceptionDemo
{
	public static void main(String[] args) throws Exception//声明抛出自定义异常的父类异常
	{

		//定义一个空数组
		int[] arr = null;
		
		//处理异常
		try
		{
			//操作了不存在的数组对象，抛出异常
			System.out.println(arr[2]);
		}
		//定义了catch语句，对捕获的异常进行处理
		catch(RuntimeException e)
		{
			//打印异常的字符串表示形式
			System.out.println(e.toString());
			//打印异常信息
			System.out.println(e.getMessage());
			//输出异常信息到流（默认控制台）
			e.printStackTrace();

			//抛出自定义异常
			throw new MyException("抛出MyException异常");
		}
	}
}
class MyException extends Exception
{
	//初始化时直接将参数传给父类
	MyException(String str)
	{
		super(str);
	}
	//不定义特有方法仅演示异常体系的共性方法
}

 

 

 

9、异常体系的常见类：

9.1、throwable：异常的根接口

Error：严重异常

Exception：可处理异常

9.1.2.1RuntimeException：运行时异常

（1） NullPointerException：空指针异常

（2） ClassCastException：类型转换异常

（3） EventException：监听事件异常（GUI中的异常）

（4） IllegalArgumentException：非法的参数异常

（5） IndexOutOfBoundsException：角标越界异常

（6） ArrayIndexOutOfBoundsException：数组角标越界异常

（7） StringIndexOutOfBoundsException：字符串索引越界异常

（8） SystemException：系统异常

9.1.2.1 InterruptedException：中断异常（多线程中的异常）

9.1.2.2 NoSuchMethodException：没有这个方法异常

9.1.2.3 IOException：IO异常

（1） FileNotFoundException：文件找不到异常

（2） InterruptedIOException：IO中断异常

（3） ObjectStreamException：对象流异常

（4） UnknownHostException：未知的主机异常（涉及到网络编程的异常）

（5） UnsupportedEncodingException：不支持的编码异常

（6） SocketException：网络端口异常

9.1.2.4 NoSuchFieldException：没有这个属性异常

 

 

 

 

 

第二部分：包机制

1、包的作用：

1.1、对类文件进行分类管理

1.2、给类提供多层命名空间

1.3、包也是一种封装形式，在包外访问包内成员有访问限制

2、包的书写格式：

2.1、写在程序文件的第一行，使用package 关键字定义

如：package 包名;

2.2、使用包机制后，类名的全称是：包名.类名

3、包的特点：

3.1、包与包之间进行访问，被访问的类以及类中的成员需要被public修饰

3.2、不同包中的子类还可以访问父类被protected权限修饰的成员

3.3、导入包中的类：

（1） 为了简化类名的书写，使用关键字import将包中的类导入以供调用

（2）使用通配符“*”，在包后面加“.*”可以将该包中的所有类导入，但不对该包中子包的类进行导入。

（3）当导入不同包名中的类存在同名类时，不能直接导入，类必须写全名

3.4、建议定义包名时不要重复，可以使用URL的段来定义，因为URL是唯一的，通常定义多级包都将域名反向作为各级包名来定义。

 

4、class文件带包编译：

4.1、编译时，带包编译成class文件在控制台的书写格式为：

javac -d（指定文件路径） demo.java

编译时就会自动生成带包的class文件。

运行时，要设置classpath到包的路径下

 

如图，编写带包的Java文件：

带包编译（这里指定文件位置我用“.”表示当前目录）

该目录下生成了名称为“packa”的包

5、访问权限问题

5.1、类的访问权限：public、default（缺省的）

每个java文件只能定义一个被public修饰的类

 

5.2、成员的访问权限：public、 protected、 default、 private

public：公共的；该修饰符修饰的类所有成员都可以访问

protected：受保护的；类被该修饰符修饰的成员可以被不同包中的子类访问

default：缺省的，不写访问修饰符会默认是该权限；相同包中的成员才可以访问该修饰符修饰的类

private：私有的；被该修饰符修饰的成员只有本类的成员才可以访问

5.3、包与包之间可以访问的权限只有两种：public、protected

 

 

 

 

第三部分：jar包

1、jar包就是Java的压缩包，可以将多个class包文件打成jar压缩包的形式

2、打jar包的作用：

2.1方便项目的携带

2.2方便于使用，只要在classpath的路径设置为包括jar的路径即可使用jar包里的class文件

2.3 数据库驱动，SSH框架等都是以jar包体现的

3、jar工具（jar.exe）

3.1、使用jar工具打jar包：

调用格式：

在控制台输入：jar -cvfm jar名 包名 包名···

生成jar包。

如图，将原有包用jar工具打成jar包

生成的jar包，如图

 

 

本章总结：

（1）异常也是一种事物，java中把异常也封装成了对象，方便描述程序中出现的各种问题

（2）异常分可处理异常和不可处理异常，可处理异常又分编译时异常和运行时异常

（3）运行时异常是可以不作处理的异常，建议不要处理，让程序停下来以检查发生异常的原因

（4）异常的处理有两种方式，声明抛出异常或者捕获并处理异常，对于多个异常要定义多个处理语句具体处理，不要简单打印异常信息或不处理

（5）当项目中可能发生特定异常时可以自定义异常类，方法是继承异常体系使该类具备可抛性。

（6）java中定义了包机制，以便类的分别存放和分别封装类的访问权限，包名最好不要定义重复，可以参照URL的字段进行定义。

（7）jar包可以封装java的包和类文件，以便项目文件的存储、携带和传送，很多库和框架都是以jar的形式体现的，学会对jar包打包。