Java语言的26个细节仔细看.docx
- 文档编号:5919510
- 上传时间:2023-01-02
- 格式:DOCX
- 页数:12
- 大小:22.34KB
Java语言的26个细节仔细看.docx
《Java语言的26个细节仔细看.docx》由会员分享,可在线阅读,更多相关《Java语言的26个细节仔细看.docx(12页珍藏版)》请在冰豆网上搜索。
Java语言的26个细节仔细看
Java语言的26个细节
Java作为一门优秀的面向对象的程序设计语言,正在被越来越多的人使用。
本文试图列出作者在实际开发中碰到的一些Java语言的容易被人忽视的细节,希望能给正在学习Java语言的人有所帮助。
1,位移运算越界怎么处理
考察下面的代码输出结果是多少?
inta=5;
System.out.println(a<<33);
按照常理推测,把a左移33位应该将a的所有有效位都移出去了,那剩下的都是零啊,所以输出结果应该是0才对啊,可是执行后发现输出结果是10,为什么呢?
因为Java语言对位移运算作了优化处理,Java语言对a<
2,可以让i!
=i吗?
当你看到这个命题的时候一定会以为我疯了,或者Java语言疯了。
这看起来是绝对不可能的,一个数怎么可能不等于它自己呢?
或许就真的是Java语言疯了,不信看下面的代码输出什么?
doublei=0.0/0.0;
if(i==i){
System.out.println("Yesi==i");
}else{
System.out.println("Noi!
=i");
}
上面的代码输出"Noi!
=i",为什么会这样呢?
关键在0.0/0.0这个值,在IEEE754浮点算术规则里保留了一个特殊的值用来表示一个不是数字的数量。
这个值就是NaN("NotaNumber"的缩写),对于所有没有良好定义的浮点计算都将得到这个值,比如:
0.0/0.0;其实我们还可以直接使用Double.NaN来得到这个值。
在IEEE754规范里面规定NaN不等于任何值,包括它自己。
所以就有了i!
=i的代码。
3,怎样的equals才安全?
我们都知道在Java规范里定义了equals方法覆盖的5大原则:
reflexive(反身性),symmetric(对称性),transitive(传递性),consistent(一致性),non-null(非空性)。
那么考察下面的代码:
publicclassStudent{
privateStringname;
privateintage;
publicStudent(Stringname,intage){
this.name=name;
this.age=age;
}
publicbooleanequals(Objectobj){
if(objinstanceofStudent){
Students=(Student)obj;
if(s.name.equals(this.name)&&s.age==this.age){
returntrue;
}
}
returnsuper.equals(obj);
}
}
你认为上面的代码equals方法的覆盖安全吗?
表面看起来好像没什么问题,这样写也确实满足了以上的五大原则。
但其实这样的覆盖并不很安全,假如Student类还有一个子类CollegeStudent,如果我拿一个Student对象和一个CollegeStudent对象equals,只要这两个对象有相同的name和age,它们就会被认为相等,但实际上它们是两个不同类型的对象啊。
问题就出在instanceof这个运算符上,因为这个运算符是向下兼容的,也就是说一个CollegeStudent对象也被认为是一个Student的实例。
怎样去解决这个问题呢?
那就只有不用instanceof运算符,而使用对象的getClass()方法来判断两个对象是否属于同一种类型,例如,将上面的equals()方法修改为:
publicbooleanequals(Objectobj){
if(obj.getClass()==Student.class){
Students=(Student)obj;
if(s.name.equals(this.name)&&s.age==this.age){
returntrue;
}
}
returnsuper.equals(obj);
}
这样才能保证obj对象一定是Student的实例,而不会是Student的任何子类的实例。
4,浅复制与深复制
1)浅复制与深复制概念
⑴浅复制(浅克隆)
被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。
换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。
⑵深复制(深克隆)
被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。
那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。
换言之,深复制把要复制的对象所引用的对象都复制了一遍。
2)Java的clone()方法
⑴clone方法将对象复制了一份并返回给调用者。
一般而言,clone()方法满足:
①对任何的对象x,都有x.clone()!
=x//克隆对象与原对象不是同一个对象
②对任何的对象x,都有x.clone().getClass()==x.getClass()//克隆对象与原对象的类型一样
③如果对象x的equals()方法定义恰当,那么x.clone().equals(x)应该成立。
⑵Java中对象的克隆
①为了获取对象的一份拷贝,我们可以利用Object类的clone()方法。
②在派生类中覆盖基类的clone()方法,并声明为public。
③在派生类的clone()方法中,调用super.clone()。
④在派生类中实现Cloneable接口。
请看如下代码:
classStudentimplementsCloneable{
Stringname;
intage;
Student(Stringname,intage){
this.name=name;
this.age=age;
}
publicObjectclone(){
Objectobj=null;
try{
obj=(Student)super.clone();
//Object中的clone()识别出你要复制的是哪一个对象。
}
catch(CloneNotSupportedExceptione){
e.printStackTrace();
}
returnobj;
}
}
publicstaticvoidmain(String[]args){
Students1=newStudent("zhangsan",18);
Students2=(Student)s1.clone();
s2.name="lisi";
s2.age=20;
System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2
//后,不影响学生1的值。
}
说明:
①为什么我们在派生类中覆盖Object的clone()方法时,一定要调用super.clone()呢?
在运行时刻,Object中的clone()识别出你要复制的是哪一个对象,然后为此对象分配空间,并进行对象的复制,将原始对象的内容一一复制到新对象的存储空间中。
②继承自java.lang.Object类的clone()方法是浅复制。
以下代码可以证明之。
classTeacher{
Stringname;
intage;
Teacher(Stringname,intage){
this.name=name;
this.age=age;
}
}
classStudentimplementsCloneable{
Stringname;
intage;
Teachert;//学生1和学生2的引用值都是一样的。
Student(Stringname,intage,Teachert){
this.name=name;
this.age=age;
this.t=t;
}
publicObjectclone(){
Studentstu=null;
try{
stu=(Student)super.clone();
}catch(CloneNotSupportedExceptione){
e.printStackTrace();
}
stu.t=(Teacher)t.clone();
returnstu;
}
publicstaticvoidmain(String[]args){
Teachert=newTeacher("tangliang",30);
Students1=newStudent("zhangsan",18,t);
Students2=(Student)s1.clone();
s2.t.name="tony";
s2.t.age=40;
System.out.println("name="+s1.t.name+","+"age="+s1.t.age);
//学生1的老师成为tony,age为40。
}
}
那应该如何实现深层次的克隆,即修改s2的老师不会影响s1的老师?
代码改进如下。
classTeacherimplementsCloneable{
Stringname;
intage;
Teacher(Stringname,intage){
this.name=name;
this.age=age;
}
publicObjectclone(){
Objectobj=null;
try{
obj=super.clone();
}catch(CloneNotSupportedExceptione){
e.printStackTrace();
}
returnobj;
}
}
classStudentimplementsCloneable{
Stringname;
intage;
Teachert;
Student(Stringname,intage,Teachert){
this.name=name;
this.age=age;
this.t=t;
}
publicObjectclone(){
Studentstu=null;
try{
stu=(Student)super.clone();
}catch(CloneNotSupportedExceptione){
e.printStackTrace();
}
stu.t=(Teacher)t.clone();
returnstu;
}
}
publicstaticvoidmain(String[]args){
Teachert=newTeacher("tangliang",30);
Students1=newStudent("zhangsan",18,t);
Students2=(Student)s1.clone();
s2.t.name="tony";
s2.t.age=40;
System.out.println("name="+s1.t.name+","+"age="+s1.t.age);
//学生1的老师不改变。
}
3)利用串行化来做深复制
把对象写到流里的过程是串行化(Serilization)过程,Java程序员又非常形象地称为“冷冻”或者“腌咸菜(picking)”过程;而把对象从流中读出来的并行化(Deserialization)过程则叫做“解冻”或者“回鲜(depicking)”过程。
应当指出的是,写在流里的是对象的一个拷贝,而原对象仍然存在于JVM里面,因此“腌成咸菜”的只是对象的一个拷贝,Java咸菜还可以回鲜。
在Java语言里深复制一个对象,常常可以先使对象实现Serializable接口,然后把对象(实际上只是对象的一个拷贝)写到一个流里(腌成咸菜),再从流里读出来(把咸菜回鲜),便可以重建对象。
如下为深复制源代码。
publicObjectdeepClone(){
//将对象写到流里
ByteArrayOutoutStreambo=newByteArrayOutputStream();
ObjectOutputStreamoo=newObjectOutputStream(bo);
oo.writeObject(this);
//从流里读出来
ByteArrayInputStreambi=newByteArrayInputStream(bo.toByteArray());
ObjectInputStreamoi=newObjectInputStream(bi);
return(oi.readObject());
}
这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的,否则,就需要仔细考察那些不可串行化的对象可否设成transient,从而将之排除在复制过程之外。
上例代码改进如下。
classTeacherimplementsSerializable{
Stringname;
intage;
Teacher(Stringname,intage){
this.name=name;
this.age=age;
}
}
classStudentimplementsSerializable
{
Stringname;//常量对象。
intage;
Teachert;//学生1和学生2的引用值都是一样的。
Student(Stringname,intage,Teachert){
this.name=name;
this.age=age;
this.p=p;
}
publicObjectdeepClone()throwsIOException,
OptionalDataException,ClassNotFoundException
{
//将对象写到流里
ByteArrayOutoutStreambo=newByteArrayOutputStream();
ObjectOutputStreamoo=newObjectOutputStream(bo);
oo.writeObject(this);
//从流里读出来
ByteArrayInputStreambi=newByteArrayInputStream(bo.toByteArray());
ObjectInputStreamoi=newObjectInputStream(bi);
return(oi.readObject());
}
}
publicstaticvoidmain(String[]args){
Teachert=newTeacher("tangliang",30);
Students1=newStudent("zhangsan",18,t);
Students2=(Student)s1.deepClone();
s2.t.name="tony";
s2.t.age=40;
System.out.println("name="+s1.t.name+","+"age="+s1.t.age);
//学生1的老师不改变。
}
5,String类和对象池
我们知道得到String对象有两种办法:
Stringstr1="hello";Stringstr2=newString("hello");这两种创建String对象的方法有什么差异吗?
当然有差异,差异就在于第一种方法在对象池中拿对象,第二种方法直接生成新的对象。
在JDK5.0里面,Java虚拟机在启动的时候会实例化9个对象池,这9个对象池分别用来存储8种基本类型的包装类对象和String对象。
当我们在程序中直接用双引号括起来一个字符串时,JVM就到String的对象池里面去找看是否有一个值相同的对象,如果有,就拿现成的对象,如果没有就在对象池里面创建一个对象,并返回。
所以我们发现下面的代码输出true:
Stringstr1="hello";Stringstr2="hello";System.out.println(str1==str2);这说明str1和str2指向同一个对象,因为它们都是在对象池中拿到的,而下面的代码输出为false:
Stringstr3="hello"Stringstr4=newString("hello");System.out.println(str3==str4);因为在任何情况下,只要你去new一个String对象那都是创建了新的对象。
与此类似的,在JDK5.0里面8种基本类型的包装类也有这样的差异:
Integeri1=5;//在对象池中拿Integeri2=5;//所以i1==i2Integeri3=newInteger(5);//重新创建新对象,所以i2!
=i3对象池的存在是为了避免频繁的创建和销毁对象而影响系统性能,那我们自己写的类是否也可以使用对象池呢?
当然可以,考察以下代码:
classStudent{privateStringname;privateintage;privatestaticHashSetpool=newHashSet();//对象池publicStudent(Stringname,intage){this.name=name;this.age=age;}//使用对象池来得到对象的方法publicstaticStudentnewInstance(Stringname,intage){//循环遍历对象池for(Studentstu:
pool){if(stu.name.equals(name)&&stu.age==age){returnstu;}}//如果找不到值相同的Student对象,则创建一个Student对象//并把它加到对象池中然后返回该对象。
Studentstu=newStudent(name,age);pool.add(stu);returnstu;}}publicclassTest{publicstaticvoidmain(String[]args){Studentstu1=Student.newInstance("tangliang",30);//对象池中拿Studentstu2=Student.newInstance("tangliang",30);//所以stu1==stu2Studentstu3=newStudent("tangliang",30);//重新创建,所以stu1!
=stu3System.out.println(stu1==stu2);System.out.println(stu1==stu3);}}
6,2.0-1.1==0.9吗?
考察下面的代码:
doublea=2.0,b=1.1,c=0.9;if(a-b==c){System.out.println("YES!
");}else{System.out.println("NO!
");}以上代码输出的结果是多少呢?
你认为是“YES!
”吗?
那么,很遗憾的告诉你,不对,Java语言再一次cheat了你,以上代码会输出“NO!
”。
为什么会这样呢?
其实这是由实型数据的存储方式决定的。
我们知道实型数据在内存空间中是近似存储的,所以2.0-1.1的结果不是0.9,而是0.88888888889。
所以在做实型数据是否相等的判断时要非常的谨慎。
一般来说,我们不建议在代码中直接判断两个实型数据是否相等,如果一定要比较是否相等的话我们也采用以下方式来判断:
if(Math.abs(a-b)<1e-5){//相等}else{//不相等}上面的代码判断a与b之差的绝对值是否小于一个足够小的数字,如果是,则认为a与b相等,否则,不相等。
7,判断奇数
以下的方法判断某个整数是否是奇数,考察是否正确:
publicbooleanisOdd(intn){return(n%2==1);}很多人认为上面的代码没问题,但实际上这段代码隐藏着一个非常大的BUG,当n的值是正整数时,以上的代码能够得到正确结果,但当n的值是负整数时,以上方法不能做出正确判断。
例如,当n=-3时,以上方法返回false。
因为根据Java语言规范的定义,Java语言里的求余运算符(%)得到的结果与运算符左边的值符号相同,所以,-3%2的结果是-1,而不是1。
那么上面的方法正确的写法应该是:
publicbooleanisOdd(intn){return(n%2!
=0);}
8,拓宽数值类型会造成精度丢失吗?
Java语言的8种基本数据类型中7种都可以看作是数值类型,我们知道对于数值类型的转换有一个规律:
从窄范围转化成宽范围能够自动类型转换,反之则必须强制转换。
请看下图:
byte-->short-->int-->long-->float-->doublechar-->int我们把顺箭头方向的转化叫做拓宽类型,逆箭头方向的转化叫做窄化类型。
一般我们认为因为顺箭头方向的转化不会有数据和精度的丢失,所以Java语言允许自动转化,而逆箭头方向的转化可能会造成数据和精度的丢失,所以Java语言要求程序员在程序中明确这种转化,也就是强制转换。
那么拓宽类型就一定不会造成数据和精度丢失吗?
请看下面代码:
inti=2000000000;intnum=0;for(floatf=i;f
9,i=i+1和i+=1完全等价吗?
可能有很多程序员认为i+=1只是i=i+1的简写方式,其实不然,它们一个使用简单赋值运算,一个使用复合赋值运算,而简单赋值运算和复合赋值运算的最大差别就在于:
复合赋值运算符会自动地将运算结果转型为其左操作数的类型。
看看以下的两种写法,你就知道它们的差别在哪儿了:
(1)bytei=5;
i+=1;
(2)bytei=5;
i=i+1;
第一种写法编译没问题,而第二种写法却编译通不过。
原因就在于,当使用复合赋值运算符进行操作时,即使右边算出的结果是int类型,系统也会将其值转化为左边的byte类型,而使用简单赋值运算时没有这样的优待,系统会认为将i+1的值赋给i是将int类型赋给byte,所以要求强制转换。
理解了这一点后,我们再来看一个例子:
byteb=120;
b+=20;
System.out.println("b="+b);
说到这里你应该明白了,上例中输出b的值不是140,而是-116。
因为120+20的值已经超出了一个byte表示的范围,而当我们使用复合赋值运算时系统会自动作类型的转化,将140强转成byte,所以得到是-116。
由此可见,
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- Java 语言 26 细节 仔细