Object类
Equals的基本体验(加上覆盖操作)
开始看java的Lang包资料了,里面有Object的各种方法。
Class Person extends Object
{
Private int age;
Person(int age)
{
This.age=age;
} Publlic boolean equals(Object obj) //Object obj=p2;
向上转型,就失去了子类的特有属性。所以下面会报错。所以再加一句。现在可以比较年纪了。一般都会覆盖此方法,根据对象的特有内容,建立判断对象是否相同的依据。一般都不会去直接比较地址。
{
If(!(obj instanceof Person))//为了程序的健壮性,加一个判断。Obj由person转型而来。
{
Return false;//但是这样做稍微有点不合适,猪跟人比较也可以编译通过,还是让它抛异常比较好。
Throw newClass CastException(“类型错误”);
}
Person p=(Person)obj;
Return this.age==obj.age;//在此覆盖了equals方法
}
}
Class ObjectDemo
{
Public static void main(String[] args)
{
Person p1=new Person(20);
Person p2=new Person(20);
Sop(p1==p2);
Sop(p1.equals(p2));//打印结果均为假,比较的其实只是对象的地址而已。Equal方法为了接受更多的对象,所以用object类型作为接受参数。
}
}
如果能看java的源码就更猛了,java/lang/object.java,其实最后调用的还是底层的C代码。Object类-hashCode方法(其实就是java lang包资料文档里面的)通过hashCode方法打印类名,就可以打印出哈希值。
Sop(p1);//打印结果和三一致,均是16进制。
Sop(hashCode());//打印的哈希值是10进制。
Sop(Integer.toHexString(p1.hashCode()));//又将十进制的转为16进制了。
当然也可以覆盖掉自带的hash方法。
Public int hashCode()
{
Return age;
}
判断对象是否一致:哈希值和内容都一致才能确定对象一致,比equals方法更可靠。(后期在集合框架中会进行重要的应用)
Object-getclass方法
字节码的一些东西,Class就是一个对象(系统中有的),getclass方法返回的就是这个Class类。(任意对象都是通过字节码文件而创建的。)
Getclass()就是获取当前对象的字节码文件。
Class clazz1=p1.getclass();
Class clazz2=p2.getclass();
Sop(clazz1==clazz2);//打印结果为true,字节码文件只有一份,加载进内存了。
Sop(clazz1.getname());//试试看,具体查看java.lang包
Object-toString方法
任何对象都能转化为string类型。
以下2条语句均可以打印一样的结果:
Sop(p1);
Sop(p1.getClass().getname()+”@”+Integer.toHexString(p1.hashCode()));
大多数情况会覆盖:equals、toString、getclass这三个方法。
异常(exception)
在运行时期发生的不正常的情况。
在java中用类的形式对不正常情况进行了描述和封装对象。描述不正常的情况的类,就称为异常类。以前正常流程代码和问题处理代码相结合,现在将正常流程代码和问题处理代码分离(直接抛出异常就行,不必管细节)。
其实异常就是java通过面向对象的思想将问题封装成了对象,用异常类对其进行描述。
异常体系
问题很多,描述的类也很多。将其共性向上抽取,形成了异常体系。最终问题(不正常情况)分成了2大类。
Throwable:异常体系的父类,throwable的子类对象均具备可抛性。无论是error还是异常,问题发生就应该抛出,让调用者知道并处理。该体系的特点就在于throwable及其所有的子类都具有可抛性。
1. 一般不可处理的(用error类表示)
2. 可处理的(exception)
对象需要具备可抛性,就是throwable的子类对象。可抛性是个啥玩意呢?
通过2个关键字来体现:throws throw,凡是可以被这2个关键字所操作的类和对象都具备可抛型。
Error是由JVM抛出的严重性问题,这种问题发生一般不针对性处理,因为处理不了,直接修改程序。
OutOfMemory//内存溢出问题
该体系的特点:子类的后缀名都是用其父类名作为后缀,阅读性很强。
异常-原理&异常对象的抛出throw(自己理解好了就行了)
虚拟机掉用主函数,主函数再调用method方法,method方法然后触发异常,主函数如果没有结束虚拟机无法结束。(把异常信息全部交给控制台那边去,谁调用我,我就抛异常给谁)
以前结束函数可以用return,现在异常也可以结束函数。
If(index>=arr.lengeh)
Throw new ArrayIndexOutOfBoundsException();//这个throw专门用于抛出的动作,谁调用我,就抛给谁。
可以查看ArrayIndexOutOfBoundsException的相关参数和方法(具体可以查看java.lang包里面)可以虚拟机自动抛出异常,当然也可以你人为自动去写抛出异常。异常一般都带着消息,而且消息可以自己定义。
异常-自定义异常&异常类的抛出throws
对于角标是整数不存在,可以用角标越界来表示。对于角标为负数的情况,准备用负数角标异常来表示。对于负数角标这种异常,java中并没有定义过。那就按照java异常的创建思想,将负数角标进行自定义描述。并封装成对象。这种自定义的问题描述称为自定义异常。
注意:如果一个类称之为异常类,必须要继承异常体系,因为只有称之为异常体系的子类才有资格具备可抛型。才可以被2个关键字所操作。Throws,throw
凡是编译器如果出现未报告的,说明编译器语法错误就进行到了最后一步了。
编译的时候:要么捕捉要么抛。
2个区别:
1. 异常(编译时和运行时)
异常的分类:
(1)编译时被检测的异常:只要是Exception和其子类都是,除了特殊子类RuntimeException体系。(这种问题一旦出现,希望在编译时就被检测,让这种问题有对应的处理方式)这样的问题都可以针对性处理。
(2)编译时不检测异常(运行时异常):就是Exception中的RuntimeException和其子类。
这种问题的发生,无法让功能继续,运算无法进行,更多是因为调用者的原因导致的。当然也有可能是内部导致的。那么这种问题一般不处理,直接编译通过,在运行时,让调用者调用的程序强制停止,让调用者对代码进行修正。
Error都让虚拟机崩了,就不叫异常了。而RuntimeException是在虚拟机正常运行期间抛出的异常。还是有区别的。
所以自定义异常时,要么继承Exception,要么继承RuntimeException。
Throw和throws的区别
1. Throws使用在函数上,throw使用在函数内。
2. Throws抛出的是异常类,可以抛出多个,用逗号隔开。Throw抛出的是异常对象,只能抛出一个,因为抛出一个函数就已经结束了,也就意味着函数出栈了,往下一个函数走。
异常捕捉
异常处理的捕捉形式:
这是可以对异常进行针对性处理的方式。具体格式是:
Try
{
//需要被检测异常的代码
}
Catch(异常类 变量) //该变量用于接收当前发生异常的对象
{
//处理异常的代码
}
Finally
{
//一定会执行的代码
}
什么时候try,什么时候throw?(内部可以处理就catch,不能处理就抛,告诉调用者,由调用者去解决问题)
Catch方法里面:(可以通过调用API指挥接收到的异常对象里面的方法来做事情)E.getMessage、e.toString等方法(了解下即可) 多catch情况(也就是throws需要抛多个异常的时候,中间有逗号隔开。就相当于一个try然而多个catch)当多catch情况当中,存在有父类catch情况的时候,一定要把父类catch的情况放在最下面,否则编译失败。。
Catch(NullPointerException e)
{
Sop(e.toString());
}
Catch(FuShuIndexException e);
{
Sop(“message”+e.getMessage());
Sop(“string”+e.toString());
E.printStackTrace();//Jvm默认的异常处理机制就是调用异常对象这个方法。
Sop(“负数角标异常!!!”);
}
Catch(Exception e) //如果放在这里则会编译报错
{
}
异常处理的原则:
1. 要么throws,throw要么try,catch,否则编译失败
2. 如果调用到了声明异常的函数,要么try catch 要么throws,否则编译失败。
3. 什么时候try,catch,什么时候throws,throw?
功能内容可以解决,用catch。解决不了,用throws告诉调用者,由调用者解决。
4. 一个功能如果抛出了多个异常,那么调用时必须对应多个catch进行针对性处理。
Finally代码块
正常情况下:
Class ExceptionDemo5
{
Public static void main(String[] args)
{
Demo d=new Demo();
Try
{
Int num=d.show(1);//此时在show方法里面没有问题,属于正常情况
Sop(“num”+=num)
}
Catch(ArrayIndexOutOfBoundsException e)
{
Sop(e.toString());
Return;//若在这里加上return,over就不打印,return直接导致主函数结束。Over那条语句本身就属于主函数接下来要执行的语句。
System.exit(0);//退出JVM,finally代码块也不执行。(一个特例)
}
Finally
{
Sop(“finally”);
}
Sop(“over”);
}
此时打印结果为:num=0;fially over
上述若改为d.show(-1),打印结果为 ArrayIndexOfBoundsException:越界啦!!(出现异常) finally over
}
查询百度的过程:连接数据库—查询—关闭连接
Finally//通常用于关闭(释放)资源。(凡是资源要关闭都把相应的代码往finally里面放)
Try catch finally代码块组合特点:
1. try catch finally
2. Try catch(多个) 当没有必要资源需要释放时,可以不用定义finally
3. Try finally(异常无法直接catch处理,但是资源需要关闭)
Void show() throws Exception
{
Throw new Exception();
}
或者
Void show() throws Exception//还是要声明throws,因为里面没有catch没有处理。
{
Try
{ //开启资源
Throw new Exception();
}
Finally
{
//关闭资源
}
}
异常应用
异常的注意事项
1. 子类在覆盖父类方法时,父类的方法如果抛出了异常,那么子类的方法只能够抛出父类的异常或者该异常的子类。
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 //也可以throws B ,但是不能throws C,当然也可以不抛出。
{
}
}
2. 如果父类抛出多个异常,那么子类只能抛出父类异常的子集。简单说:子类覆盖父类只能抛出父类的异常或者子类或者子集。
注意:如果父类的方法没有抛出异常,那么子类覆盖时绝对不能抛。但是可以try,catch
Interface Inter
{
Void function();
}
Class D implements Inter//这样写就会编译报错,父类没有抛异常,子类也不能抛。
{
Public void function() throws Exception
{
}
}
异常的应用没怎么看,自己需要去练手。(以后感兴趣可以去看看)

本文探讨了Java中对象比较的实现方式,包括equals方法的重写及hashCode的作用,并深入讲解了异常处理机制,如异常的抛出、捕捉与自定义。
&spm=1001.2101.3001.5002&articleId=80817660&d=1&t=3&u=5604d91051d34df49c0393b1ac73d480)
2756

被折叠的 条评论
为什么被折叠?



