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
                {
                        if(b<0)
                           throw  new FuShuException("出现了除数为负数的情况！",b); //手动通过throw关键字抛出一个自定义异常对象
                        return a/b;
                }
}

class FuShu
{
        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());
                        //        System.out.println("出现负数了!");
                }
                System.out.println("over");
        
        }
}


怎么理解？？？

不知道有没有帮助

1. package exercise;
   
2. 
   
3. class FuShuException extends Exception//自定义异常必须是在Throwable这个体系中，才可以try和throw
   
4. {
   
5.         
   
6.         private int value;//定义这个变量是为了获取负数是多少。
   
7.         FuShuException(String msg,int value)
   
8.         {
   
9.                 super(msg);//子类的空构造方法默认第一行是super()。
   
10.                                         //这里定义了有参的构造方法，所以所以没有无参的构造方法。
    
11.                                         //必须有一个构造方法访问父类,这是继承的特性。
    
12.                 this.value=value;//将负数b传递给形参value,value再传递给本类的成员变量this.value，方便在别的方法中调用。
    
13.         }
    
14.         public int getvalue()//通过这个方法调用负数。
    
15.         {
    
16.                 return value;
    
17.         }
    
18. }
    
19. 
    
20. class Demo
    
21. {
    
22.                 int div(int a,int b)throws FuShuException//当异常不是RunTimeException的子类时，
    
23.                                                                         //内部没有try catch的话必须声明异常，就是throws抛出异常。
    
24.                 {
    
25.                         if(b<0)
    
26.                            throw  new FuShuException("出现了除数为负数的情况！",b); //手动通过throw关键字抛出一个自定义异常对象
    
27.                         return a/b;
    
28.                 }
    
29. }
    
30. 
    
31. public class FuShu
    
32. {
    
33.         public static void main(String args[])
    
34.         {
    
35.                 Demo d=new Demo();
    
36.                 try//try中存放的是有可能出现异常的代码
    
37.                 {
    
38.                         int x=d.div(4,-1);
    
39.                 System.out.println("x=="+x);
    
40.                 }
    
41.                 catch(FuShuException e)//catch是处理出现的对应的异常。
    
42.                 {
    
43.                                 System.out.println(e.toString());
    
44.                                         System.out.println("错误的负数是："+e.getvalue());
    
45.                         //        System.out.println("出现负数了!");
    
46.                 }
    
47.                 System.out.println("over");
    
48.         
    
49.         }
    
50. }

复制代码

清风有意 发表于 2014-4-17 12:02
不知道有没有帮助

兄弟 谢了！