面向对象之自定义异常

 

/*

因为项目中出现了特有的问题

而这些问题并未被Java所描述并封装对象。

所以对于这些特有的问题可以按照Java的对问题封装的思想、

将特有的问题，进行自定义的一场封装

 

自定义异常：

 

需求：在本程序中，对应除数是-1，也是为错误的，是无法进行运算的。，

那么就需要对这个问题进行自定义的描述。

 

当在函数内部出现了throw抛出了异常对象，那么就必须要给对应处理动作

要么在汉函数上申明让调用者处理

要么在函数上声明让调用者处理

 

一般情况下，函数内部出现异常，函数上需要声明

 

发现打印的结果中集中只有异常的名称。却没有异常的信息

因为自定义的异常并未定义信息

 

如何定义异常信息？？？

因为父类中已经发异常信息的操作已经完成了，

所以子类只要在构造时，将异常信息传给父类通过super语句，

那么就可以直接通过getMassage方法获取自定义的异常信息，

 

自定义异常：

必须是自定义类继承Exception。

 

继承Exception原因：

异常体系有一个特点，因为异常类和异常对象都会抛出

他们就、都具有可抛型。这个可抛型是Throwable这个体系中独有的特点

 

只有这个体系中的类和对象才可以被throws和throw操作！

 

throws和throw和区别：

throws使用在函数上

throw使用在函数内。

throws后面跟着异常类，可以跟多个、用逗号分开。

throw后面跟的是异常对象

 

 

*/

class FuShuException extends Exception //getMassage();

{

     private int value;

     //private String mag;

     FuShuException(String msg)

     {

 

     super(msg);

 

     /*this.msg = msg;

     }

     public String getMessage()

     {

     return msg;*/

     }

     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 FuShuExeption("出现了除数是负数的情况 -----/by fushu",b);//手动通过throw关键字手动抛出自定义异常对象

     }//throw定义在函数内！

     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("除数出现负数了");

         System.out.println("错误的负数是："+e.getValue());

     }

 

     System.out.println("over")

     }

}

/*

class Throwable

{

private String message;

Throwable(String message)

     {

     this.message = message;

     }

     public String getMassage()

     {

     return message;

     }

}

class Exception extends Throwable

{

Exception(String massage)

     {

     super(massage);

     }

}

class Person

{

String name;

Person(String name)

     {

     this.name = name;

     }

     public String getName()

     {

     return name();

     }

}

class Student extends Person

{

Student (String name)

     {

     super(name);

     }

}

new Student("lisi")

*/

 

面向对象之RuntimeException

/*

 

Exception有一个特殊的子类异常，ArithmeticException执行时异常

 

如果在函数内部抛出异常，函数上可以不用声明，编译一样通过1

 

如果在函数上申明了该异常，调用者可以不用进行处理，编译一样通过。

 

之所以不用在函数声明，是因为不需要让调用者处理

当该异常发生，希望程序停止，因为在运行时，出现了无法继续运算的情况，希望停止程序后！

对待吗进行修正！

 

 

自定义异常时：如果该异常的发生，无法在继承进行运算！

就让自定义异常继承RuntimeException.

 

对应异常分两种：

1，编译时被检测的异常

2，编译时不被检测的异常（运行是异常，RuntimeException以及子类）

 

*/

 

class FuShuException extends RuntimeException

{

     FuShuException(String msg)

     {

     super.(msg);

     }

}

 

class Demo

{

int div(int a,int b)//throws ArithmeticException

     {

     if (b<0)

      throw new FuShuException("出现的除数为负数")；

     if (b==0)

      throw new ArithmeticException("被零除啦");

     return a/b;

}

class ExceptionDemo5

{

public static void main(String[] args)

     {

     Demo d = new Demo();

 

     int x = a.div(4,0);

 

     System.out.println("x="+x);

 

     System.out.println("over")

     }

}

/*

     class Person

     {

     public void checkName(String name)

         {

 

         //if (name.equals("lisi"))//NullPointerException

         if("lisi".equals(name))

              System.out.println("yes");

         else

              Sytem.out.println("no");

        

         }

     }

     main()

     {

     Person p = new Person();

     p.checkName("haha");

     }

     */