1.避免使用检查的异常（Checked Exception），要使用 RuntimeException。

2.转化异常时仅增加信息。
  try{
   ...
  }
  catch(Exception ex){
    throw new RuntimeException(message, ex);
  }
3.不要隐藏异常。
  catch(Exception ex){ // 错误代码
    throw new RuntimeException(message, ex);
  }
4.使用 finally 块释放资源。

5.异常处理方式中，业务逻辑应放到 try 中。
  异常处理仅用来处理错误。
6.调用者可以使用返回的异常描述信息，也可以根据类型判断异常类别。
 
7.异常影响性能
  抛出异常需要的性能消耗，是返回一个结果值得 10-100,000 倍；
  不要在循环体内用异常处理结构；应该在外层、较低频率使用异常处理。
 

    动物类要有呼吸方法。怎么呼吸就是子类的事了。 

    现在有很多讨论和建议提倡用interface代替abstract类，两者从理论上可以做一般性的混用，但是在实际应用中，他们还是有一定区别的。抽象类一般作为公共的父类为子类的扩展提供基础，这里的扩展包括了属性上和行为上的。而接口一般来说不考虑属性，只考虑方法，使得子类可以自由的填补或者扩展接口所定义的方法，就像JAVA王子所说的事件中的适配器就是一个很好的应用。

    用一个简单的例子，比如说一个教师，我们把它作为一个抽象类，有自己的属性，比如说年龄，教育程度，教师编号等等，而教师也是分很多种类的，我们就可以继承教师类而扩展特有的种类属性，而普遍属性已经直接继承了下来。 

    而接口呢，还是拿教师做例子，教师的行为很多，除了和普通人相同的以外，还有职业相关的行为，比如改考卷，讲课等等，我们把这些行为定义成无body的方法，作为一个集合，它是一个interface。而教师张三李四的各自行为特点又有不同，那么他们就可以扩展自己的行为body。从这点意义上来说， interface偏重于行为。 

    总之，在许多情况下，接口确实可以代替抽象类，如果你不需要刻意表达属性上的继承的话。

public class Prime
{
    public static void main(string args[])
    {
        int n=0;
        int i,j;
        boolean flag;
        for(i=2;i<100;i++)
        {
            flag=true;
            for(j=2;j<=i/2;j++)
            {
                if(i%j==0)
                {
                    flag=false;
                    break;
                }
          }
          if(flag)
          {
              System.out.print(i+" ");
              n++;
              if(n%5==0)
                  System.out.println();
          }
    }
}

基础知识：在程序运行时，常常会出现一些非正常的现象，这种情况称为运行错误。根据其性质可以分为错误和异常。

错误：常见的有程序进入死循环，内存泄漏等。这种情况，程序运行时本身无法解决，只能通过其他方法干预。对应的类为Error类。

异常：常见的有除数为0，数组越界等。这种情况，不向错误那样，程序运行时本身可以解决，由异常代码调整程序运行方向，使程序仍可继续运行直至正常结束。对应的类为Exception类。

抛出异常：当程序发生异常时，产生一个异常事件，生成一个异常对象，并把它提交给运行系统，再由运行系统寻找相应的代码来处理异常，这个过程称为抛出异常。

捕获异常：异常抛出后，运行时系统从生成对象的代码开始，沿方法的调用栈逐层回溯查找，直到找到包含相应处理的方法，并把异常对象交给该方法为止，这个过程称为捕获异常。

使用try—catch—finally语句捕获和处理异常。

图一 五大模板

对模板的一点解释：

1. try语句 当某段代码在运行时可能产生异常的话，应该把这段代码放到try语句中去。但不要把所有的语句放到try语句中，因为粒度太大。

2. catch语句 其中的参数类似于方法的声明，包含一个异常类型和一个异常对象。异常类型必须是Throwable类的子类，当然也可以是自己自定义的异常类。        

A. 一个try语句下面可以有多个catch语句，分别处理不同的异常。但排列顺序必须是从特殊到一般，最后一个一般都是  Exception类（模板四）。

B. 也可以用一个catch语句处理多个异常类型，这时它的异常类型参数应该是这些异常类型的超类（模板三）。

C. java运行时系统从上到下分别对每个catch语句处理的异常类型进行检测，直到找到与类型匹配的catch语句为止。  匹配是指catch所处理的异常类型与所生成的异常类型完全一致或是它的超类。

D. 如果程序所产生的异常和所有的catch处理的异常都不匹配，则这个异常将由java虚拟机捕获并处理，此时与不使用异常处理是一样的。

3. finally语句 在try所限定的代码中，当抛出一个异常时，其后的代码不会被执行。通过finally语句可以指定一块代码。无论try所指定的程序块中抛出或不抛出异常，也无论catch语句的异常类型是否与所抛出的异常的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。该语句也是可以省略的（模板二）。

4. 异常语句嵌套  当在处理异常时很有可能再次抛出异常，这种现象是非常常见的。常见形式为模板五。

      大家也许在编程的过程中，会意识到这里出错，但不知道会抛出什么异常，也是一件头疼的事，现将这部分总结如下：

算术异常类：ArithmeticExecption

空指针异常类：NullPointerException

类型强制转换异常：ClassCastException

数组负下标异常：NegativeArrayException

数组下标越界异常：ArrayIndexOutOfBoundsException

违背安全原则异常：SecturityException

文件已结束异常：EOFException

文件未找到异常：FileNotFoundException

字符串转换为数字异常：NumberFormatException

操作数据库异常：SQLException

输入输出异常：IOException

方法未找到异常：NoSuchMethodException

这是最常见的一些异常，大家可以在日后的使用中总结，但最详细的恐怕还是JDK的文档了。还是看JDK的文档吧：）；  

Exception异常类的方法

Public class Exception extends Throwable

构造方法：public Exception()

              public Exception(String s)

实例方法：public String getMessage()

              public void printStackTrace()

区别一：

throw是语句抛出一个异常；throws是方法抛出一个异常；

throw语法：throw <异常对象>

在方法声明中，添加throws子句表示该方法将抛出异常。

throws语法：<修饰符>]<返回值类型><方法名>（[<参数列表>][throws<异常类>]

其中：异常类可以声明多个，用逗号分割。

区别二：throws可以单独使用，但throw不能；

区别三：throw要么和try-catch-finally语句配套使用，要么与throws配套使用。但throws可以单独使用，然后再由处理异常的方法捕获。

跟声明一个类一样，但必须是继承于Exception类。可以用throw和throws抛出这个自定义的类。

首先以两个例子开始：

1）
public class Test2 {  public static void main (String [] args)  {
 StringBuffer a = new StringBuffer ("A");
 StringBuffer b = new StringBuffer ("B");
 operate (a,b);
 System.out.println(a+","+b);
 }static void operate(StringBuffer x, StringBuffer y){
     x.append(y);
     y = x;
   }
}
输出：AB,B

2）
public class Test2 {  public static void add3 (Integer i){
      int val=i.intValue();
      val += 3;
      i = new Integer (val);
  }  public static void main (String args [ ] )  {
 Integer  i = new Integer (0);
  add3 (i);
  System.out.println (i.intValue ( ));
 }
}
输出：0

    首先我们应该明白JAVA中的参数传递全是以值传递的。是基本类型，就拷贝一个基本类型传进方法；是引用，就拷贝一个引用变量传进去方法，理解了这两点就能理解方法操作对象的相关问题了。最好能画出引用指向对象的图出来，就能完全理解了。
    第1题，调用operate方法时，传入了两个引用a,b的拷贝x,y，这两个x,y都指向原a,b引用所指向的对象。x.append(y)对它指向的对象(即a指向的对象)进行了操作。而x=y，只是两个拷贝变量在赋值，并没有影响到原b所指向的对象。所以b所指向的对象仍然为B。
第2题，i=new Integer(val)只是一个引用的拷贝指向了另外一个对象，而原来的i仍然是指向对象new Integer(0)的。
把握住了JAVA都是传值并且传的都是拷贝的话，类似的题大家都能迎刃而解了。Java中的参数传递只有一种方式: by value. 理论说教太麻烦了，直接看些例子吧:
1). 基本类型
    public class A{
   public static void main(String[] args){
       int x = 1;
       System.out.println(x);    //1
       test(x);
       System.out.println(x);    //还是1＝＝>By value
   }
  
   static void test(int a){
      a = 2;
   }
}

2). 引用类型
    public class B{
   public static void main(String[] args){
       Integer x = new Integer(1);
       System.out.println(x);
       test(x);
       System.out.println(x);
      
   }
  
   static void test(Integer a){
      a = new Integer(2);
   }
}    

    理解这里的关键是区分对象和引用。 这里声明的x是一个引用，而不是一个对象（只是Java把它设计为看上去好像是对象一样）。这个引用它指向了一个对象，这个对象就是后面用new关键字生成的对象。因此，可以说x指向了一个Integer对象。

    在调用test方法的时候，程序将x作为参数传递给test方法了。这里仍然是值传递，在test调用过程中，会产生一份新的引用(不妨叫做y)。此时，x和y指向了同一个对象。

    x和y指向的是同一个对象， 由于Java的设计，我们可以通过操作引用来达到操作对象的目的。因此，如果我们此时使用y来修改对象的属性 (例如，y.someField++); 你可以看到x指向的对象同时也被修改到了。

    另一方面，如果我们让y指向另外一个对象， y=new Integer(2); 此时x和y就指向了不同的
对象。y修改了它指向的对象的属性，很显然不会影响到x指向的对象。有人说了数组。数组也是一个引用类型，它的参数传递方式按照引用类型的参数传递一样可以解释得通：

import java.util.Arrays;public class A{
   public static void main(String[] args){
      int[] aa = {3, 2, 1};
      System.out.println(Arrays.toString(aa));  //[3, 2, 1]
      test(aa);
      System.out.println(Arrays.toString(aa));  //[3, 2, 1]
      test2(aa);
      System.out.println(Arrays.toString(aa));  //[4, 2, 1]
   }
  
   static void test(int[] a){
      a = new int[]{1, 2, 3};   //指向了新对象
   }
  
   static void test2(int[] a){
     if(a != null && a.length > 0)
       a[0]++;              //修改原来的那个对象
   }
}

对象是传引用，简单类型是传值，不要被网上的一些概念所迷惑！！！你可以自己做个试验。
至于String等类型传的还是引用。如果你用concat方法，String对象的原值就会被改变。
但你如果按如下方法：

public class Test {
    public static void test(String str) {
        str = "World";
    }
    public static void main(String[] args) {
        String string = "Hello";
        test(string);
        System.out.println(string);
    }
}　　

运行结果：Hello

这里str = "World" 就等同于 String str＝new String("World")。所以结果没有改变！！！ 

下列程序在1处是否会有异常，如果没有，输出是什么？是否会运行到2处，如果会，输出是什么？为什么会有这样的结果？ 　　

import java.util.arraylist;
　　 import java.util.list;
　　
　　 public class testclass {
　　 public static void main(string args[]) {
　　　　 list list = new arraylist();
　　　　 test2(list);
　　　　 system.out.println(list.size()); // 1处
　　　　 test3(list);
　　　　 system.out.println(list.size()); // 2处
　　 }
　　
　　 public static void test2(list list) {
　　　　 list = null;
　　 }
　　
　　 public static void test3(list list) {
　　 　　 list.add(“aaaa“);
　　 }
　　 }plumechen:

不会出错的。结果是0，1。

因为test2(list)传得是list的引用，我理解成指针置的副本，list=null；只是把那个传入的值设置为null，不改变原来list的指针和内容。test3(list)传入的一样，但是执行了list.add()由于传入指针值的副本也指向原来的那个list的地址，所以原来的那个list的内容就改变了， size变成了1了。