异常与包
一、异常
1.1、异常体系
异常概述：在现实生活中，常常会遇到很多的问题；类似的，在java中也会出现种种的不正常情况，将这些不正常情况封装成为对象，就叫做异常。简单说：异常就是问题在java中的体现。
就像人生病了，病可以分为严重性疾病，例如：癌症；也可以分为非严重性疾病，例如：感冒，上火。类似的，在java中的异常体系(Throwable)可以分为严重性的异常(Error)和非严重性的异常(Exception)。无论Error还是Exception都具有一些共性，比如：不正常原因，引发原因；那么根据共性抽取原则，java就把这些共性抽取到父类Throwable中。
Throwabla的两个子类：1、Error：描述严重性问题，比如类不存在、内存溢出等等；
2、Exception：描述非严重性问题，可以通过try/catch/finally语句处理。下面主要就是要学习Exception异常。
由Throwable类提供的一些重要方法：
(1)、getMessage():获取异常信息，返回字符串；
(2)、toString():获取异常类名和异常信息，返回字符串；
(3)、printStackTrace()获取异常类名、异常信息和异常出现的位置。返回值void；
(4)、printStackTrace(PrintStream s)将异常内容保存在日志文件中，以便查阅。
异常的处理：异常可以通过try/catch/finally语句进行处理，格式为：
try{需要被检查的代码;}catch(异常类型 变量){处理异常的代码;}finally{…}
注意：try中检测到异常会将异常对象传递给catch，catch捕获到异常进行处理。
finally里通常用来关闭资源。比如：数据库资源，IO资源等。try是一个独立的代码块，在其中定义的变量只在该变量块中有效。如果在try以外继续使用，需要在try建立引用。在try对其进行初始化。IO，Socket就会遇到。finally代码块一般都会执行到，除非前面执行了System.exit(0)。
throws与throw的区别：定义方法时，需要把出现的问题暴露给调用者，那么用throws在函数上声明，调用者必须处理，否则编译通不过。当方法内部出现了某种情况，程序不能继续运行，需要跳转，那么用throw把异常对象抛出。简单说：throws用于暴露异常；throw用于抛出异常。
对异常处理的一些建议：
(1)、声明多个异常时，建议声明更为具体的异常，这样异常处理可以更加具体；
(2)、声明了几个异常，就对应几个catch块。如果多个catch块中的异常出现继承关系时，父类异常catch块放在最下面。
(3)、进行catch处理时，catch中一定要定义具体处理方式，不要简单定义一句e.printStackTrace(),也不要简单书写一条输出语句。
下面代码演示异常：
package itheima.day09;
//演示多异常的处理
public class ExceptionDemo2 {
public static void main(String[] args) {
Demo1 d = new Demo1();
// 异常的处理
try{
int x = d.div(1, 1);
System.out.println("x = "+x);
// 算术异常
}catch(ArithmeticException e1){
System.out.println(e1.toString());
System.out.println("被零除了");
// 数组角标越界异常
}catch(ArrayIndexOutOfBoundsException e2){
System.out.println(e2.toString());
System.out.println("数组角标越界了");
}
}
}
class Demo1{
// 有异常的方法，其实RuntimeException子类可以不声明
int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException
{
int[] arr = new int[a];
System.out.println(arr[4]);
return a/b;
}
}1.2、自定义异常
项目中会出现特有的问题，而这些问题并未被java封装成异常对象；那么这些特有的问题可以按照java对问题封装的思想进行自定义的异常封装；这就是自定义异常。
自定义异常时，自定义异常类必须继承Exception类或其子类，如：RuntimeException。因为只有异常体系中才具有处理问题的特性。
运行时异常：Exception类中有一个特殊的子类RuntimeException:运行时异常。如果在函数内抛出了运行时异常，函数上不用声明，即使声明了，调用者也不用进行处理，编译一样能通过。之所以不用声明也不同处理编译一样通过，发生了RuntimeException程序再运行毫无意义，希望程序停止，让程序员修改；比如：除数是0,时根本无法运行，希望程序停止。
编译时异常：发生编译时异常时，必须处理，否则，编译通不过。Exception体系中除了RuntimeException及其子类都是编译时异常。
下面代码演示自定义异常与RuntimeException：
package itheima.day09;
/*
需求：有一个圆形和长方形，都可以获取面积。
对应面积如果出现非法的数值，视为获取面积出现了问题，
问题通过异常来表示。
*/
//传入了非法值，程序运行下去毫无意义，希望程序停止，继承RuntimeException的子类ArithmeticException
class IllegalValueEXception extends ArithmeticException
{
// 程序出现负数的面积时，处理不了，必须修改代码
IllegalValueEXception(String message){
super(message);
}
}
//图形的接口
interface Shape{
void getArea();
}
//长方形的类
class Rec implements Shape
{
private double length,width;
Rec(double length,double width){
if(length<=0 || width <=0)
// 当出现非法值时，抛出异常
throw new IllegalValueEXception("程序出现非法值");
this.length = length;
this.width = width;
}
public void getArea(){
System.out.println(length*width);
}
}
//圆形
class Circle implements Shape
{
private double radius;
public static final double PI = 3.14;
Circle(double radius){
if(radius <=0)
// 当出现非法值时，抛出异常
throw new IllegalValueEXception("程序出现非法值");
this.radius = radius;
}
public void getArea(){
System.out.println(radius*PI);
}
}
public class ExceptionTest2 {
public static void main(String[] args) {
// RuntimeException子类异常本来可以不处理，其实除了修改代码，别无选择，这里的处理只是提醒
try {
Rec r = new Rec(-7,9);
r.getArea();
Circle c = new Circle(3);
c.getArea();
} catch (IllegalValueEXception e) {
System.out.println(e.toString());
System.out.println("必须修改代码");
}
System.out.println("over");
}
}异常在子父类覆盖关系中的体现：
(1)、如果父类方法抛出异常，子类的覆盖方法只能抛出父类异常或者该异常的子类；
(2)、如果父类方法抛出多个异常，那么子类覆盖方法只能抛出父类异常的子集；
(3)、如果父类的方法没有抛出异常，子类该方法中的异常只能try、catch处理。
之所以异常在子父类覆盖关系中有上面三方面的限制，那是因为多态，子类也是父类的一种，比如：狗既可以称为狗，也可以称为动物。假设有异常发生，在处理多态的方法时，有可能父类的方法没有没覆盖，这时，很简单：不存在异常的覆盖问题。但当父类的方法被子类覆盖后，要是子类方法抛出的异常大于父类被覆盖的方法所抛出的异常，那么显然有些异常处理不到！这不符合Java语言的安全性，所以：子类在覆盖父类的方法时，所抛出的异常不能大于父类中被覆盖方法的异常。
简单说：异常在子父类覆盖关系中有限制，就是因为多态！
下面代码演示:
package itheima.day09;
/*演示异常子父类中的覆盖关系*/
public class FuGaiException {
public static void main(String[] args) {
Test1 t = new Test1();
t.function(new Zi());
}
}
/*
Exception
|__AException
|__BException
|__CException
*/
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 Test1{
/*当Fu f = new Zi()时，多态，
那么f.show()调用的是子类的show()方法，
假如子类show()方法声明的异常比父类show()方法声明的多，那么在这里显然就有些不能处理到
所以为了程序的扩展性，子类覆盖方法的异常必须是父类方法异常的子集。
*/
void function(Fu f){
try{
f.show();
}catch(AException e){
e.getMessage();
}
}
}二、包
2.1、包(package)
包的概述：在计算机中，两个同名文件不能同时存在于同一文件夹下；当要存储两个同名文件时，可以把它们分别存储在不同的文件夹下。在Java中也一样，当有两个同名文件时，可以用不同的包把它们分别存储。包可以对文件进行分类管理，给类提供多层的命名空间。包类似于文件夹。
注意：包必须写在程序的第一行；包名一般小写，例如：package itheima.day09;；当加入了包后，类名的全称为：包名.类名；包也是一种封装形式。
包的导入：导入包用关键字import，导入包可以简化程序的书写；包的导入并非导入包中的包，而是导入包中的类；一个程序文件中只有一个package，但可以有多个import，也就是说一个程序文件可以导入多个不同的包；“*”是包中类的通配符，意为导入所有的包，但一般需要包中哪个类就导入哪个类，例如：importmypack.Demo;，而不是import mypack.*;，提高程序运行的效率。
权限：在java中，有四种权限修饰符：public(公有的)，protected(保护的)，default(默认的，不写)，private(私有的)。被访问的包中的类权限必须是public的。具体权限如下图：
classpath：是给java虚拟机(JVM)提供的一个环境变量，可以指定类或者包所在的路径。
path和classpath的区别：
path环境变量里面记录的是可执行性文件，如.exe文件，对可执行文件先在当前路径去找，如果没找到就去path环境变量中配置的路径去找，简单说：path环境变量是配置给windows用的。
classpath环境变量里记录的是java类文件的所在的目录，当没配置classpath路径，直接在当前路径寻找；当配置了classpath路径，结尾处不加分号，会在配置的路径去寻找，若找不到直接报错，结尾处加分号，先在配置路径寻找，找不到再到当前路径寻找，再找不到就报错。
2.2、jar包
在windows中，可以把很多的文件压缩成zip包；类似的，在java中，可以把很多的.class文件压缩成jar包。jar包可以方便与于项目的携带。
在项目中，当需要用到第三方一共的jar包时，那么需要先将jar包导入。
在eclipse中导入jar包：
1、点击工程的根目录，点击Properties进入Properties；
2、在Properties页面中选中Java Build Path，选中Libraries标签，点击Add External JARs；
3、找到需要添加的jar包，确定即可。