class FuShuException extends Exception//自定义对象
{
        private String msg;
        FuShuExcetion(String mag)
        {
                this.msg=msg;
        }
        public String getMessage()
        {
                return msg;
        }
}

class Demo
{
        int div(int a,int b)throws FuShuException//在功能上通过throws的关键字声明了该功能有可能会出现问题。
        {
                if(b<0)
                        throw new FuShuException("出现了除数是负数的情况");//手动让throw关键字抛出对象。

                return a/b;
        }
}


class  ExceptionDemo3
{
        public static void main(String[] args)
        {
                Demo d=new Demo();
                        try
                        {
                                int x=d.div(4,-2);
                        System.out.println("x="+x);
                        }
                        catch (FuShuException e)
                        {
                                System.out.println(e.toString());
                                System.out.println("除数为负数啦！！！");
                        }
                        
        
                System.out.println("over");
        }
}

这都什么资质啊，，，，，

真是有够蛋疼，，，，，错误原因也不贴上来，，，，构造方法上少写一个字母，，，， FuShuExcetion(String mag)这个地方，少些了，跟类名不一样。

FuShuExcetion(String mag)
         {
                 this.msg=msg;
         }

单词写错了{:soso_e127:}FuShuException

还是构造函数的名字写错了
见代码

1. 
   
2. class FuShuException extends Exception//自定义对象
   
3. {
   
4.         private String msg;
   
5.                 FuShuException(String mag)                                //                FuShuExcetion(String mag)        //构造函数的名字写错了，
   
6.         {
   
7.                 this.msg=msg;
   
8.         }
   
9.         public String getMessage()
   
10.         {
    
11.                 return msg;
    
12.         }
    
13. }
    
14. 
    
15. class Demo
    
16. {
    
17.         int div(int a,int b)throws FuShuException//在功能上通过throws的关键字声明了该功能有可能会出现问题。
    
18.         {
    
19.                 if(b<0)
    
20.                         throw new FuShuException("出现了除数是负数的情况");//手动让throw关键字抛出对象。
    
21. 
    
22.                 return a/b;
    
23.         }
    
24. }
    
25. 
    
26. 
    
27. class  ExceptionDemo3
    
28. {
    
29.         public static void main(String[] args)
    
30.         {
    
31.                 Demo d=new Demo();
    
32.                         try
    
33.                         {
    
34.                                 int x=d.div(4,-2);
    
35.                         System.out.println("x="+x);
    
36.                         }
    
37.                         catch (FuShuException e)
    
38.                         {
    
39.                                 System.out.println(e.toString());
    
40.                                 System.out.println("除数为负数啦！！！");
    
41.                         }
    
42.                         
    
43.         
    
44.                 System.out.println("over");
    
45.         }
    
46. }

复制代码

FuShuExcetion(String mag)
        {
                super(mag);
                this.mag=mag;
        }

你既然要继承父类，当然要初始化父类的成员了。

1. class FuShuException extends Exception //getMessage();
   
2. {
   
3.         private int value;
   
4. 
   
5.         FuShuException()
   
6.         {
   
7.                 super();
   
8.         }
   
9.         FuShuException(String msg,int value)
   
10.         {
    
11.                 super(msg);
    
12.                 this.value = value;
    
13.         }
    
14. 
    
15.         public int getValue()
    
16.         {
    
17.                 return value;
    
18.         }
    
19. 
    
20. }
    
21. 
    
22. 
    
23. 
    
24. class Demo
    
25. {
    
26.         int div(int a,int b)throws FuShuException
    
27.         {
    
28.                 if(b<0)
    
29.                         throw new FuShuException("出现了除数是负数的情况------ / by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。
    
30. 
    
31.                 return a/b;
    
32.         }
    
33. }
    
34. 
    
35. 
    
36. class  ExceptionDemo3
    
37. {
    
38.         public static void main(String[] args)
    
39.         {
    
40.                 Demo d = new Demo();
    
41.                 try
    
42.                 {
    
43.                         int x = d.div(4,-9);
    
44.                         System.out.println("x="+x);               
    
45.                 }
    
46.                 catch (FuShuException e)
    
47.                 {
    
48.                         System.out.println(e.toString());
    
49.                         //System.out.println("除数出现负数了");
    
50.                         System.out.println("错误的负数是："+e.getValue());
    
51.                 }
    
52.                
    
53.                
    
54. 
    
55.                 System.out.println("over");
    
56. 
    
57.         }
    
58. }
    
59. 
    
60. /*
    
61. class Throwable
    
62. {
    
63.         private String message;
    
64.         Throwable(String message)
    
65.         {
    
66.                 this.message = message;
    
67.         }
    
68. 
    
69.         public String getMessage()
    
70.         {
    
71.                 return message;
    
72.         }
    
73. }
    
74. 
    
75. class Exception extends Throwable
    
76. {
    
77.         Exception(String message)
    
78.         {
    
79.                 super(message);
    
80.         }
    
81. }
    
82. 
    
83. 
    
84. class Person
    
85. {
    
86.         String name;
    
87.         Person(String name)
    
88.         {
    
89.                 this.name = name;
    
90.         }
    
91.         public String getName()
    
92.         {
    
93.                 return name;
    
94.                 }
    
95. }
    
96. 
    
97. class Student extends Person
    
98. {
    
99.         Student (String name)
    
100.         {
     
101.                 super(name);
     
102.         }
     
103. }
     
104. 
     
105. new Sttdent("lisi").getName();
     
106. 
     
107. */

复制代码

希望能帮到