//仅作为学习笔记



class Demo
{
	int div(int a,int b) throws Exception//在功能上通过throws的关键字声明该功能可能出现问题
	{
		return a/b;
	}
}


class ExceptionDemo
{
		public static void main(String[]args) //throws Exception
		{
			Demo d = new Demo();

		try
		{
				int x = d.div(4,0);
				//int x = d.div(4,1);
				System.out.println("x="+x);	
		}
		catch (Exception e)
		{
			System.out.println(e.toString());
		}
		
			System.out.println("Over");
		}

}

在开发中，如果去调用别人写的方法时，是否能知道别人写的方法是否会发生异常？这是很难判断的。针对这种情况，Java总允许在方法的后面使用throws关键字对外声明该方法有可能发生异常，这样调用者在调用方法时，就明确地知道该方法有异常，并且必须在程序中对异常进行处理，否则编译无法通过。
如下面代码



package www.kangxg.jdbc;

public class Example {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
       int result = divide(4,2);
       System.out.println(result);
    }
    
    public static int divide(int x,int y) throws Exception
    {
        int result = x/y;
        return result;
    }

}

这时候 编译器上会有错误提示  Unhandled exception type Exception
所以需要对调用divide()方法进行try...catch处理 




package www.kangxg.jdbc;

public class Example {

    public static void main(String[] args) {
        
      try {
         int    result = divide(4,2);
          System.out.println(result);
       } catch (Exception e) {
        
          e.printStackTrace();
       }
      
    }
    
    public static int divide(int x,int y) throws Exception
    {
        int result = x/y;
        return result;
    }

}
debug 运行程序

当 调用divide()方法时，如果不知道如何处理声明抛出的异常，也可以使用throws 关键字继续抛异常，这样程序也能编译运行。但是注意的是，程序一旦发生异常，如果没有被处理，程序就会非正常终止。如下：

package www.kangxg.jdbc;

public class Example {

    public static void main(String[] args) throws Exception {
        
          int    result = divide(4,0);
          System.out.println(result);
      
    }
    
    public static int divide(int x,int y) throws Exception
    {
        int result = x/y;
        return result;
    }

}
   

debug运行程序
 
  




Java 运行时异常与编译时异常
1. 编译时异常
   在Java 中，Exception类中除了RuntimeException 类及其子类外都是编译时异常。编译时异常的特点是Java编译器会对其进行检查，如果出现异常就必须对异常进行处理，否则程序无法编译通过。
  处理方法
   使用try... catch 语句对异常进行捕获
   使用throws 关键字声明抛出异常，调用者对其进行处理
2.运行时异常
  RuntimeException 类及其子类运行异常。运行时异常的特点是Java编译器不会对其进行检查。也就是说，当程序中出现这类异常时，即使没有使用try... catch 语句捕获使用throws关键字声明抛出。程序也能编译通过。运行时异常一般是程序中的逻辑错误引起的，在程序运行时无法修复。例如 数据取值越界。
三 自定义异常
  JDK中定义了大量的异常类，虽然这些异常类可以描述编程时出现的大部分异常情况，但是在程序开发中有时可能需要描述程序中特有的异常情况。例如divide()方法中不允许被除数为负数。为类解决这个问题，在Java中允许用户自定义异常，但自定义的异常类必须继承自Exception或其子类。例子如下



package www.kangxg.jdbc;

public class DivideDivideByMinusException  extends Exception {
    
    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    public DivideDivideByMinusException(){
        super();
    }
    
    public DivideDivideByMinusException(String message)
    {
        super(message);
    }
}

  
package www.kangxg.jdbc;

public class Example {

    public static void main(String[] args) throws Exception {
        
        try {
             int    result = divide(4,-2);
              System.out.println(result);
         } catch (DivideDivideByMinusException e) {
            
             System.out.println(e.getMessage());
         }
      
    }
    
    public static int divide(int x,int y) throws DivideDivideByMinusException
    {
        if(y<0)
        {
            throw new DivideDivideByMinusException("被除数是负数");
        }
        int result = x/y;
        return result;
    }

}
   

Debug 运行


  

View Code 

 1 class Math{
 2     public int div(int i,int j) throws Exception{
 3         int t=i/j;
 4         return t;
 5     }
 6 }
 7 public class ThrowsDemo {
 8     public static void main(String args[]) throws Exception{
 9         Math m=new Math();
10         System.out.println("出发操作："+m.div(10,2));
11     }
12 }


主方法使用throws关键字

//仅作为学习笔记


/*

throws 和throw的区别
1，throws使用在函数上。
2，throw使用在函数内。

throws后面跟的异常类可以跟多个，用逗号隔开
throw后面跟的是异常对象。

*/



class FuShuException extends Exception
{
	private int value;
	FuShuException(String msg,int value)
	{
		super(msg);
		this.value = value;
	}

	public int getValue()
	{
		return value;
	}
}



class Demo
{
	int div(int a,int b)throws FuShuException//throws定义在函数上
	{
		if(b < 0)
		{
			throw new FuShuException("出现了除数是负数的情况！",b);//throws定义在函数内
		}
		return a/b;
	}
}

class ExceptionDemo3 
{
	public static void main(String[] args) 
	{

		Demo d = new Demo();


		try
		{
			int x = d.div(4,-1);							
			System.out.println(" x = "+ x);
		}
		catch (FuShuException e)
		{
			System.out.println(e.toString());
			System.out.println("出现错误的数是："+e.getValue());
		}

	}
}