java基础学习——（11）异常、Object类

it2022-05-05 133

异常

在运行时期发生的不正常情况。

Throwable（可抛） Error（错误）通常出现重大问题如：运行的类不存在或者内存溢出等不编写针对代码对其处理 Exception（异常）在运行时运行出现的一起情况，可以通过try catch finally

Exception和Error的子类名都是以父类名作为后缀

在java中用类的形式对不正常情况进行了描述集合封装对象。描述不正常的情况的类，就称为异常类。以前正常流程代码和问题处理代码相结合，现在将正常流程和异常问题处理相分离，提高阅读性。

其实异常就是java通过面向对象的思想将问题封装成了对象。用异常类对其进行描述。不同的问题用不同的类进行具体的描述，比如角标越界，空指针等等。问题很多，意味着描述的类也很多。将其共性进行向上抽取，形成了异常体系。

最终问题（不正常情况）就分成了两大类：（Throwable以下两类的父类） 1、一般不可处理的。Error 2、可以处理的。Exception

Throwable：无论是error ，还是Exception，问题发生就应该可以抛出，让调用者知道并处理。该体系的特点就在于Throwable及其所有的子类都具有可抛性。

可抛性到底指的是什么？怎么体现可抛性呢？其实通过两个关键字体现的。throws throw,凡是可以被这两个关键字所操作的类和对象都具备可抛性。

1、一般不可处理的。Error 。特点：是由jvm抛出的严重性的问题，这种问题发生一般不针对性处理，直接修改程序。 2、可以处理的。Exception

该体系的特点：

子类的后缀都是用其父类名作为后缀，阅读性很强。

负数角标这种异常在java中并没有定义过。那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述，并封装成对象。这种自定义的问题描述称为自定义异常。

自定义异常：

class Demo { public int method(int[] arr,int index) { if(arr==null) throw new NullPointerException("数组的引用不能为空。")； if(index>=arr.length) { throw new ArrayIndexOutOfBoundsException("数组的角标越界啦~"+index); } if(index<0) { throw new ArrayIndexOutOfBoundsException("角标的数值不能为负啊兄弟："+index); } return arr[index]; } } class InnerClassDemo2 { public static void main(String[] args) { int[] arr = new int[3]; Demo d = new Demo(); int num = d.method(arr,30); System.out.println("num"+num); } } //输出结果： Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 数组的角标越界啦~30 at Demo.method(InnerClassDemo2.java:7) at InnerClassDemo2.main(InnerClassDemo2.java:18)

注意：如果过让一个类称为异常类，必须要继承异常体系。因为只有成为异常体系的子类才有资格具备可抛性，才可以被两个关键字所操作，throw 、throws

java虚拟机会先检查语法错误，然后再检查异常。

class FuShuIndexException extends Exception { FuShuIndexException() {} } class Demo { public int method(int[] arr,int index) { if(index<0) { throw new FuShuIndexException(); } return arr[index]; } } class InnerClassDemo2 { public static void main(String[] args) { int[] arr = new int[3]; Demo d = new Demo(); int num = d.method(arr,30); System.out.println("num"+num); } } //InnerClassDemo2.java:18: 错误: 未报告的异常错误FuShuIndexException; 必须对其进行捕获或声明以便抛出 // throw new FuShuIndexException(); // ^ //1 个错误

对异常进行声明

异常的分类：

1.编译时被检测异常：只要是Exception和其子类都是,除了特殊子类RuntimeException体系。这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式，这样的问题都可以针对性的处理。

2.编译时不检测异常（运行时异常）：就是Exception中的RuntimeException和其子类这种问题的发生无法让功能继续，运算无法进行，更多是因为调用者的原因导致的，或者引发了内部状态的改变导致的。那么这种问题一般不处理，直接接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行修正。

所以自定义异常时，要么继承Exception，要么继承RuntimeException。

RuntimeException是那些可能在java虚拟机正常运行期间抛出的异常的超类。可能在执行方法期间抛出但未被捕获的RuntimeException的任何子类都无需再throws子句中进行声明。

throws和throw的区别

1.throws使用在函数上， throw使用在函数内 2.throws抛出的是异常类，可以抛出多个，用逗号隔开。 throw抛出的时异常对象。

异常捕捉

这是可以对异常进行针对性处理的方法。

具体格式：

try { //需要被检测异常的代码。 } catch（异常类变量）//该变量用于接收发生的异常对象 { //处理异常的代码 } finally { //一定会被执行的代码 }

异常捕获实例

class FuShuIndexException extends Exception { FuShuIndexException(String msg) { super(msg);//继承的父类有相应的处理 } } class Demo { public int method(int[] arr,int index)throws FuShuIndexException //在所调用的地方加一个throws FuShuIndexException { if(index<0) { throw new FuShuIndexException("角标为负的啦"); } return arr[index]; } } class InnerClassDemo2 { public static void main(String[] args) { int[] arr = new int[3]; Demo d = new Demo(); try //在有可能出现异常的语句进行try { int num = d.method(arr,-3); System.out.println("num"+num); } //出现异常以后对异常进行捕获、处理 catch (FuShuIndexException e) { System.out.println("负数角标异常啦"); System.out.println("massage："+e.getMessage()); //继承，getMassage()，是父类中的方法。 System.out.println("string："+e); //这里自动调用函数，e==>e.toString() e.printStackTrace(); //jvm默认的异常处理机制就是调用异常对象的这个方法。 } System.out.println("结束"); } } ---------- 执行 ---------- 负数角标异常啦 massage：角标为负的啦 string：FuShuIndexException: 角标为负的啦 FuShuIndexException: 角标为负的啦 at Demo.method(InnerClassDemo2.java:14) at InnerClassDemo2.main(InnerClassDemo2.java:27) 结束

注意：一个try可以对应多个catch。多catch父类的catch放在最下面，否则编译失败。

异常处理原则 1.函数内部如果抛出需要检测的异常，那么函数上必须要声明。否则必须在函数内用try catch捕捉，否则编译失败。 2.如果调用到了声明异常的函数，要么try catch，要么throws，否则编译失败。 3.什么时候catch？什么时候throws呢？功能内部可以解决，用catch 解决不了，用throws告诉调用者，由调用者解决 4.一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性的处理。内部有几个需要检测的异常，就抛几个异常，抛出几个，就catch几个。

finally代码块一定会执行的代码。只有一种情况执行不到，即退出jvm : System.exit(0); 通常用于关闭（释放）资源。

例如：连接数据库—>查询。Exception—>关闭连接—>

try catch finally 代码块的组合特点：

1.try catch finally 2.try catch（多个）当没有必要资源需要释放时，可以不用定义finally 3.try finally 异常无法直接catch处理，但是资源需要关闭

异常的注意事项：

1.子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。 2.如果过父类抛出多个异常，那么子类只能抛出父类异常的子集。简单说：子类覆盖父类只能抛出父类的异常或子类或者子集注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try。

class A extends Exception {} class B extends A {} class C extends Exception {} class Fu { void show()throws A {} } class Zi extends Fu { void show()throws A//或者B，而不能是C，子类覆盖父类只能抛出父类的异常或子类或者子集 {} }

Object类

类object是类层次结构的根类。每个类都使用object作为超类。所有对象（包括数组）都实现这个类的方法。 object是不断抽取而来的，具备所有对象都具备的共性内容。

常用的共性内容：

（1）equals（object obj）//意味着可以比较obj下的所有类对象指示其它某个对象是否与此对象是否“相等”。

默认是比较地址

class Person extends Object { private int age; Person(int age) { this.age = age; } public } class InnerClassDemo2 { public static void main(String[] args) { Person p1 = new Person(20); Person p2 = new Person(20); Person p3 = p1; System.out.println(p1 == p2); //比较的是地址值 System.out.println(p1.equals(p3)); //比较的是地址值 } } ---------- 执行 ---------- false true

对equals进行复写，重新定义它的比较内容。这里是复写为比较年龄。

class Person extends Object { private int age; Person(int age) { this.age = age; } //比较Person的年龄，是否是同龄人。 public boolean equals(Object obj) { Person p = (Person)obj; return this.age == p.age; } } class InnerClassDemo2 { public static void main(String[] args) { Person p1 = new Person(20); Person p2 = new Person(20); Person p3 = p1; System.out.println(p1.equals(p2)); System.out.println(p1.equals(p3)); } } ---------- 执行 ---------- true true

对以上代码进行改进，因为Object类下有多个子类，若不是传入Person类就没有比较的意义，所以向下转型需要健壮性判断。对判断结果进行异常抛出

class Person extends Object { private int age; Person(int age) { this.age = age; } //比较Person的年龄，是否是同龄人。 public boolean equals(Object obj) { if(!(obj instanceof Person)) { throw new ClassCastException("类型错误");//RuntimeException的任何子类都无需再throws子句中进行声明。 } Person p = (Person)obj; return this.age == p.age; } } class Demo {} class InnerClassDemo2 { public static void main(String[] args) { Person p1 = new Person(20); Person p2 = new Person(20); Person p3 = p1; Demo d = new Demo(); System.out.println(p1.equals(d)); System.out.println(p1.equals(p3)); } } ---------- 执行 ---------- Exception in thread "main" java.lang.ClassCastException: 类型错误 at Person.equals(InnerClassDemo2.java:14) at InnerClassDemo2.main(InnerClassDemo2.java:30)

equals():比较两个对象是否相等(判断地址还有内容)。一般都会覆盖此方法，根据对象的特有内容建立判断对象是否相同的依据。

注意: 当此方法被重写时,通常有必要重写hashCode方法,以维护hashCode方法的常规协定，该协定声明相等对象必须具备相等的哈希值码。

(2) hashCode() 返回该对象的哈希码值。支持此方法是为了提高哈希表（例如 java.util.Hashtable 提供的哈希表）的性能。实际上，有Object类定义的hashCode方法确实会针对不同的对象返回不同的整数。（一般是通过将该对象的内部地址转换成一个整数来实现的，但是Java编程语言不需要这种实用技巧）。

class InnerClassDemo2 { public static void main(String[] args) { Person p1 = new Person(20); Person p2 = new Person(20); Person p3 = p1; Demo d = new Demo(); System.out.println(p1);//哈希值1 System.out.println(p1.hashCode());//哈希值2 System.out.println(Integer.toHexString(p1.hashCode()));//实际上转换为16进制字符后就是一样的数值。 } } ---------- 执行 ---------- Person@4e25154f 1311053135 4e25154f

复写哈希值方法。

class Person extends Object { private int age; Person(int age) { this.age = age; } //比较Person的年龄，是否是同龄人。 public int hashCode() { return this.age; } } class Demo {} class InnerClassDemo2 { public static void main(String[] args) { Person p1 = new Person(20); Person p2 = new Person(20); Person p3 = p1; Demo d = new Demo(); System.out.println(p1.hashCode()); } } ---------- 执行 ---------- 20

(3) getClass() 返回此Object运行时类。向上抽取的是class Class。包括抽取类名、方法、构造器等。

class Person extends Object { private int age; Person(int age) { this.age = age; } //比较Person的年龄，是否是同龄人。 } class Demo {} class InnerClassDemo2 { public static void main(String[] args) { Person p1 = new Person(20); Person p2 = new Person(2); Class clazz1 = p1.getClass(); Class clazz2 = p2.getClass(); System.out.println(clazz1==clazz2); System.out.println(clazz1.getName()); } } ---------- 执行 ---------- true Person

(4) toString() public String toString() 返回该对象的字符串表示。：getClass().getName() + ‘@’ + Integer.toHexString(hashCode()) 建议所有子类都重写此方法。

专利

最新回复(0)