Java语言入门（八）——异常处理机制

异常

1 异常是java提供的一种错误处理机制。
2 异常定义了程序中遇到的非致命的错误, 而不是编译时的语法错误，如程序要打开一个不存的文件、网络连接中断、操作数越界、装载一个不存在的类等。
3 此处讨论的一般是指运行期出现的错误（注意查看出现错误的名称和行号）
4 一个图 & 五个关键字
try、catch、finally、throw、throws

异常处理机制

1 抛出异常
Java是这样规定的： 当语义限制被违反时，将会抛出（throw）异常，即产生一个异常事件，生成一个异常对象，并把它提交给运行系统，再由运行系统寻找相应的代码来处理异常。一个异常对象可以由Java虚拟机来产生，也可以由运行的方法生成。异常对象中包含了异常事件类型、程序运行状态等必要信息。
2 捕获异常
异常抛出后，运行时系统从生成异常对象的代码开始，按方法的调用顺序进行查找，直到找到包含相应处理的方法代码，并把异常对象交给该方法为止，这个过程称为捕获（catch）异常。
3 异常处理机制就是： 当语义限制被违反时，将会抛出异常对象，并将引起程序流程从异常发生点转移到程序员指定的处理异常方法代码处进行异常处理。

class Test-8.1
{  public static void main(String[] args)
   {  System.out.println("begin");
       try //有可能出现异常的代码
       {  System.out.println(9/0);//出现异常
          //System.out.println(9/2);//无异常，不处理代码
       }
       catch(ArithmeticException e)
       {    //System.out.println(e);//输出异常
	  e.printStackTrace();//输出异常及异常发生行数
        }
        finally //无论是否有异常，均执行
        {  System.out.println("i am fianlly");  }
       System.out.println("end");
   }
}

class Test-8.2
{   public static void main(String[] args)
     {   System.out.println("begin");
          try
          {  System.out.println(9/(Integer.parseInt(args[0]))); }
	catch(ArithmeticException e)
	{   e.printStackTrace();   }
	catch(ArrayIndexOutOfBoundsException e)
	{    e.printStackTrace();   }
	catch(NumberFormatException e)
	{     e.printStackTrace();   }
	System.out.println("end");
     }
}//catch无法同时捕捉两个异常

class Test-8.3
{  public static void main(String[] args)
    {  System.out.println("begin");
     try
     {  System.out.println(9/(Integer.parseInt(args[0]))); }
	//可能出现的异常：
	//[ArrayIndexOutOfBoundsException]（不输入）
	//[NumberFormatException]（输入a）
	catch(Exception e) 
	{  e.printStackTrace();  }
	System.out.println("end");
      }
}

class Test-8.4
{  public static void main(String[] args)
    {  System.out.println("begin");
        try 
         {	System.out.println(9/(Integer.parseInt(args[0])));  }
        catch(ArrayIndexOutOfBoundsException e) 
          //用catch捕捉异常，一定要先小后大
	{   e.printStackTrace();  }
	catch(Exception e)
	{    e.printStackTrace();  }
	System.out.println("end");
      }
}

异常的分类

1 Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类(或其子类之一)的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。所有能够抛出、并且能够被控制的异常或错误都必须从Throwable类继承。
2 Error 是 Throwable 的子类，一般是指java虚拟机（JVM）出错或是机器本身硬件、操作系统等出错，这种错误不是编写的java程序所导致的，这就好比是天灾，不是人为引起的，也不是程序本身所能控制的，所以一般不去处理这种类型的错误。
3 Exception 类及其子类都是Throwable 类的子类。这些异常一般是因编写的程序而导致的，是可以人为控制的。这就好比是人祸，可以避免、防范和处理的。它指出了合理的应用程序想要捕获的条件，表示程序本身可以处理的异常。
4 RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。Java编译器不去检查它，也就是说，当程序中可能出现这类异常时，即使没有用try…catch语句捕获它，也没有用throws字句声明抛出它，还是会编译通过，但在运行时可能出现问题。比如前面除数为0的例子中，出现的ArithmeticException异常就是此类的一个异常子类。

一个图&五个关键字以及异常与继承

1 一个图 & 五个关键字
try、catch、finally、throw
2 try语句 ： 用来监视可能引起异常的语句，写程序时，应该将可能出现异常的语句代码放入此语句块中。
3 catch语句：异常发生时要执行的异常处理程序，它可以捕获到try{}语句块中抛出的异常对象，并可以按人为的要求进行异常信息的输出。
4 如果希望在异常发生时能确保有一段代码被执行，那么应该使用finally子句。
5 Java异常处理可以使用try…catch语句进行处理，也可以使用try…catch…fianlly进行处理。
6 throws：用在方法申明处（方法头），表示本方法不处理异常，有异常向上抛，交给被调用处处理。尽量要在异常发生处进行处理，而不是抛出
7 throw ：一般用在方法里，由用户手工抛出一个异常的实例化对象。用于指出异常的名称和类型。要对其进行 捕获/处理。程序会在throw语句处立即终止，转向try…catch寻找异常处理方法，不再执行throw后面的语句。

class A
{  public int div (int x,int y)
    {  int z=0;
       System.out.println("begin");
       z= x/y;  //程序是在这里出现异常
       System.out.println("end");
       return z;}
}
class Test-8.5
{  public static void main(String[] args)
    {  A a=new A();
       int x= 0; 
       x=a.div(10,5);
       System.out.println(x);}
}

class A
{  public int div (int x,int y) throws Exception
    {  int z=0;
       System.out.println("begin");
       z= x/y;  //程序是在这里出现异常
       System.out.println("end");
       return z;}
}
class Test-8.6
{  public static void main(String[] args)
    {  A a=new A();
       int x= 0; 
       try{ x=a.div(10,0); }
       catch (Execption e)  {  e.printStackTrace();  } }
}

class A
{  public int div (int x,int y) throws Exception
    {  int z=0;
       System.out.println("begin");
       z= x/y;  //程序是在这里出现异常
       System.out.println("end");
       return z;}
}
class Test-8.7
{  public static void main(String[] args) throws Exception 
    {  A a=new A();
       int x= 0; 
       x=a.div(10,5);
       System.out.println(x);}
}

class A
{  public int div (int x,int y)throws ArithmeticException
   {  int z=0;
      System.out.println("begin");
      z= x/y;  //程序是在这里出现异常
      System.out.println("end");
      return z; }
}
class B extends A
{  public int div (int x,int y)throws
ArithmeticException /* ,IllegalAccessException  */
   {  int z=0;
      System.out.println("begin");
         z= x/y;  //程序是在这里出现异常
    System.out.println("end");
    return z; }
}
class Test-8.8
{  public static void main(String[] args)throws Exception
   {  A a=new A();
      int x= 0;
      x=a.div(10,0);
     System.out.println(x);}
}
//异常与继承的关系。子类在改写父类方法时，不能抛出比父类更多和更新的异常

class A
{  public int div (int x,int y) throws ArithmeticException
    {  int z=0;
       System.out.println("begin");
       try { z= x/y; } 
       catch(Exception e){ e.printStackTrace(); }	
       finally {System.out.println("end");  }     
       return z; } 
}
class Test-8.9
{  public static void main(String[] args)
    {  A a=new A();
       int x= 0;
       x=a.div(10,0); 
       System.out.println(x);}  
} //处理了异常后尽管方法有throws也不会抛出异常给main

class Test-8.10
{
     public static void main(String[] args)
     {  
          try  {  throw new Exception("i am wrong");  }    
          catch(Exception e){   }
          finally { System.out.println("end"); }
      }
}

class A
{  public int div(int x, int y)throws Exception  
    {   int t=0;
        System.out.println("begin");
        try  { t=x/y; }
        catch (Exception e) {  throw e;  }
        finally{System.out.println("end");  } 		
         return t; }
}
class Test-8.11
{  public static void main(String[] args) 
    {  A a=new A();
        int m=0;
        try {  m=a.div(2,0); }
        catch (Exception e) {   System.out.println(e);}  }
}

//自定义异常
class MyException extends Exception
{  public MyException(String str)
    { super(str); }
}
class Test-8.12
{   public static void main(String[] args)throws Exception
    { 
      int x=5;
      if(x>3)
       throw new MyException("notice!!");
      }
}

小结：
1 避免过大的try语句块，不要把不会出现异常的代码放到try块里面，尽量保持一个try块对应一个或多个异常。
2 细化异常的类型，不要不管什么类型的异常都写成Excetpion。
3 catch语句块尽量保持一个块捕获一类异常，不要忽略捕获的异常，捕获到后要么处理，要么重新抛出新类型的异常。
4 不要把自己能处理的异常抛给别人。

断言assert

class Test-8.13
{
    public static void main(String[] args) 
    {
       int x=10;
       assert x==90:"it is wrong";
       System.out.println(x);
     }
}
//编译  javac Test-8.13.java
//运行     java –ea Test-8.13

包

1 定义：将多个类放在一起时，要保证类名不能重复。当声明的类很多时，类名就有可能冲突，这就需要一种机制来管理类名，这就是包。
2 包是Java提供的一种区别类名空间的机制，是类的组织方式，一个包对应一个文件夹，包中还可以有包，称为包等级，如同文件夹中可以有子文件夹。
3 同一个包中类名不能重复，不同包中可以有相同的类名。
4 系统包：又称类库或API包，所谓API。
5Java常用包
(1)java.lang包 (惟一自动引入每个Java程序的类库)
(2)java.util包 (低级的实用工具类,eg日期类,堆栈类)
(3)java.io包 (语言的输入输出类)
(4)java.net包 (访问网上资源,通信,网络协议)
(5)java.awt包 (图形用户界面)
(6)java.applet包 (小应用程序,只包含了一个Applet类)
6 创建包语句格式为：
package 自定义包名;
在一个Java文件里,只能有一个package,声明包语句必须添加在源程序的第一行。
7 Tips:
(1)＊号表示包中所有的类，但不包含子包
(2)一个包中的类要被外部访问，则此类一定要为public类型的
(3) Java.lang包是系统自动隐含导入的

//Test1.java
package huang.guo;//创建包
class A
{  public static void main(String[] args) 
    {  System.out.println("HELLO WORLD");  }
}
//打包编译  javac -d . Test1.java  (点的左右各有一个空格)
//运行java huang.guo.A

//Test2.java
package huang.guo;
class B
{  public static void main(String [] args)
   {  //C c=new C();
      huang.guo.quan.C c = new huang.guo.quan.C();
      c.say();  }
}
//或者
//Test2.java
package huang.guo;
import huang.guo.quan.*;//导入放在创建后
class B
{  public static void main(String [] args)
   {  C c=new C();
       c.say();  }
}

//Test3.java
package huang.guo.quan;
public class  C
{  public void say()
    {  System.out.println("i am c"); }
}
//同一包中的类可以相互调用
//或者
//Test3.java
package huang.guo.quan;
public class  C
{  public void say()
    {  System.out.println("i am c"); }
}
//打包编译  javac -d . Test3.java
                       javac -d . Test2.java
//运行java huang.guo.B

//jar命令的使用，即jar包的生成和导入（一定要把jar包写到classpath的路径里面去）
//jar -cvf my.jar guo        生成my. jar,可删除guo文件夹
 //set classpath=%classpath%;文件地址\my.jar

访问权限

1 Public:所有的都可以访问
2 Private:本类中才能访问
3 Protected:同一个包中,不同包中的子类可以访问
4 默认:同一个包中可以访问