day05-【异常、Object类】

1.Object 类

Object类是所有类的父类，是最顶层的父类。

当一个类没有直接继承其他父类时，这个类的直接父类就是Object类；
class Person{
    ....    
}
等价于
class Person extends Object{
    ...
}

1.equals方法：
    boolean equals（Object obj）：判断当前对象与obj对象的地址是否一样，如果一样就返回true，否则返回false；
2.重写equals方法：
    应为object类自带的equals方法不能满足需求，所以重写；

    重写的目标：
        1.如果两个对象的地址一样就返回true；
        2.否则 如果两个对象中数据都一样也返回true；
        3.否则 返回false；
    重写的代码不需要自己写，可以使用eclipse快捷键生成；

3.String toString（）方法：
    是用来返回对象的字符串表示；

    Object类中的toString方法默认返回对象的地址；

4.重写toString（）方法：
    因为我们希望toString返回的是对象的内容，而不是地址：
    重写的目标：
        Person[name="冬冬"，age=25];

2.异常

Java代码中出现的不正常的情况；

Throwable类是异常类的继承结构中最顶层的异常类；

Throwable
    |--Error:错误,java代码中出现非常严重的问题,不修改代码问题解决不了,就象人患了癌症,不动手术活不下去;
    |--Exception:异常,java代码中出现一般的问题,只要处理一下就解决了.就象人患了感冒,发烧,只要吃点药就可以了.
        |-运行时异常:RuntimeException:NullPointerException,ArrayIndexOutOfBoundsException;
        |-编译时异常:FileNotFoundException,IOException;

    通常说的异常值的是Exception,不是Error.

    怎么区分是Error还是Exception?
        异常的名字如果是以Error结尾的,表示这个异常是一个错误: java.lang.OutOfMemoryError
        异常的名字如果是以Exception结尾的,表示这个异常是一个普通的异常:java.io.FileNotFoundException

    常见的异常:
        1.空指针异常:NullPointerException;
        2.数组索引越界的异常:ArrayIndexOutOfBoundsException;
        3.文件找不到的异常:FileNotFoundException;
        4.类型转换异常:ClassCastException;
        5.IO异常:IOException;

1.JVM处理异常的过程:
    1.程序执行到出错的那一行代码时,JVM创建了一个异常对象:new ArrayIndexOutOfBoundsException(5);
    2.JVM会把异常对象抛出给这一行代码所在的方法:printArray(int[] iArray);
    3.由于printArray方法没有处理异常,所以这个方法会把异常抛给方法的调用者main方法;
    4.main方法接收到异常对象后也没有处理,所以main方法把异常对象抛给它的调用JVM;
    5.JVM接收到异常之后,打印异常信息,结束程序的运行;


2.自己在程序中创建异常对象并抛出

    1.确定出错的那一行代码;
    2.在满足某个条件后,创建异常对象:
        new 异常类名(异常的描述信息);
    3.使用throw关键字把刚才创建的异常对昂向外抛出:
        throw new 异常类名(异常的描述信息);

4.处理异常

    第一种处理方法:

        捕获式处理:

            使用try{}catch{}代码块包裹住可能会出现异常的代码.

            格式1:
                    /*
                     * 第一种处理方式的格式:
                     *   try{
                     *      可能会出现异常的代码;
                     *   }catch(异常类名 异常的对象名){
                     *      处理异常的代码;
                     *   }
                     * 
                     */

                    示例代码:
                        public static void printArray(int[] iArray){

                            System.out.println(iArray[0]);
                            // 捕获处理异常
                            try{
                                // 可能会出现异常的代码
                               System.out.println(iArray[5]);
                               System.out.println("我是也是try里面的代码....");
                            }catch(ArrayIndexOutOfBoundsException e){
                                // 处理异常的代码;
                                System.out.println("数组的长度不能小于6!");
                            }

                            // try..catch语句之后的代码,在捕获住异常之后,会继续被执行
                            System.out.println("程序要没有结束..try..catch语句之后的代码..");
                        }


            格式2:
                    /*
                     * 第二种处理方式的格式:
                     *   try{
                     *      可能会出现异常的代码;
                     *   }catch(异常类名 异常的对象名){
                     *      处理异常的代码;
                     *   }finallay{

                            不管程序是否抛出异常,都必须要执行的代码写在这个位置;
                         }
                     }
                     * 
                     */


                      不管try代码块中的程序是否抛出异常,finally代码块中的程序都会被执行;

                    示例代码:
                        public static void main(String[] args) {
                            FileWriter fw = null;
                            try{
                                // 可能会出现异常的代码
                                fw = new FileWriter("D://a.txt");
                                // 如果上面一行抛出异常,下面这行代码将不会被执行
                                fw.write("hello");
                            }catch(IOException e){
                                System.out.println("文件找不到或者写入数据错误!");
                            }finally{
                                // 不管try代码块中的程序是否抛出异常,finally代码块中的程序都会被执行;
                                System.out.println("finally代码块...");
                                try {
                                    fw.close();
                                }catch (NullPointerException e) {
                                    System.out.println("空指针异常!");
                                }catch (IOException e) {
                                    System.out.println("IOException!");
                                }
                            }
                            // 上面的异常如果被捕获住了,下面的代码会继续被执行
                            System.out.println("try...catch..finally语句之后的代码....");
                    }


        捕获处理的好处:

            可以自己捕获和处理异常,并让try...catch..语句之后的代码继续执行;




    第二种处理方式:
        声明式处理:

            在方法的小括号后面使用throws 关键字,把方法中可能会抛出的异常类名列出来,多个异常类名之间用逗号隔开;

            格式:

                修饰符 返回值类型 方法名(参数列表) throws 异常名1,异常名2...{
                    方法体;
                }

                意思是告诉这个方法的调用者必须处理声明出来的异常;

            示例代码:
                public static void method03() throws IOException,NullPointerException{

                        FileWriter fw = null;
                        fw = new FileWriter("S://a.txt");
                        fw.write("hello");
                        fw.close();
                }

3.自定义异常

 因为JDK中提供的异常类不能满足我们的需要,或者异常的类名太长,或者不好学习,所以我们要自定义异常类;

如何自定义异常呢?

    jdk定义异常的特点:
        1.写一个类,继承异常类(既可以是Throwable类,也可以是它的子类);
        2.在类中定自己的构造方法;
        3.在自己的构造方法中调用父类的构造方法;


    自定义异常,按照jdk的定义方式:
        1.写一个类,继承异常类(既可以是Throwable类,也可以是它的子类);
        2.在类中定自己的构造方法;
        3.在自己的构造方法中调用父类的构造方法;

    示例代码:
        //1.写一个类,继承异常类(既可以是Throwable类,也可以是它的子类);
        public class NoAgeException extends RuntimeException{

            // 2.在类中定自己的构造方法;
            public NoAgeException(){

                //3.在自己的构造方法中调用父类的构造方法;
                super();
            }

            public NoAgeException(String message){
                //3.在自己的构造方法中调用父类的构造方法;
                super(message);
            }
        }

    使用自定义异常:

        1.创建异常对象;
        2.使用throws关键字抛出;

        示例代码:

            public class Person {
                ....

                public void setAge(int age) {

                    if(age > 150 || age < 0){
                        throw new NoAgeException("年龄不能大于150,不能小于0!");
                    }
                    this.age = age;
                }

                ....

            }

5.补充

 异常的分类 

* Exception : 所有异常子类,编译异常
* RuntimeException : 所有异常子类,运行异常
*
* 编译异常: 调用了一个抛出异常的方法,必须要处理,不处理编译失败
* throws try catch
*
* 运行异常: 方法抛出异常,都是RuntimeException类或者是他的子类
* 方法定义上,不需要写throws, 调用者不用处理
* 设计思想: 一旦发生,不要进行try..catch处理
* 必须程序停止运行,修改源代码
*
* 运行异常:
* 不需要写throws
* 只要发送,请你修改源码
*
* 举出常见的4个运行时期的异常 面试题
* NullPointerException 空指针异常
* ArrayIndexOutOfBoundsException 数组越界异常
* ClassCastException 类型转换异常
* IllegalArgumentException 无效参数异常