java中的Object与异常

1:Object类

(1)Object是类层次结构的根类，所有的类都直接或者间接的继承自Object类。
(2)Object类的构造方法有一个，并且是无参构造
(3)要掌握的方法：
    A:toString()
        返回对象的字符串表示，默认是由类的全路径+'@'+哈希值的十六进制表示。
        这个表示其实是没有意义的，一般子类都会重写该方法。
    B:equals()
        比较两个对象是否相同。默认情况下，比较的是地址值是否相同。
        而比较地址值是没有意义的，所以，一般子类也会重写该方法。
(4)要了解的方法：
    A:hashCode() 返回对象的哈希值。不是实际地址值，可以理解为地址值。
(5)注意问题；
    直接输出一个对象名称，其实默认调用了该对象的toString()方法。

2:异常

(1)软件运行中，由于数据的问题，会导致程序在运行产生一些使JVM无法运行的一些异常情况，
这些异常情况，统称为：异常
异常情况的后果：导致程序中断。
而程序员还不希望程序因为异常情况而中断程序，这时，Java为程序员提供了一种"异常处理机制"，使用这种机制，
在异常产生的情况下，让程序继续健康的运行下去。
异常处理机制：要求程序员在编程时，就要事先预见到可能出现异常的代码， 然后使用异常处理机制进行监控、捕获、处理等操作，
 最终目的：使程序继续健康运行下去。
(2)异常的体系
Throwable
    |--Error 于指示合理的应用程序不应该试图捕获的严重问题，我们不处理。
    |--Exception
        |--RuntimeException 运行期异常，我们需要修正代码
        |--非RuntimeException 编译期异常，必须处理的，否则程序编译不通过
(3)异常的处理：
    A:JVM的默认处理
        把异常的名称,原因,位置等信息输出在控制台，但是呢程序不能继续执行了。
        1).JVM执行到异常的代码；
        2).JVM要识别出这种异常。
        3).JVM要到类库中找到这个异常的"描述类"--任何类型的异常都有相应的"描述类".
        4).JVM要创建一个这个异常类的对象；
        5).JVM将这个异常对象信息打印到控制台：
        6).JVM将程序停掉，然后结束运行。
    B:自己处理
        a:try...catch...finally
        自己编写处理代码,后面的程序可以继续执行
(4)try_catch处理异常_过程解析
    1)异常处理机制最基本方式：

....
            try{
                //可能出现异常的代码
            }catch(异常类名 变量名){
                //如果try中出现此类型异常，会转向执行到这里
            }
            ...无论是否出现异常，都会继续运行...
            ...
            ...

    2).注意：
        1).可能出现异常的代码的识别：要凭经验，没有经验就可以当代码没有异常情况，然后要进行充分的测试，测试后发现异常，然后再更改代码。
        2).catch中的异常类型名的指定：可以先假定没有异常，然后做测试，出现异常在控制台就知道有什么异常了。
        3).异常可以嵌套使用：

try{
                    ...
                    try{
                        ...
                    }catch(具体的异常类型 e){
                        ...
                    }
                    ...
                    try{
                        ...
                    }catch(具体的异常类型 e){
                        ...
                    }
                    ...
                }catch(Exception e){
                    ....
                }

(5)catch处理异常_过程解析

try{
            ...
            ...
            ...
        }catch(异常类名1 变量名){
            ...
        }catch(异常类名2 变量名){
            ...
        }....

    注意：
    1.如果try中可能出现多个异常，当出现异常时，try中后续代码将不会被执行，直接跳到响应的catch中运行。
    2.多catch的异常类型可以是"平级关系"，没有先后顺序关系；
      但也可以是"子父级关系"，父级的异常类型，必须要在多catch的末尾。
            b:throws
                把自己处理不了的，在方法上声明，告诉调用者，这里有问题
(6)面试题
    A:编译期异常和运行期异常的区别?
        编译期异常 必须要处理的，否则编译不通过
        运行期异常 可以不处理，也可以处理
    B:throw和throws是的区别
        throw:
            在方法体中,后面跟的是异常对象名,并且只能是一个
            throw抛出的是一个异常对象，说明这里肯定有一个异常产生了
        throws:
            在方法声明上,后面跟的是异常的类名,可以是多个
            throws是声明方法有异常，是一种可能性，这个异常并不一定会产生
(7)finally关键字
    A:finally用于释放资源，它的代码永远会执行。特殊情况：在执行到finally之前jvm退出了
    B:异常处理的变形

try...catch...finally
            try...catch...
            try...catch...catch...
            try...catch...catch...fianlly
            try...finally

(8)Throwable的几个常见方法
    1).public String getMessage():获取异常信息。
    2).public String toString():重写toString()
    3).public void printStackTrace():打印堆栈异常。通常是测试时候使用,便于发现错误代码的位置，便于维护。

            try{
                System.out.println(10 / 0);
            }catch(ArithmeticException e){//异常对象实参，是由JVM创建并传递的。
                System.out.println("异常信息是：" + e.getMessage());
                System.out.println("toString:" + e.toString());//异常类名 ： 异常信息
                System.out.println("打印堆栈异常信息：");
                e.printStackTrace();
            }

(9)方法中处理异常的方式_throws
    1).如果知道某些方法中可能会发生什么异常，可以在方法声明处显示的声明要抛出这种异常，
       如果方法内真的出现异常，JVM会将异常对象抛给调用者。
       方法内如果出现任何异常，建议抛给调用者，不要私自处理。

    2).格式：

public void show() throws 异常类名1 , 异常类名2 , .... , 异常类名n {
                方法体，如果这里面发生了上面声明的几种异常类型之一，JVM就会将异常对象抛给调用者。
            }

    3).注意：
        1).如果抛出的是"运行时异常"：调用者可以不捕获，编译可以通过。但如果出异常，程序仍然挂。建议调用者调用前必须要通过各种方式了解到这个方法会抛出什么异常，对于任何类型的异常都应该去处理。
        2).如果抛出的是"非运行时异常"调用者必须处理。要么try...catch...要么继续抛出。否则编译错误。
(10)异常_方法中处理异常的方式_throw
    1).格式：

public void show(int[] arr){
                if(arr == null){
                    //手动的抛出一个异常对象
                    throw new NullPointerException();//也是方法的一种返回值，返回的是一个"异常对象"
                }
            }

    2).注意：
        1).如果抛出的是"运行时异常":方法声明处可以不声明throws；调用者也可以不处理；
        2).如果抛出的是"非运行时异常：方法声明处必须显示的声明throws这种异常，并且调用者必须处理；

public void show() throws IOException{
                    throw new IOException():
                }

(11)自定义异常
    继承自Exception或者RuntimeException,只需要提供无参构造和一个带参构造即可
(12)异常的注意实现
    1).什么是重写：子类编写一个跟父类一模一样的方法：返回值类型、方法名、形参列表访问修饰符要跟父类相同，或比父类更宽。
    2).完善：当父类方法不抛异常，抛出运行时，抛出非运行时异常，子类重写时的规则：
       例如：
        1.父类方法不抛出异常：子类重写时可以：
            1).可以不抛出任何异常；
            2).可以抛出任何的运行时异常；
            3).不能抛出任何的非运行时异常；
        2.父类方法抛出一个运行时异常，子类重写时：
            1).可以不抛出任何异常；
            2).可以抛出任何的运行时异常；
            3).不能抛出任何的非运行时异常；
        3.父类方法抛出一个非运行时异常，子类重写时：
            1).可以不抛出任何异常；
            2).可以抛出任何的运行时异常；
            3).只能跟父类相同的非运行时异常，不能抛出比父类更多的非运行时异常。

    3).结论：无论父类方法是否抛出异常，或者抛出任何异常，子类重写时都可以：
        1).不抛出任何异常；
        2).抛出任何的运行时异常；
        3).子类只能抛出跟父类相同的"非运行时异常"，不能抛出比父类更多的非运行时异常。