java的细节.docx

1、java的细节Java作为一门优秀的面向对象的程序设计语言,正在被越来越多的人使用。本文试图列出作者在实际开发中碰到的一些Java语言的容易被人忽视的细节,希望能给正在学习Java语言的人有所帮助。 1，位移运算越界怎么处理 考察下面的代码输出结果是多少? int a=5; System.out.println(a33); 按照常理推测,把a左移33位应该将a的所有有效位都移出去了，那剩下的都是零啊，所以输出结果应该是0才对啊，可是执行后发现输出结果是10，为什么呢？因为Java语言对位移运算作了优化处理，Java语言对ab转化为a(b%32)来处理，所以当要移位的位数b超过32时，实际上移位

2、的位数是b%32的值，那么上面的代码中a33相当于a1，所以输出结果是10。 2，可以让i!=i吗？ 当你看到这个命题的时候一定会以为我疯了，或者Java语言疯了。这看起来是绝对不可能的，一个数怎么可能不等于它自己呢？或许就真的是Java语言疯了，不信看下面的代码输出什么？ double i=0.0/0.0; if(i=i) System.out.println(Yes i=i); else System.out.println(No i!=i); 上面的代码输出No i!=i，为什么会这样呢？关键在0.0/0.0这个值，在IEEE 754浮点算术规则里保留了一个特殊的值用来表示一个不是数字的

3、数量。这个值就是NaN(Not a Number的缩写)，对于所有没有良好定义的浮点计算都将得到这个值，比如：0.0/0.0；其实我们还可以直接使用Double.NaN来得到这个值。在IEEE 754规范里面规定NaN不等于任何值，包括它自己。所以就有了i！=i的代码。 3，怎样的equals才安全？ 我们都知道在Java规范里定义了equals方法覆盖的5大原则：reflexive（反身性），symmetric（对称性），transitive（传递性），consistent（一致性），non-null（非空性）。那么考察下面的代码： public class Student private

4、String name; private int age; public Student(String name,int age) this.name=name; this.age=age; public boolean equals(Object obj) if(obj instanceof Student) Student s=(Student)obj; if(s.name.equals(this.name) & s.age=this.age) return true; return super.equals(obj); 你认为上面的代码equals方法的覆盖安全吗？表面看起来好像没什么问

5、题，这样写也确实满足了以上的五大原则。但其实这样的覆盖并不很安全，假如Student类还有一个子类CollegeStudent,如果我拿一个Student对象和一个CollegeStudent对象equals,只要这两个对象有相同的name和age，它们就会被认为相等，但实际上它们是两个不同类型的对象啊。问题就出在instanceof这个运算符上，因为这个运算符是向下兼容的，也就是说一个CollegeStudent对象也被认为是一个Student的实例。怎样去解决这个问题呢？那就只有不用instanceof运算符，而使用对象的getClass()方法来判断两个对象是否属于同一种类型，例如，将上

6、面的equals()方法修改为： public boolean equals(Object obj) if(obj.getClass()=Student.class) Student s=(Student)obj; if(s.name.equals(this.name) & s.age=this.age) return true; return super.equals(obj); 这样才能保证obj对象一定是Student的实例，而不会是Student的任何子类的实例。4，浅复制与深复制1）浅复制与深复制概念浅复制（浅克隆）被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的

7、引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。深复制（深克隆）被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。2）Java的clone（）方法clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：对任何的对象x，都有x.clone() !=x/克隆对象与原对象不是同一个对象对任何的对象x，都有x.clone().getClass()= =x.getClass()/克隆对象与

8、原对象的类型一样如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。Java中对象的克隆为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。在派生类中覆盖基类的clone()方法，并声明为public。在派生类的clone()方法中，调用super.clone()。在派生类中实现Cloneable接口。请看如下代码：class Student implements Cloneable String name; int age; Student(String name,int age) this.name=name; this.age

9、=age; public Object clone() Object obj=null; try obj=(Student)super.clone(); /Object中的clone()识别出你要复制的是哪一个对象。 catch(CloneNotSupportedException e) e.printStackTrace(); return obj; public static void main(String args) Student s1=new Student(zhangsan,18); Student s2=(Student)s1.clone(); s2.name=lisi; s2

10、.age=20; System.out.println(name=+s1.name+,+age=+s1.age);/修改学生2 /后，不影响学生1的值。 说明：为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。继承自java.lang.Object类的clone()方法是浅复制。以下代码可以证明之。class Teacher String name; int age; Teacher(St

11、ring name,int age) this.name=name; this.age=age; class Student implements Cloneable String name; int age; Teacher t;/学生1和学生2的引用值都是一样的。 Student(String name,int age,Teacher t) this.name=name; this.age=age; this.t=t; public Object clone() Student stu=null; try stu=(Student)super.clone(); catch(CloneNot

12、SupportedException e) e.printStackTrace(); stu.t=(Teacher)t.clone(); return stu; public static void main(String args) Teacher t=new Teacher(tangliang,30); Student s1=new Student(zhangsan,18,t); Student s2=(Student)s1.clone(); s2.t.name=tony; s2.t.age=40; System.out.println(name=+s1.t.name+,+age=+s1.

13、t.age); /学生1的老师成为tony,age为40。 那应该如何实现深层次的克隆，即修改s2的老师不会影响s1的老师？代码改进如下。class Teacher implements Cloneable String name; int age; Teacher(String name,int age) this.name=name; this.age=age; public Object clone() Object obj=null; try obj=super.clone(); catch(CloneNotSupportedException e) e.printStackTrace

14、(); return obj; class Student implements Cloneable String name; int age; Teacher t; Student(String name,int age,Teacher t) this.name=name; this.age=age; this.t=t; public Object clone() Student stu=null; try stu=(Student)super.clone(); catch(CloneNotSupportedException e) e.printStackTrace(); stu.t=(T

15、eacher)t.clone(); return stu; public static void main(String args) Teacher t=new Teacher(tangliang,30); Student s1=new Student(zhangsan,18,t); Student s2=(Student)s1.clone(); s2.t.name=tony; s2.t.age=40; System.out.println(name=+s1.t.name+,+age=+s1.t.age); /学生1的老师不改变。3）利用串行化来做深复制 把对象写到流里的过程是串行化（Seri

16、lization）过程，Java程序员又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做“解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。 在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。如下为深复制源代码。public Object de

17、epClone()/将对象写到流里ByteArrayOutoutStream bo=new ByteArrayOutputStream();ObjectOutputStream oo=new ObjectOutputStream(bo);oo.writeObject(this);/从流里读出来ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray();ObjectInputStream oi=new ObjectInputStream(bi);return(oi.readObject();这样做的前提是对象以及对象内部所有

18、引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。上例代码改进如下。class Teacher implements Serializable String name; int age; Teacher(String name,int age) this.name=name; this.age=age; class Student implements Serializable String name;/常量对象。 int age; Teacher t;/学生1和学生2的引用值都是一样的。 Student(String

19、name,int age,Teacher t) this.name=name; this.age=age; this.p=p; public Object deepClone() throws IOException,OptionalDataException,ClassNotFoundException/将对象写到流里ByteArrayOutoutStream bo=new ByteArrayOutputStream();ObjectOutputStream oo=new ObjectOutputStream(bo);oo.writeObject(this);/从流里读出来ByteArray

20、InputStream bi=new ByteArrayInputStream(bo.toByteArray();ObjectInputStream oi=new ObjectInputStream(bi);return(oi.readObject();public static void main(String args) Teacher t=new Teacher(tangliang,30); Student s1=new Student(zhangsan,18,t); Student s2=(Student)s1.deepClone(); s2.t.name=tony; s2.t.age

21、=40; System.out.println(name=+s1.t.name+,+age=+s1.t.age); /学生1的老师不改变。5，String类和对象池 我们知道得到String对象有两种办法： String str1=hello; String str2=new String(hello); 这两种创建String对象的方法有什么差异吗？当然有差异，差异就在于第一种方法在对象池中拿对象，第二种方法直接生成新的对象。在JDK5.0里面，Java虚拟机在启动的时候会实例化9个对象池，这9个对象池分别用来存储8种基本类型的包装类对象和String对象。当我们在程序中直接用双引号括起来一

22、个字符串时，JVM就到String的对象池里面去找看是否有一个值相同的对象，如果有，就拿现成的对象，如果没有就在对象池里面创建一个对象，并返回。所以我们发现下面的代码输出true： String str1=hello; String str2=hello; System.out.println(str1=str2); 这说明str1和str2指向同一个对象，因为它们都是在对象池中拿到的，而下面的代码输出为false: String str3=hello String str4=new String(hello); System.out.println(str3=str4); 因为在任何情况下，

23、只要你去new一个String对象那都是创建了新的对象。与此类似的，在JDK5.0里面8种基本类型的包装类也有这样的差异： Integer i1=5;/在对象池中拿 Integer i2 =5;/所以i1=i2 Integer i3=new Integer(5);/重新创建新对象，所以i2!=i3 对象池的存在是为了避免频繁的创建和销毁对象而影响系统性能，那我们自己写的类是否也可以使用对象池呢？当然可以，考察以下代码： class Student private String name; private int age; private static HashSet pool=new Hash

24、Set();/对象池 public Student(String name,int age) this.name=name; this.age=age; /使用对象池来得到对象的方法 public static Student newInstance(String name,int age) /循环遍历对象池 for(Student stu:pool) if(stu.name.equals(name) & stu.age=age) return stu; /如果找不到值相同的Student对象，则创建一个Student对象 /并把它加到对象池中然后返回该对象。 Student stu=new

25、Student(name,age); pool.add(stu); return stu; public class Test public static void main(String args) Student stu1=Student.newInstance(tangliang,30);/对象池中拿 Student stu2=Student.newInstance(tangliang,30);/所以stu1=stu2 Student stu3=new Student(tangliang,30);/重新创建，所以stu1!=stu3 System.out.println(stu1=stu

26、2); System.out.println(stu1=stu3); 6 i=i+1和i+=1完全等价吗？ 可能有很多程序员认为i+=1只是i=i+1的简写方式，其实不然，它们一个使用简单赋值运算，一个使用复合赋值运算，而简单赋值运算和复合赋值运算的最大差别就在于：复合赋值运算符会自动地将运算结果转型为其左操作数的类型。看看以下的两种写法，你就知道它们的差别在哪儿了： (1) byte i=5; i+=1; (2) byte i=5; i=i+1; 第一种写法编译没问题，而第二种写法却编译通不过。原因就在于，当使用复合赋值运算符进行操作时，即使右边算出的结果是int类型，系统也会将其值转化为左边的byte类型，而使用简单赋值运算时没有这样的优待，系统会认为将i+1的值赋给i是将int类型赋给byte，所以要求强制转换。理解了这一点后，我们再来看一个例子： byte b=120; b+=20; System.out.println(b=+b); 说到这里你应该明白了，上例中输出b的值不是140，而是-116。因为120+20的值已经超出了一个byte表示的范围，而当我们使用复合赋值运算时系统会自动作类型的转化，将140强转成byte，所以得到是-116。由此可见，在使用复合赋值运算符时还得小心，因为这种类型转换是在不知不觉中进行的，所以得到的结果就有可能和你的预想不一样。