Java学习之路0722（八）（object类、异常处理）

Object类

Java中所有的引用数据类型都继承于Object类,也称为祖类。Java中Object类位于Java.lang.Object。它是所有类的父类

Object类中常用的方法有equals(),toString(),hashCode().

equals()方法

equals()方法用于比较两个引用的对象是否一致相等，equals()方法默认实现是使用“==”运算符比较两个对象的引用地址，而不是比较内容，所以要想真正实现比较对象的内容，需要在自定义中重写equals方法。

public class Student1 {
    private int id;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

public class StudentTest {
    public static void main(String[] args) {

        Student1 zhangsan=new Student1();
        zhangsan.setId(1);
        zhangsan.setName("张三");
        Student1 lisi=new Student1();
        lisi.setId(1);
        lisi.setName("zhangsan");
        System.out.println(zhangsan.equals(lisi));
    }//输出的结果为false
}
如果将equals重写的话，就可以实现比较内容相等的equals
public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        if(this.id==1){
            return true;
        }
        return super.equals(obj);
    }
    输出的结果为true

toString()方法

toString()方法返回该对象的字符串表示、

hashCode()方法

返回该对象的哈希表值

异常处理

异常的定义:在程序中。错误可能产生于程序员没有预料到的各种情况，已尝试在一个程序执行期间发生的事件，他中断了正在执行的程序的正常进行。

异常的产生可能是除数为0 ，或者是数组越界，指向为空等等

public class Test {
    public static void main(String[] args)   {
        System.out.println(1/0);
}
}

异常的分类

RubntimeException异常不用try。。。catch捕捉，只是在运行时才会发现异常。

异常处理、捕捉异常

try{
//程序代码块
}
catch（Exceptiontype1 e）{
//对异常1的处理
}
catch（Exceptiontype2 e）{
//对异常2的处理
}
···
finally{
//程序块
}

catch捕捉的异常的范围广的在下面，范围小的在上面

public class Test {
    public static void main(String[] args) throws FileNotFoundException, IOException  {
        int i=1;
        int k=0;
        try{         //除数为0 的异常
            System.out.println(i/k);
        }catch(ArithmeticException ex){
            ex.printStackTrace();
            System.out.println("除数非零");
        }
    }
}

自定义异常

1、创建自定义异常类；
2、在方法中通过throw关键字抛出异常对象；
3、如果在当前抛出的异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则方法中声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。

import java.io.PrintWriter;
public class MyException extends Exception{//创建自定义的异常类，继承Exception类
    @Override
    public void printStackTrace() {重写父类的方法
        System.err.println("不准上课睡觉");
        super.printStackTrace();
    }
}

public class Test {
    public static void main(String[] args) throws FileNotFoundException, IOException  {
        Student a=new Student();//自定义异常
        try{
            a.study();
        }catch(MyException e){
            e.printStackTrace();
        }
    }
}

throw和throws 的区别

throws是关键字通常被应用在声明方法时，用来指定方法可能抛出的异常

throw关键字通常用于方法体中，并且抛出一个异常对象

如果想要在上一级代码中捕获异常并处理异常，则需要在抛出异常的方法中使用throws关键字在方法声明的中指明要抛出的异常;如果要捕捉throw抛出的异常，则必须使用try-catch语句块。

编写的自定义异常类
import java.io.PrintWriter;
public class MyException extends Exception{
    public MyException(String string) {
        // TODO Auto-generated constructor stub
        System.out.println(string);
    }   
}

Student2类
public class Student2 {
    int numbook;
    public void readbook ()throws MyException{
        if(numbook<=0){
            throw new MyException("没有书可读");
        }//throw写在方法体内。throws用在方法声明时
    }
}


Test测试类
public class Test {
    public static void main(String[] args)  {
        Student2 lisi=new Student2();
        lisi.numbook=0;
        try {
            lisi.readbook();
        } catch (MyException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

异常处理规则

1、不过度使用异常；2、不适用庞大的try语句块；3、不忽视捕获到的异常。