《day12---异常》

 //91-面向对象-异常-异常的发生和简单应用。
 /*
 异常：
 java运行时期发生的问题就是异常。
 
 Java中运行时的除了异常Exception含有错误Error.
 
 异常：通常发生后可以有针对性的处理方式的。
 错误：通常发生后不会有针对性的处理方式。
       Error的发生往往都是系统级别的问题，都是jvm所在系统发生的并反馈给jvm
       无法修正处理，只能修改源代码。
 */
 
 class ExceptionDemo
 {
     public static void main(String[] args)
     {
         int[] arr = new int[1024*1024*1000];//Exception in thread "main" java.lang.OutOfMemoryError:
         System.out.println(arr[0]);
         System.out.println(arr[3]);//改句运行时，发生了异常Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
                                     //导致程序无法执行，程序结束。
         System.out.println("over");
     }
 }

 //92-面向对象-异常-异常的发生和简单应用。
 class Person
 {
     private String name;
     private int age;
     Person(String name,int age)
     {
         //加入逻辑判断。
         if(age<0 || age>200)
         {
             /*
             这样做虽然可以编译运行看到提示消息，但是问题却没有发生，
             程序还在继续执行，并打印了p对象，这是不合理的，人对象初始化过程
             中已经出了问题，为什么还要对人对象进行操作。
             所以应该将问题暴露出来，让使用改程序的调用者知道，
             所以要用异常来解决。
             */
 //            System.out.println("年龄数值错误");
 //            return;//终止初始化。
             throw new IllegalArgumentException(age+",年龄数值非法");
         }
         this.name = name;
         this.age = age;
     }
     //定义Perosn对象对应的字符串表现形式，覆盖Object中的toString方法，
     public String toString()
     {
         return "Person[name="+name+",age="+age+"]";
     }
 }
 
 class ExceptionDemo2
 {
     public static void main(String[] args)
     {
         Person p = new Person("XiaoMing",-20);
         System.out.println(p);
 
     }
 }

 //93-异常的定义&体系。
 /*
 ExceptionDemo2.java中的异常不好认，能不能定义一个符合我的程序要求的问题。
 
 异常的信息都可以自己定义，那么异常的名字是否可以自己定义呢？是否可以更
 符合自己程序的阅读呢？
 
 之前的几个异常都是java通过类进行描述，并将问题封装成对象，这是符合面向对象的
 思想的。
 其实：异常就是讲问题封装成了对象。
 
 所以我也准备对自己所需要的问题进行类的描述。
 
 发生了编译失败：
 ExceptionDemo3.java:43: 错误: 不兼容的类型: NoAgeException无法转换为Throwable
                         throw new NoAgeException(age+",年龄数值非法");
                         ^
 1 个错误
 
 不兼容，不明白，查阅API文档，提示说无法转换为Throwable，啥东西？
 搜索API,看到Throwable描述，发现，它是异常和错误的超类。
 原来它是异常体系的顶层类。
 Throwable
     |--Error
     |--Excepton.
 
 通过阅读，自定义异常被抛出，必须是继承Throwable,或者继承Throwable的子类
 该对象才可以被throw抛出。
 
 原来这个异常体系局部一个特有的特性，可抛性，可以被throw关键字操作。
 
 继承选择父类时，更为确切的是继承Exception。
 但是发现编译又异常失败了。
 
 ExceptionDemo3.java:61: 错误: 未报告的异常错误NoAgeException; 必须对其进行捕获或声明 以便抛出
                         throw new NoAgeException(age+",年龄数值非法");
                         ^
 1 个错误
 
 通过这个编译失败提示，发现自定义的异常和之前所使用的异常（空指针异常，
 角标越界异常，无效参数异常有不同。）
 抛出那些异常没有这个失败提示，那么之前的异常和自定义的异常有什么区别呢？
 通过查看API文档的继承体系发现，之前的异常都是Exception下面的RuntimeException子类
 的子类。
 阅读RuntimeException描述中有明确说明，这个运行时异常以及其子类都无需进行声明。
 
 可以将自定义的异常继承RuntimeException。
 
 */
 
 //自定义异常。描述Person的年龄数值非法。
 /**
 只要是本项目中的Person的年龄出现非法值，就会发生该异常。
 */
 class NoAgeException extends RuntimeException
 {
     /*
     为什么要定义构造函数，因为看到java中的异常描述类中有提供对问题的构造方法。
     */
     NoAgeException()
     {
         super();
     }
 
     NoAgeException(String message)
     {
         super(message);//如果自定义异常需要异常信息，可以通过调用父类带有
                         //字符串参数的构造函数即可。
     }
 }
 
 class Person
 {
     private String name;
     private int age;
     Person(String name,int age)
     {
         //加入逻辑判断。
         if(age<0 || age>200)
         {
             throw new NoAgeException(age+",年龄数值非法");
         }
         this.name = name;
         this.age = age;
     }
     //定义Perosn对象对应的字符串表现形式，覆盖Object中的toString方法，
     public String toString()
     {
         return "Person[name="+name+",age="+age+"]";
     }
 }
 
 class ExceptionDemo3
 {
     public static void main(String[] args)
     {
         Person p = new Person("XiaoMing",-20);
         System.out.println(p);
 
     }
 }

 //94-编译时异常和运行时异常
 /*
 ExceptionDemo3.java中涉及的问题。
 1，继承Exception和继承RuntimeException为什么差距那么大？
 2，啥是捕获，啥事声明？
 */
 
 class Demo
 {
     void show()
     {
         //如果在函数内抛出Exception//编译失败，因为编译器在检查语法时发生了错误。
         /*
         该抽象已经出现问题，java认为这个程序本身存在隐患，需要捕获或者声明出来。
         （要么捕获，要么声明出来，让调用者知道。）
         */
 //        throw new Exception();
 
         /*
         为什么抛出RuntimeException就不需要捕获，不需要声明呢？
         不是功能本身发生的异常，而是因为比如调用者传递参数错误
         而导致功能运行失败。
         这时也是问题，需要通过异常来体现，但是这个异常时不需要声明
         出来的。
         声明的目的是为了让调用者进行处理。
         不声明的目的是不让调用者进行处理。就是为了让程序停止，让调用
         者看到现象，并进行代码的修正。☆☆☆☆☆
 
         异常分两种
         1.编译时异常。编译器会检测。
         2.运行时异常。编译器不会检测，不需要声明。声明也可以，如果声明了
                                         无外乎，就是让调用者给出处理方式。
         常见的异常；
         ArrayIndexOutOfBoundsEception
         IllegalArgumentException
         NullPointerException
         ClassCastException
 
         */
         throw new RuntimeException();
     }
 }
 class ExceptionDemo4
 {
     public static void main(String[] args)
     {
         System.out.println("Hello World!");
     }
 }

 //95-异常-声明&捕获
 /*
 声明和捕获：
 声明：将问题标识出来，报告给调用者。
 如果函数内，通过throw抛出了编译时异常，而没有捕获，
 那么必须通过throws进行声明，让调用者去处理。
 
 捕获：java中对异常有针对性的语句进行捕获。
 语句：
 try
 {
     //需要被检测的代码或者语句。
 }
 catch(异常类 变量)//参数。
 {
     //异常的处理语句。
 }
 finally
 {
     //一定会被执行的语句。
 }
 
 */
 class Demo
 {
     /*
     如果定义功能时，有问题发生，需要报告给调用者，可以在函数
     上使用throws进行声明。
     */
     void show(int x)throws Exception
     {
         if(x>0)
         throw new Exception();
         else
             System.out.println("show run");
     }
 }
 
 class ExceptionDemo5
 {
     public static void main(String[] args)//throws Exception//在调用者上继续声明
     {
         Demo d = new Demo();
         try
         {
             d.show(2);//当调用了声明异常的方法时，必须有处理方式，要么捕获，要么声明。
         }
         catch (Exception ex)//括号中，需要定义什么呢？对方抛出的是什么问题，在括号中就定义什么问题的引用。
         {
             System.out.println("异常发生了");
         }
 
         System.out.println("Hello World!");
     }
 }

 //96-声明&捕获在例子中的应用。
 
 class NoAgeException extends RuntimeException
 {
     /*
     为什么要定义构造函数，因为看到java中的异常描述类中有提供对问题的构造方法。
     */
     NoAgeException()
     {
         super();
     }
 
     NoAgeException(String message)
     {
         super(message);//如果自定义异常需要异常信息，可以通过调用父类带有
                         //字符串参数的构造函数即可。
     }
 }
 
 class Person
 {
     private String name;
     private int age;
 
     /*
     构造函数到底抛出的NogAgeException是继承Exception呢？还是继承
     RuntimeException呢？
     继承Exception就必须要throws声明，一旦声明就告知调用者要进行捕获，
     一旦问题处理完了，调用者的程序会继续执行，但是，如果使用到了Person
     对象的数据，会导致代码都是失败的。
     如果继承RuntimeException是不需要throws声明的，那么这时，调用者是不可
     能编写捕获代码的，因为调用者根本不知道有问题。
     一旦发生NoAgeExcepton，调用者程序会停掉，并由jvm将信息显示到屏幕上。
     让调用者看到，然后调用者去修改源代码。
     */
     Person(String name,int age)//throws NoAgeException
     {
         //加入逻辑判断。
         if(age<0 || age>200)
         {
             throw new NoAgeException(age+",年龄数值非法");
         }
         this.name = name;
         this.age = age;
     }
     //定义Perosn对象对应的字符串表现形式，覆盖Object中的toString方法，
     public String toString()
     {
         return "Person[name="+name+",age="+age+"]";
     }
 }
 
 class ExceptionDemo6
 {
     public static void main(String[] args)
     {
 //        try
 //        {
             Person p = new Person("XiaoMing",20);
             System.out.println(p);
 //        }
 //        catch (NoAgeException ex)
 //        {
     //        System.out.println("异常发生了");
 //        }
 
         System.out.println("over");
 
     }
 }

 //97-运行时异常的应用。
 /*
 描述长方形：
     属性：长和宽。
     行为：获取面积。
 
 考虑健壮性问题：
 万一长和宽数值非法。
 描述问题：将问题封装成对象，用异常的方式来表示。
 */
 
 /*
 不知道要继承编译时异常还是运行时异常。
 */
 
 class NoValueException extends RuntimeException
 {
     NoValueException()
     {
         super();
     }
     NoValueException(String message)
     {
         super(message);
     }
 }
 class Rec
 {
     private int length;
     private int width;
     Rec(int length,int width)
     {
         if(length<=0 || width<=0)
         {
             //抛出异常，但是不用声明，不需要调用者处理，就需要一旦问题日发生，让调用者端进行停止，修改代码去。
             throw new NoValueException("长或者宽的数值非法，请修正。");
         }
         this.length = length;
         this.width = width;
     }
     /**
     定义面积函数。
     */
     public int getArea()
     {
         return length*width;
     }
 }
 class ExceptionDemo7
 {
     public static void main(String[] args)
     {
         Rec r = new Rec(-3,4);
         int area = r.getArea();
         System.out.println("area="+area);
 
     }
 }

 //98-99--编译时异常和异常的转换
 /*
 案例二：毕老师用电脑讲课。
 两个对象：
     老师：
         属性：姓名。
         行为：讲课。
     电脑：
         行为：运行。
 
 考虑问题：
 1.电脑蓝屏--->异常
 
 2.电脑冒烟了-->异常
 */
 //可以声明出来，让调用者给出处理方式。
 class LanPingException extends Exception
 {
     LanPingException()
     {
         super();
     }
     LanPingException(String message)
     {
         super(message);
     }
 }
 
 class MaoYanException extends Exception
 {
     MaoYanException()
     {
         super();
     }
     MaoYanException(String message)
     {
         super(message);
     }
 }
 /*
 讲课中冒烟，问题可以临时解决，但是冒烟问题没有直接处理，所以就使用throws声明。
 但是发现，这个问题不应该属于讲课的问题，调用讲课方法的调用者处理不了这个问题，
 该调用者能处理的应该是冒烟导致的课程进行不下去的问题。
 应该在列出一个异常，课时停止异常。
 */
 
 class NoPlanException extends Exception
 {
     NoPlanException()
     {
         super();
     }
     NoPlanException(String message)
     {
         super(message);
     }
 }
 
 class NoteBook
 {
     private int state=2;
     public void run()throws LanPingException,MaoYanException
     {
         System.out.println("笔记本电脑运行");
         if(state == 1)
             throw new LanPingException("电脑蓝屏了");
         if(state == 2)
             throw new MaoYanException("电脑冒烟了");
 
     }
     public void reset()
     {
         state = 0;
         System.out.println("电脑重启");
     }
 }
 
 class Teacher
 {
     private String name;
     private NoteBook book;
     Teacher(String name)
     {
         this.name = name;
         book = new NoteBook();
     }
 
     //讲课：
     public void prelect()throws NoPlanException
     {
         /*
         调用到了声明异常的方法，在这里到底是捕获好呢？还是声明好呢？
         有具体的捕获处理方法吗？有，那就捕获，没有，那就声明。
         我可以处理，重启电脑就可以了，重启是电脑的功能。
         */
         try
         {
             book.run();//对于声明多个异常的方法，在处理，需要定义多个catch与之对应。
         }
         catch (LanPingException e)//LanPingException e = new LnaPingException("电脑蓝屏了")
         {
             //重启；
             System.out.println(e.toString());
             e.printStackTrace();
             book.reset();
         }
         catch(MaoYanException e)//MaoYanException e = MaoYanException("电脑冒烟了");
         {
             System.out.println(e.toString());
             test();
             //冒烟问题没有解决。继续声明throws出去。
 //            throw e;
             throw new NoPlanException(e.getMessage()+",课时停止");//异常转换。
 
         }
         System.out.println("讲课");
     }
         //留练习题
         public void test()
         {
         System.out.println("做练习");
         }
 }
 
 class ExceptionDemo8
 {
     public static void main(String[] args)
     {
         Teacher t = new Teacher("毕老师");
         try
         {
             t.prelect();
         }
         catch (NoPlanException e)
         {
             System.out.println(e.toString());
             System.out.println("换老师");
         }
         System.out.println("Hello World!");
     }
 }

 //100-throw和throws的区别。
 /*
 throw和throws的区别:
 
  1,throw用在函数内，
    throws用在函数上。
  2，throw抛出的是异常对象。
     throws用于进行异常类的声明，后面异常类用逗号隔开。
 */
 class Demo
 {
     void show()throw Exception
     {
         throw new Exception();
     }
 }
 class
 {
     public static void main(String[] args)
     {
         System.out.println("Hello World!");
     }
 }