try
{
    ......    //可能产生异常的代码
}
catch( ExceptionName1 e )
{
    ......    //当产生ExceptionName1型异常时的处置措施
}
catch( ExceptionName2 e )
{
......     //当产生ExceptionName2型异常时的处置措施
}  
[ finally{
......     //无条件执行的语句
        }  ]

 1 public static void main(String[] args) {
 2         try {
 3             int i = 10;
 4             int j = i / 0;
 5         } catch(NullPointerException e){
 6             System.out.println(e.getMessage());
 7         } catch(ArithmeticException e){
 8             System.out.println(e.getMessage());
 9         } catch(Exception e){
10             System.out.println(e.getMessage());
11         }
12         System.out.println("end...");
13         }

1 public static void main(String[] args) {
2         try {
3             InputStream is = new FileInputStream("abc.txt");
4         } catch (FileNotFoundException e) {            
5             e.printStackTrace();
6         }
7     }    

public class TestException {    
    public static void main(String[] args) {
        try {
            test();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }    
    
    public static void test() throws FileNotFoundException
    {
        InputStream is = new FileInputStream("abc.txt");
    }
}

public class TestException {    
    public static void main(String[] args) {
        try {
            test();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }    
                                  //多个异常在抛出时，是没有父类和子类先后的写法顺序的，只有处理时才有顺序
    public static void test() throws IOException, FileNotFoundException, SQLException
    {
        InputStream fs = new FileInputStream("abc.txt");  //抛出FileNotFoundException
        
        Connection connection = null; 
        String sql = null;
        PreparedStatement ps = connection.prepareStatement(sql); //抛出SQLException
        
        byte [] buffer = new byte[fs.available()];      //抛出IOException
    }
}

public class TestException {    
    public static void main(String[] args) {
        try {
            test();
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }                              
    public static void test() 
    {
        int i = 10 / 0;
        System.out.println(i);
    }
}

public class TestException {    
    public static void main(String[] args) {
        //从多态的角度考虑，调用了a的方法，就应该按a对象方法的抛出异常的方法来处理，即是父类的异常类型，如果子类抛了范围更大的异常，就无法处理
        //这就与java的继承或者多态机制相悖
        A a = new B();
        try {
            a.method();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }                              
}

class A{
    void method () throws FileNotFoundException{        
    }
}
class B extends A{
    @Override
    //这种是不合法的
    void method() throws IOException {

    }
}
//重写方法不能抛出比被重写方法范围更大的异常类型
//从理解的角度：
//我们现在有个动物类，它有个方法叫  eat() ，抛出"被毒死"的异常! 那么我们的子类在重写eat()方法时可以抛出 "被毒死"异常或其子类，如"被毒药毒死异常”、
//"被毒蘑菇毒死异常“.....
//但是却不能抛出毒死异常之外的  如”撑死异常“或者”噎死异常“
//就好比比如说宪法规定骂人只承担民事责任，到了刑法里就不能说直接枪毙了，这就是一个约束能力的问题，子类行为不能超出父类约束范畴。否者就容易乱套。
//就像父类的某方法公有的，子类就不能重写改成私有的了。这就是一个约束力的问题。

public class TestException {    
    public static void main(String[] args) {
        
    }    
    
    public static void test(){        
        //1. 创建一个异常类对象
        RuntimeException ex = new RuntimeException();        
        //2. 把异常类对象抛出去
        throw ex;
    }
}

public class AgeTooLargeException extends RuntimeException{


    private static final long serialVersionUID = 1L;

    public AgeTooLargeException() {
        // TODO Auto-generated constructor stub
    }
    
    public AgeTooLargeException(String msg) {
        super(msg); 
    }
}

import java.util.Scanner;
/**
 * 人工手动抛出异常:
 * 1. 创建一个异常类对象
 * 2. 在方法内部使用 throw 关键字把该异常类对象抛出去!
 * 
 * 自定义的异常类:
 * 1. 通常继承自 RuntimeException(可以继承 Exception)
 * 2. 自定义的异常类就是用来被人工抛出的！
 */
public class TestException {    
    public static void main(String[] args) {
        inputAge();
        System.out.println("end...");
    }    
    /**
     * 输入年纪: 要求年纪必须在 15-30 之间, 超出 30 则年纪偏大
     */
    public static void inputAge(){
        Scanner sc = new Scanner(System.in);        
        System.out.print("age=");
        int age = sc.nextInt();        
        if(age > 30){
            //System.out.println("年纪偏大.");
            throw new AgeTooLargeException("年纪偏大.");
        }
    }
}

public static void main(String[] args) {
        try {
            inputAge();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        System.out.println("end...");
    }    

package com.atguigu.java;

public class EcmDef {
    public static void main(String[] args) {
        
        try {
            int i = Integer.parseInt(args[0]); // "a"
            int j = Integer.parseInt(args[1]);            
            System.out.println(ecm(i, j));
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("输入的参数个数不足.");
        } catch (ArithmeticException e) {
            System.out.println("除数不能为 0");
        } catch (EcDef e) {
            System.out.println(e.getMessage()); 
        } catch (NumberFormatException e) {
            System.out.println("输入的参数不能转为整型.");
        }

    }
    
    public static int ecm(int i, int j){
        
        if(i < 0 || j < 0){
            throw new EcDef("不能处理负数. ");
        }        
        int result = i / j;
        return result;
    }
}


//自定义一个输入负数的异常类
public class EcDef extends RuntimeException{

    public EcDef() {
        // TODO Auto-generated constructor stub
    }
    
    public EcDef(String msg) {
        super(msg);
    }
}