Java：异常的处理

class ExceptionDemo
{
    public int  method(int a,int b)
    {
       return a/b;
    }
}
class ExceptionDemoTest 
{
    public static void main(String[] args) 
    {   
        ExceptionDemo ed = new ExceptionDemo();
        try
        {
           int x = ed.method(4,0);
           System.out.println("x = "+x);
        }
        catch (Exception e)
        {
           System.out.println(e.toString()); //输出异常的类的对象
           System.out.println("除零了");
        }
        finally
        {
            System.out.println("over");
        }
    }
}

class ExceptionDemo
{
    public int  method(int a,int b) throws Exception
    {
       return a/b;
    }
}
class ExceptionDemoTest 
{
    public static void main(String[] args) throws Exception
    {   
        ExceptionDemo ed = new ExceptionDemo();
        ed.method(4,0);
        System.out.println("over");
    }
}

class ExceptionDemo
{
    public int  method(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException
    {
       int[] array = new int[a];
       System.out.println(array[4]);
       return a/b;
    }
}
class ExceptionDemoTest 
{
    public static void main(String[] args) 
    {   
        ExceptionDemo ed = new ExceptionDemo();
        try
        {
         //int x = ed.method(4,0);  //所传两个数据均发生了异常，即数组下标越界异常和除数为0异常，但这两个
                                    //异常不能同时检测到，因为检测时有循序，但第一个检测到处理完时即停止
                                    
        // int x = ed.method(4,1);  //检测到数组越界异常
           int x = ed.method(5,0);  //检测到除0异常
           System.out.println("x = "+x);
        }
        catch (ArithmeticException e)
        {  
           System.out.println("异常的数据信息为"+e.getMessage());
           System.out.println(e.toString());  //输出异常的类的对象
           System.out.println("除零了");
           //e.printStackTrace();    //其实它是虚拟机的处理机制
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
          System.out.println("异常的数据信息为"+e.getMessage());
          System.out.println(e.toString());     //输出异常的类的对象
          System.out.println("数组角标越界异常");
          //e.printStackTrace();    //其实它是虚拟机的处理机制
        }
        catch(Exception e)     //这个是上面的子类异常的父类异常，多用于处理不在具体的异常之外的异常
        {
          System.out.println(e.toString());     //输出异常的类的对象
        }
        finally
        {
            System.out.println("over");
        }
    }
}

//继承Exception的异常类

class FuShuException extends Exception
{  
/* private String msg;
   FuShuException(String msg)
    {
      this.msg = msg;
    }
   public String getMessage()   //输出异常信息
    {
      return msg;
    }
*/ private int vaule;
   FuShuException(String msg,int vaule)
    {
      super(msg);          //父类throwable已经完成了异常的处理，子类直接可以调用,所以上面的异常初始化方法不用再写
      this.vaule = vaule;
    } 
   public int getVaule()
    {
      return vaule;
    }
}

//异常类
class ExceptionDemo 
{
    public int  method(int a,int b) throws FuShuException
    {
       if(b<0)
            throw new FuShuException("出现了除数是负数的情况:/by fushu",b);  //通过手动throw抛出自定义异常对象
       return a/b;
    }
}

//主方法测试
class ExceptionDemoTest 
{
    public static void main(String[] args) 
    {   
        ExceptionDemo ed = new ExceptionDemo();
        try
        {
           int x = ed.method(4,-1);
           System.out.println("x = "+x);
        }
        catch (FuShuException e)
        {
           System.out.println(e.toString()); //输出自定义异常类，自动去调用前面的get Message();
           System.out.println("错误的负数是:"+e.getVaule());
           //System.out.println("除数为负数了");
        }
        finally
        {
            System.out.println("over");
        }
    }
}

//继承Exception的电脑蓝屏异常类

class BlueScreenException extends Exception
{
    private String message;
    public BlueScreenException(String message)
    {
       super(message);
    }
}

//继承Exeption的系统冒烟异常类
class SystemSmokingException extends Exception
{
    private String message;
    public SystemSmokingException(String message)
    {
       super(message);
    }
}

//继承Exception的转换异常类
class NoPlanExecption extends Exception
{
    private String message;
    public NoPlanExecption(String message)
    {
       super(message);
    }
}

//定义一个老师类
class Teacher
{
    private String name;
    private Computer c;
    public Teacher(String name)
    {
        this.name = name;
        c = new Computer(3);  //设置电脑目前的状态(1或2或3)
    }
    void lecture() throws NoPlanExecption
    {   
        try
        {
             c.run();
        }
        catch (BlueScreenException e)
        {   
            System.out.println(e.toString());
            c.reset();
        }
        catch(SystemSmokingException e)
        {
            test();
            throw new NoPlanExecption("讲课不能继续,"+e.getMessage());   //冒烟异常老师解决不了，转换为课程进度异常抛出
        }
        System.out.println(name+"讲课");
     }
     public void test()
        {
            System.out.println("学生自己做练习");
        }
} 

//定义一个电脑类
class Computer
{   
    private int state;  //电脑状态：数字1代表正常运行、数字2代表蓝屏、数字3代表冒烟
    public Computer(int state)
    {
      this.state = state;
    }
    void run() throws BlueScreenException,SystemSmokingException
    {
      if(state==2)
          throw new BlueScreenException("电脑蓝屏了");

      else if(state==3)
          throw new SystemSmokingException("电脑冒烟了");

      System.out.println("电脑运行");
    }
    public void reset()
    {
      state = 1;    //重新将电脑状态设置成数字1
      System.out.println("电脑重新启动");
    }
}

//测试类
class CustomizeExceptionDemo 
{
    public static void main(String[] args) 
    {
        Teacher t = new Teacher("毕老师");
        try
        {
            t.lecture();
        }
        catch (NoPlanExecption e)
        {
            System.out.println(e.toString());
            System.out.println("换老师或放假");
        }
    }
}