class Demo
{
       int div(int a ,int b)throws Exception    //这个抛出异常时声明该功能可能出现问题
       {
                 return a/b;
       }
}
class  ExceptionDemo1                              
{
       public static void main(String[] args) throws Exception //课时这里程序并没有异常，4/1是正确的啊，为什么还要抛出啊
       {                                                      
                 Demo d = new Demo();
                 int x =d.div(4,1);
                 System.out.println("x="+x);
                 System.out.println("over!");
       }
}

class Demo
{
       int div(int a ,int b)throws Exception    //这个抛出异常时声明该功能可能出现问题
       {
                 return a/b;
       }
}
class  ExceptionDemo1                              
{
       public static void main(String[] args) throws Exception //课时这里程序并没有异常，4/1是正确的啊，为什么还要抛出啊
       {                                                      
                 Demo d = new Demo();
                 try
                 {
                     int x =d.div(4,1);//你这行代码可能会出现异常，因为除数可能是0. 其实你这样在主函数上
                 }                                      声明可能出出现异常不好。
                 catch(ArithmaticException e)   //这样会抛给JVM。建议使用try,catch捕获这个异常来处理它。而且                              
                 {                                     ArithmaticException是RuntimeException的子类，可以通过修改代码来完善程序的。
                                            dosomething;
                                   }
                 System.out.println("x="+x);
                 System.out.println("over!");
       }
}

异常并不是说到发生了再去抛，再去处理，当程序有潜在的出现异常的可能时就要声明，就要处理。
int div(int a ,int b)throws Exception    //这个抛出异常时声明该功能可能出现问题
       {
                 return a/b;
       }

像上面这个方法就有潜在的异常(b<0)，这时就要声明并处理，函数本身没有处理就要声明。所以在函数上声明了该异常，由调用者来处理。

主函数在调用该函数时，发现该函数声明了异常，就要进行处理(要么处理(try)要么抛)如果不能处理（通常情况下必须处理）可再次将异常抛出
所以下面的语句，主函数再次将异常抛出，由虚拟机来处理。
public static void main(String[] args) throws Exception //课时这里程序并没有异常，4/1是正确的啊，为什么还要抛出啊

1. class Demo
   
2. {
   
3.         int div(int a ,int b)throws Exception    //这个抛出异常时声明该功能可能出现问题
   
4.                                       //你这抛出了异常，将抛给调用这个函数的调用者，那么调用者要么throws，要么try
   
5.         {
   
6.                   return a/b;
   
7.         }
   
8. }
   
9. class  ExceptionDemo1                              
   
10. {
    
11.         public static void main(String[] args) // throws Exception //课时这里程序并没有异常，4/1是正确的啊，为什么还要抛出啊
    
12.                                                      //这里调用了抛出异常的方法，那么main方法要么抛出这个异常给JVM，要么就要在这里try
    
13.         {                                                      
    
14.                  Demo d = new Demo();
    
15.                  try
    
16.                {
    
17.                       int x =d.div(4,1);
    
18.                }
    
19.                catch(Exception e)
    
20.               {}
    
21.                   System.out.println("x="+x);
    
22.                   System.out.println("over!");
    
23.         }
    
24. }
    

复制代码

看看这个吧，希望你能理解

class Demo
{
        int div(int a ,int b)throws Exception    //这个抛出异常时声明该功能可能出现问题
        {
                  return a/b;
        }
}
class  ExceptionDemo1                              
{
        public static void main(String[] args) throws Exception //课时这里程序并没有异常，4/1是正确的啊，为什么还要抛出啊   原因三点：1.d调用的div方法本身就有可
                                                      能产生异常；2.当b=0的时候，除数不可以为0，产生异常；3.当a<b的时候，因为申明x是int类型，这样会产
                                                      生精度溢出，出现异常。
        {                                                      
                 Demo d = new Demo();
                  int x =d.div(4,1);
                  System.out.println("x="+x);
                  System.out.println("over!");
        }
}

今天学了一部分异常,那我就小小的总结一下

进行操作的表达式有可能会抛出异常的,我们必须要处理它,这里处理有两种方式
一种是try-catch,一种是抛出
如果是子类复写父类的方法,而父类没有异常抛出的话,子类出现了异常只能try-catch
如果父类抛出了异常,那子类就可以抛出与父类异常的子集
抛出异常的关键字有两个 一个是throw,一个是throws
throw写在异常对象前
throws写在方法后,后面可以写多个异常
异常分为运行时异常和编译时异常
所有RuntimeException及其子类都是运行时异常
编译时异常是除上述运行时异常外的所有Exception及其子类的异常
Exception 和 Error同属于throwable类

...纯手打啊..

因为你声明的是 throws Exception  ，这个说简单点吧，是编译时异常，编译的时候JVM就告诉程序员这个方法是有问题的必须得到处理，你要么在mainh函数里面try catch（为什么呢？因为你主函数中有调用到这个方法int x=d.div(4,1)） ,要么再向上throws抛出，这个时候抛到主函数了（到JVM了，不能再抛出了）。

如果你将div方法 后面声明的是 throws RuntimeException(运行时异常)，那么程序只会在运行的时候才有可能报错，也就是你说的  4/1 程序正常运行， 但是4/0程序就报错了。（这个动作是在运行时才能知道的）