public class Exceptions {

     public static int function(int[] arr,int index) throws FuShuIndexException    //自定义错误类声明抛出

     {

         /*注意Java自带错误处理类不需要throws关键字进行声明抛出就可以使用,

          * 是因为这些类继承自RunTimeException,该异常及其子类编译时不被检测

          * 但是运行时会报错,并且直接中断程序运行

          */

         if(arr==null){

             throw new NullPointerException("传入数组为空指针！");

         }

         if(index>arr.length-1){

             throw new ArrayIndexOutOfBoundsException("哥们,数组角标越界了！");

         }

         if(index<0){

             throw new FuShuIndexException("不能使用负数角标");

         }

         return arr[index];

     }

     public static void main(String[] args) throws FuShuIndexException        //调用处抛出

     {

         int[] arr={1,2,3,4};

         /*经过catch的处理就相当于解决异常,后续操作可以继续执行

          * 并且如果一段代码可以检测多个异常,则需要多个catch语句,但是只能接受第一个错误

          * catch语句如果接受Exception类型的对象,由于多态特性(子类可以替代父类使用)

          * 此时,该语句可以接受任意类型的异常,所有如果有该句应该放在最后

          */

         try{

             int a=function(null,2);

             System.out.println(a);

         }catch(FuShuIndexException F){

             System.out.println("负数角标异常！");

             System.out.println("message:"+F.getMessage());

             //sop会将内容转换为字符串在输出,对象也不例外,所以会自动执行toString（）操作

             System.out.println("string:"+F.toString());

             /*getStackTrace()方法可以获取错误的详细信息

              * printStackTrace()是将错误信息打印到控制台上,这是jvm默认使用的方法

              */

             F.printStackTrace();

         }catch(NullPointerException N){

             System.out.println("传入数组为空指针！");

         }catch(Exception E){

             System.out.println("其他错误");

         }

         //finally语句总会执行,所有通常用于关闭/释放资源

         finally{

             System.out.println("over");

         }

         System.out.println("end");

     }

 }

 /*Java中错误最顶端是Throwable类 ,所有的可用方法都在其中定义了,子类可以直接使用。

  * 自定义错误类必须继承异常体系(通常是Exception/RuntimeExcetion),以便可以抛出,

  * 并且按照规范应该以父类作为类名的结尾,提高阅读性

  * 自定义的错误类如果想要被Java处理,必须使用两种操作:

  * 1、声明抛出:就是在需要抛出错误的函数参数后用 throws关键字+自定义错误类名 作为声明抛出,注意可以多抛出

  * ()

  * ！！！注意这里的抛出和Java处理机制中的抛出一样,调用处也需要抛出。

  * 2、使用try{}catch(异常类型  变量){}finally{}结构处理

  * 上面两种方式如果自己能处理就用2,不能处理就抛出

  * ！！！注意:错误处理类一般不用进行太多操作,而且超累已经进行了封装,所以可以直接调用就行,

  * ！！！创建自定义的错误处理类是方便将错误进一步分类

  */

 class FuShuIndexException extends Exception{

     FuShuIndexException(){

     }

     FuShuIndexException(String msg){

         super(msg);

     }

 }

 public class ObjectSuper {

     public static void main(String[] args){

         ObjectSuperDemo o1=new ObjectSuperDemo();

         ObjectSuperDemo o2=new ObjectSuperDemo();

         System.out.println(o1==o2);

         //其实equals方法就是将o1==o2操作给封装了

         System.out.println(o1.equals(o2));

         /*Class对象:java中一切皆对象(类也一样,因为包含相同的内容被抽取为类对象)

          * 类/接口在加载后会生成一个class文件(即字节码文件),也会在内存中生成一个相应的字节码文件对象(Class对象)

          * 注意:一个类在内存中只会存在一份字节码文件对象,new的时候是根据这个对象生成新对象的。

          * 使用对象的getClass()可以获取这个对象,也叫运行时Class对象

          */

         /*toString():下面的println()的参数是字符串类型,所以所有类型都会进行转换

          * 其中基本类型直接转换,而对象类型是调用toString()实现的。和equals()一样,

          * Object对象对该方法进行了实现,但是子类可以对其进行覆盖

          */

         System.out.println(o1.getClass());

     }

 }

 class ObjectSuperDemo{

 }

 class ObjectSuperDemo1{

     ObjectSuperDemo1(int num){

         setNum(num);

     }

     private int num;

     public int getNum() {

         return num;

     }

     public void setNum(int num) {

         this.num = num;

     }

     /*覆盖Object的equals()的操作是常见操作,因为其是根据地址来进行判断

      * 而在实际中往往需要判断对象特有内容是否相同,此时不必重建新方法,而是重写equals()

      * 由于多态和类型转换问题,需要进行健壮性判断

      * 总会被重写,而Object中仍有equals方法是因为它是所有对象的父类,如果没有实现(是抽象方法)

      * 以后每个类中,不管是否有其他功能,都有先实现该功能,不方便

      */

     public boolean equals(Object obj){

         if(!(obj instanceof ObjectSuperDemo1)){

             //return false;

             throw new ClassCastException("类型不匹配");

         }

         ObjectSuperDemo1 o=(ObjectSuperDemo1)obj;

         return this.num==o.num;

     }

     public int hashCode(){

         return num;

     }

 }