欧美jjzz,精品乱码一区二区三区,成人国产一区二区

yuxh — Tue, 02 Jun 2015 02:27:00 GMT

新电脑装上eclipse4.4.2�Q�导入maven��目之后�Q�依赖库��L��有很多错误。最后搜索到可能是eclipse的bug�Q�据说是

JAVA_HOME没有正确传�?/code>�Q�，查看到eclipse默认的是安装的jre目录�Q�修改到jdk目录下，依赖问题解决�?br />不过目前版本仍然没有解决pom文�g�?#8220;Plugin execution not covered by lifecycle configuration”错误�Q�暂时忽略不���吧�?img src ="http://www.aygfsteel.com/yuxh/aggbug/425441.html" width = "1" height = "1" />

yuxh 2015-06-02 10:27 发表评论



yuxh — Thu, 31 May 2012 03:23:00 GMT
本打�����承一个API中的Parent�c�（Parent�l�承自GrandParent�c�）�Q�重写其中的service�Ҏ���Q�copy了Parent的service�Ҏ��。不�q�发现Parent的service中也有super.service�Ҏ��。当时考虑直接调用GrandParent的service�Ҏ��。。。未遂（包括反射也不行）。正好看到老外写的一���文章，���译�Q?br />在Son�c�里面写一个test�Ҏ���Q?br /> public void test() {
 super.test();
 this.test();
}
反编译之后：
public void test()
    {
    //    0    0:aload_0         
    //    1    1:invokespecial   #2   
    //    2    4:aload_0         
    //    3    5:invokevirtual   #3   
    //    4    8:return          
    }
使用ASM可以完成对GrandParent�Ҏ��的调�?br />public class GrandParent {
    public void test() {
            System.out.println("test of GrandParent");
    }
}

public class Parent extends GrandParent{
    public void test() {
        System.out.println("test of Parent");
    }
}

public class Son extends Parent{
    public void test() {
        System.out.println("test of Son");
    }
}
调用Son实例的test�Ҏ��只会执行Son的test�Ҏ��。而ASM可以修改class�Q�先写一个Example�cȝ��承Son�Q�重写test�Ҏ��

 1 import java.io.FileOutputStream;
 2  
 3 import org.objectweb.asm.ClassWriter;
 4 import org.objectweb.asm.MethodVisitor;
 5 import org.objectweb.asm.Opcodes;
 6  
 7 public class ASMByteCodeManipulation extends ClassLoader implements Opcodes {
 8  
 9  public static void main(String args[]) throws Exception {
10   ClassWriter cw = new ClassWriter(0);
11   cw.visit(V1_1, ACC_PUBLIC, "Example", null, "Son", null);
12  
13   // creates a MethodWriter for the (implicit) constructor
14   MethodVisitor mw = cw.visitMethod(ACC_PUBLIC, "", "()V", null,null);
15   mw.visitVarInsn(ALOAD, 0);
16   mw.visitMethodInsn(INVOKESPECIAL, "Son", "", "()V");
17   mw.visitInsn(RETURN);
18   mw.visitMaxs(1, 1);
19   mw.visitEnd();
20  
21   // creates a MethodWriter for the 'test' method
22   mw = cw.visitMethod(ACC_PUBLIC, "test", "()V", null, null);
23   mw.visitFieldInsn(GETSTATIC, "java/lang/System", "out","Ljava/io/PrintStream;");
24   mw.visitLdcInsn("test of AI3");
25   mw.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println",
26     "(Ljava/lang/String;)V");
27   //Call test() of GrandParent
28   mw.visitVarInsn(ALOAD, 0);
29   mw.visitMethodInsn(INVOKESPECIAL, "GrandParent", "test", "()V");
30   //Call test() of GrandParent
31   mw.visitVarInsn(ALOAD, 0);
32   mw.visitMethodInsn(INVOKESPECIAL, "Parent", "test", "()V");
33   //Call test() of GrandParent
34   mw.visitVarInsn(ALOAD, 0);
35   mw.visitMethodInsn(INVOKESPECIAL, "Son", "test", "()V");
36   mw.visitInsn(RETURN);
37   mw.visitMaxs(2, 1);
38   mw.visitEnd();
39  
40   byte[] code = cw.toByteArray();
41   FileOutputStream fos = new FileOutputStream("Example.class");
42   fos.write(code);
43   fos.close();
44  
45   ASMByteCodeManipulation loader = new ASMByteCodeManipulation();
46   Class exampleClass = loader.defineClass("Example", code, 0,
47     code.length);
48   Object obj = exampleClass.newInstance();
49   exampleClass.getMethod("test", null).invoke(obj, null);
50  
51  }
52 }
输出�Q?br />test of AI3
test of GrandParent
test of Parent
test of Son
看看怎样实现的，11行定义一个新的类Example�l�承Son�?2行，Example重写test�Ҏ���Q�先打印“test of  AI3”�Q�再分别�?9�?2�?5行调�?span style="color: #000000; ">GrandParent、Parent、Son的test�Ҏ���?/span>
 main�Ҏ��中，45行创建Example的实例，再用反射调他的test�Ҏ���?br />使用invokespecial�q�种方式也有局限，只能从子�c�调用。否则报错：Exception in thread "main" java.lang.VerifyError: (class: Example,  method: test1 signature: (LAI2;)V) Illegal use of nonvirtual function  call


yuxh 2012-05-31 11:23 发表评论


Java时区处理
yuxh — Thu, 15 Mar 2012 15:08:00 GMT
通用协调�?UTC, Universal Time Coordinated)�Q�格林尼��d�^均时(GMT, Greenwich Mean Time) �׃��历史原因�Q�这两个旉���是一��L���?div>北京时区是东八区�Q�领先UTC八个���时�Q�在电子邮�g信头的Date域记�?0800�?div>转换中，最重要的公式就是：
UTC �Q?时区�?�Q?本地旉���
    public static Calendar convertToGmt(Calendar cal) {

        Date date = cal.getTime();

        TimeZone tz = cal.getTimeZone();



        System.out.println("input calendar has date [" + date + "]");



        // Returns the number of milliseconds since January 1, 1970, 00:00:00 GMT

        long msFromEpochGmt = date.getTime();



        // gives you the current offset in ms from GMT at the current date

        int offsetFromUTC = tz.getOffset(msFromEpochGmt);

        System.out.println("offset is " + offsetFromUTC);



        // create a new calendar in GMT timezone, set to this date and add the offset      

        Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));

        Calendar utcCal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));



        gmtCal.setTime(date);
        //�Ҏ��东西时区�Q�选择offsetFromUTC为正或负�?/span>
        gmtCal.add(Calendar.MILLISECOND, offsetFromUTC);



        utcCal.setTime(date);

        utcCal.add(Calendar.MILLISECOND, offsetFromUTC);



        System.out.println("Created GMT cal with date [" + gmtCal.getTime()

                + "==" + utcCal.getTime() + "]");

        return gmtCal;

    }



yuxh 2012-03-15 23:08 发表评论


区分getPath(), getAbsolutePath(), getCanonicalPath()
yuxh — Fri, 24 Jun 2011 05:42:00 GMT
来自
http://stackoverflow.com/questions/1099300/whats-the-difference-between-getpath-getabsolutepath-and-getcanonicalpath

C:\temp\file.txt" - this is a path, an absolute path, a canonical path
  .\file.txt This is a path, It's not an absolute path nor canonical path.
  C:\temp\myapp\bin\..\\..\file.txt This is a path, and an absolute path, it's not a canonical path
  Canonical path is always an absolute path.
Converting from a path to a canonical path makes it absolute (通常会处理改变当前目录，所以像. ./file.txt 变�ؓc:/temp/file.txt). The  canonical path of a file just "purifies" the  path, 去除和解析类�?#8220; ..\” and resolving symlinks(on  unixes)
In short:
  getPath() gets the path string that the File object was constructed with, and it may be relative current directory.
getAbsolutePath() gets the path string after resolving it against  the current directory if it's relative, resulting in a fully qualified  path.
getCanonicalPath() gets the path string after resolving any relative  path against current directory, and removes any relative pathing (. and  ..), and any file system links to return a path which the file system  considers the canonical means to reference the file system object to  which it points.
  Also, each of this has a File equivalent which returns the corresponding File object.
 
The best way I have found to get a feel for things like this is to try them out:
  import java.io.File;
public class PathTesting {
        public static void main(String [] args) {
                File f = new File("test/.././file.txt");
                System.out.println(f.getPath());
                System.out.println(f.getAbsolutePath());
                try {
                        System.out.println(f.getCanonicalPath());
                }
                catch(Exception e) {}
        }
}
  Your output will be something like:
  test\..\.\file.txt
C:\projects\sandbox\trunk\test\..\.\file.txt
C:\projects\sandbox\trunk\file.txt
  So, getPath() gives you the path based on the File object, which may or may not be relative; getAbsolutePath() gives you an absolute path to the file; and getCanonicalPath()  gives you the unique absolute path to the file. Notice that there are a  huge number of absolute paths that point to the same file, but only one  canonical path.
  When to use each? Depends on what you're trying to accomplish, but if you were trying to see if two Files are pointing at the same file on disk, you could compare their canonical paths.


yuxh 2011-06-24 13:42 发表评论


路径斜杠处理
yuxh — Wed, 15 Jun 2011 06:47:00 GMT
     摘要:   阅读全文

yuxh 2011-06-15 14:47 发表评论


yuxh — Mon, 15 Nov 2010 11:59:00 GMT
31 
while (i != 0)
    i >>>= 1; //无符号右�U�，不管正负左边都是�?
��Z��表达式合法，�q�里的i必须是整�?byte, char, short, int, or long)。谜题的关键在于>>>= 是一个复合赋值操作符�Q�不�q�的是复合赋值操作符会默默的�?span class="docEmphasis">narrowing primitive conversions�Q�即从一个数据类型�{换�ؓ一个更���的数据�c�d���?span class="docEmphStrong">Narrowing primitive conversions can lose information about the magnitude or precision of numeric values。�ؓ了��问题更具体，假设�q�样定义�Q?br>short i = -1; 因�ؓ初始值i ((short)0xffff) 非零�Q���@环执行。第一步位�U�M��把i提升为int�?tt>short, byte, or char�c�d��的操作数都会做这��L��操作。这�?span class="docEmphasis">widening primitive conversion�Q�没有信息丢失。这�U�提升有�W�号扩展�Q�因此结果是int�?tt>0xffffffff。无�W�号右移一位��生int�?tt>0x7fffffff。�ؓ了把int值存回short变量�Q�Java执行了可怕的narrowing primitive conversion,即简单去掉高十六位。这样又变回�?tt>(short)0xffff。如果定义类�?tt>short or byte型的负数�Q�都会得到类似结果。你如果定义的是char话，则不会无限��@环，因�ؓchar值非负，位移之前的宽扩展不会做符��h��展�?br>
�ȝ���Q?span style="color: red">不要�?tt>short, byte, or char变量上��用复合赋值操作符。这�U�表辑ּ��q�行混合�c�d��计算�Q�非常容易�؜淆。更�p�糕的是隐含的窄映射会丢掉信息�?br>
32 
while (i <= j && j <= i && i != j) {}
i <= j and j <= i, surely i must equal j�Q�对于实数来说是�q�样的。他非常重要�Q�有个名�U�ͼ�The �?relation on the real numbers is said to be antisymmetric。Java's <= operator used to be antisymmetric before release 5.0, but no longer.Java 5之前数据比较�W�号(<, <=, >, and >=) 需要两边的操作数必���Mؓ基础�c�d��(byte, char, short, int, long, float, or double).在Java 5变�ؓ两边操作��Cؓ凡是可�{变�ؓ基础�c�d��的类型。java 5引入autoboxing and auto-unboxing 。The boxed numeric types are Byte, Character, Short, Integer, Long, Float, and Double。具体点�Q�让上面�q�入无限循环�Q?br>Integer i = new Integer(0);
Integer j = new Integer(0);
 (i <= j and j <= i) perform unboxing conversions on i and j and compare the resulting int values numerically。i和j表示0�Q�所以表辑ּ�为true�?tt>i != j比较的是对象引用�Q�也为true。很奇怪规范没有把�{�号改�ؓ比较倹{��原因很���单：兼容性。当一�U�语�a��q�泛应用的时候，不能破坏已存在的规范来改变程序的行�ؓ。System.out.println(new Integer(0) == new Integer(0));��L��输出false�Q�所以必���M��留。当一个是boxed numeric �c�d���Q�另一个是基本�c�d��的时候可以值比较。因为java 5之前�q�是非法的，具体点：
System.out.println(new Integer(0) == 0); //之前的版本非法，Java 5输出True
�ȝ���Q?span style="color: red">当两边的操作数是boxed numeric�c�d��的时候，数字比较�W�和�{�于�W�号是根本不同的�Q�数字比较符是值比较，�{�号比较的是对象引用�?br>
33 
while (i != 0 && i == -i) {}
有负可����C�i一定是数字�Q�NaN不行�Q�因��Z��不等于�Q何数。事实上�Q�没有实数可以出现这�U�情��c��但Java的数字类型�ƈ没有完美表达实数。��Q�Ҏ���׃��个符号位�Q�一个有效数字（���数�Q�，一个指数构成。��Q�Ҏ��只有0才会和自��q��负数相等�Q�所以i肯定是整数。有�W�号整数用的是二�q�制补码计算�Q�取反加一。补码的一大优势是用一个唯一的数来表�C?。然而有一个对应的�~�点�Q�本来可表达偶数个��|��现在用一个表达了0�Q�剩下奇��C��来表�C�正负数�Q�意味着正数和负数的数量不一栗���比如int��|��他的Integer.MIN_VALUE�Q?tt>-2³¹�Q�。十六进制表�?tt>0x8000000。通过补码计算可知他的负数仍然不变。对他取负数是溢��Z��的，不过Java在整数计���中忽略了溢出�?br>�ȝ���Q�Java使用二进制补码，是不对称的。有�W�号整数(int, long, byte, and short) 负数值比整数值多一个�?br>
34
        final int START = 2000000000;
        int count = 0;
        for (float f = START; f < START + 50; f++)
            count++;
        System.out.println(count);
注意循环变量是float。回忆谜�?8 �Q�明显f++没有��M��作用。f的初始化值接�q?tt>Integer.MAX_VALUE�Q�因此需�?1位来准确表达�Q�但是float�c�d��只提供了24位精度。增加这样大的一个float��g��会改变倹{��看��h��会死循环�Q�运行程序会发现�Q�输�?。��@环中f�?tt>(float)(START + 50)做比较。但int和float比较的时候，自动把int先提�C�Zؓfloat。不�q�的是三个会引�v�_�ֺ�丢失的宽基本�c�d��转换的其中之一�Q�另外两个是long到float�Q�long到double�Q�。f的初始值巨大，�?0再�{换�ؓfloat和直接把f转换为float是一��L��效果�Q�即(float)2000000000 == 2000000050�Q�所�?tt>f < START + 50 ��p�|。只要把float改�ؓint卛_��修正�?br>     没有计算器，你怎么知道 2,000,000,050 和float表示2,000,000,000一��P��…�?br>The moral of this puzzle is simple: Do not use floating-point loop indices, because it can lead to unpredictable behavior. If you need a floating-point value in the body of a loop, take the int or long loop index and convert it to a float or double. You may lose precision when converting an int or long to a float or a long to a double, but at least it will not affect the loop itself. When you use floating-point, use double rather than float unless you are certain that float provides enough precision and you have a compelling performance need to use float. The times when it's appropriate to use float rather than double are few and far between�?br>
 35 
下面�E�序模拟一个简单的旉���
int minutes = 0; 
for (int ms = 0; ms < 60*60*1000; ms++) 
  if (ms %  60*1000 == 0) 
     minutes++; 
 System.out.println(minutes); 
�l�果�?tt>60000�Q�问题在于布���表辑ּ�ms % 60*1000 == 0�Q�最���单的修改�Ҏ��是：if (ms % (60 * 1000) == 0) 
更好的方法是用合适命名的帔R��代替��力数字�Q?/tt>
 private static final int MS_PER_HOUR = 60 * 60 * 1000; 
private static final int MS_PER_MINUTE = 60 * 1000; 
public static void main(String[] args) {
   int minutes = 0; 
   for (int ms = 0; ms < MS_PER_HOUR; ms++) 
     if (ms % MS_PER_MINUTE == 0) 
        minutes++;
    System.out.println(minutes); 
} 
�l�不要用�I�格来分�l�；使用括号来决定优先��


yuxh 2010-11-15 19:59 发表评论


yuxh — Mon, 15 Nov 2010 08:39:00 GMT
24      

  for (byte b = Byte.MIN_VALUE; b < Byte.MAX_VALUE; b++) {

        if (b == 0x90)

            System.out.print("Joy!");

    }

Ox90 ���过了byte的取��D���?font face="Courier New">-128�?27。byte和int比较是一�U��؜合类型比较。考虑个表辑ּ�((byte)0x90 == 0x90)得到的是false。byte和int做比较的时候，Java先对byte�q�行了widening primitive conversion 再比较两个int倹{��因为byte是有�W�号�c�d���Q��{变做了符��h��展，把负的byte��D�{换�ؓ相应的int倹{��这个例子中(byte)0x90被�{变�ؓ-112�Q�当然不�{�于int�?0x90或者说+144。�؜合比较总让�����惑，因�ؓ��L��������pȝ����L��升一个操作数来和另一�U�类型匹配。有几种方式可避免�؜合比较。可以把int映射为byte�Q�之后比较两个byte��|�� 

if (b == (byte)0x90)

    System.out.println("Joy!");

另外�Q�可用mask抑制�W�号扩展�Q�把byte转换为int�Q�之后比较两个int��|��

if ((b & 0xff) == 0x90)

    System.out.println("Joy!");

但最好的�Ҏ��是把帔R��值移出��@环放到常量声明中�?br />
    private static final byte TARGET = 0x90; // Broken!

    public static void main(String[] args) {

        for (byte b = Byte.MIN_VALUE; b < Byte.MAX_VALUE; b++)

            if (b == TARGET)

                System.out.print("Joy!");

    }

不幸的是�Q�上面编译通不�q�：0x90对于byte�c�d��来说不是一个有效倹{��这样修改即可：

private static final byte TARGET = (byte)0x90;

To summarize: Avoid mixed-type comparisons, because they are inherently confusing (Puzzle 5). To help achieve this goal, use declared constants in place of "magic numbers." You already knew that this was a good idea; it documents the meanings of constants, centralizes their definitions, and eliminates duplicate definitions.现在你知道他�q�可以强制你为每一个常量定义适用的类型，避免一�U��؜合类型比较的来源�?/p>
25 


int j = 0;

for (int i = 0; i < 100; i++)

  j = j++;

System.out.println(j); //打印出的�?


问题出在 j = j++; �{�同于下列操作：
int tmp = j; j = j + 1; j = tmp; 

�q�次的教训和��N��7一��P��在一个表辑ּ�中不要给同一个变量赋��D���q�一�ơ�?/font>

26
public static final int END = Integer.MAX_VALUE;

public static final int START = END - 100;

public static void main(String[] args) {

    int count = 0;

    for (int i = START; i <= END; i++)

       count++;

     System.out.println(count);

}

看�v来像100�Q�再仔细看��@环是���于�{�于�Q�应该是101�Q�结果是�E�序没有输出��M����|��陷入一个死循环。问题出�?tt>Integer.MAX_VALUE�Q�当�l�箋增加的时候，他悄悄变�?tt>Integer.MIN_VALUE。如果你需要��@环int��D��界，最好用long变量做烦引：

for (long i = START; i <= END; i++)  //输出101

教训是：ints are not integers。无��Z��时用基本�c�d���Q�注意边界倹{��上溢或下溢会出��C��么情况？一般来说最好用大一点的�c�d���Q�基本类型是byte, char, short, int, and long�Q��?/font>也可以不用long�Q?/tt>

int i = START; 

do { 

  count++; 

} while (i++ != END); 

考虑到清晰和���单，��L��用long索引�Q�除了一�U�特�D�情况：如果要遍历所有int��|���q�样用int索引的话会快两倍�?br />
一个��@环四十亿int��|��调用�Ҏ��的常规用法：

// Apply the function f to all four billion int values
int i = Integer.MIN_VALUE;
do {
f(i);
} while (i++ != Integer.MAX_VALUE);

27  位移

��C��java是��用二�q�制补码计算�Q�在��M��有符号基本类型中(byte, short, int, or long)都是用所有位�|?来表�C?1�?

        int i = 0;

        while (-1 << i != 0)       //左位�U?br />
            i++;

        System.out.println(i);

int型的-1�?tt>0xffffffff 表示。不断左�U�，双����?补位。移�?2�ơ，变�ؓ�?�Q�蟩出��@环打�?2�Q�实际上�E�序会死循环。问题出�?1<<32不等�?而是�{�于-1�Q�因��Z���Uȝ��号只用右�Ҏ��作数的低五位作�ؓ�U�d��距离�Q�如果左操作数是long的话用六位。三个位�U�L��作符�Q?lt;<,>>,>>>都是�q�样。移动距���L��L��0�?1�Q�左�Ҏ��作数是long的话0�?3。位�U�距��ȝ��32取模�Q�左�Ҏ��long则用64取模。给int��g���U?2位或�l�long��g���U?4位只会返回本�w�。所以不可能用位�U�d��全移除一个数据。幸�q�的是，有一个简单的办法解决�q�个问题。保存上一�ơ的位移�l�果�Q�每一�ơ�P代多�U�d��一位�?br />
        int distance = 0;

        for (int val = -1; val != 0; val <<= 1)

            distance++;

        System.out.println(distance);

修改后的�E�序说明了一个原则：位移距离如果可能的话�Q�用帔R���?br />
另外一个问题，许多�E�序员认为右�U�M��个负的移动距���，���和左移一��P��反之亦然。事实上不是�q�样�Q�左�U�L��左移�Q�右�U�d��是右�U�R��负数距���d��留下低五位（long留六位）�Q�其余的�|?���变��Z��正数距离。比如，左移一个int�?1的距���，实际上是左移31位�?br />


28 无穷的表�C?br />
for (int i = start; i <= start + 1; i++) {

}

看�v来��@环两�ơ就会结束，如果�q�样定义呢：

int start = Integer.MAX_VALUE - 1;//��d�@�?br />
while (i == i + 1) {

}

�q�个不可能死循环�Q�如果i是无�I�呢�Q�Java采用IEEE 754���点数算术，用double或float来表�C�无�I����所以可以用��M�����点数计���表辑ּ�得出无穷来初始化i。比如：double i = 1.0 / 0.0;

更好的是可以利用标准库提供的帔R��:double i = Double.POSITIVE_INFINITY;

事实上，�Ҏ��用不着用无�I�初始化i来引��h��循环。只要��够大的��Q�Ҏ�����够了：double i = 1.0e40;

�q�是因�ؓ���点数越大，他的值和下一个数的��D�����M�����p��大。distribution of floating-point values is a consequence of their representation with a fixed number of significant bits. �l���够大的��Q�Ҏ��加一不会改变��|��因�ؓ他不能填充这个数和下一个数之间的距���R����Q�Ҏ��操作�q�回最接近准确数学�l�果的��Q点倹{��一旦两个相��L�Q点��g��间的距离大于2�Q�加1��׃��会有效果。float�c�d��来说�Q�超�q?²⁵�Q�或33,554,432�Q�再�?���无效；对double来说���过2⁵⁴�Q�接�q?.8 x 10¹⁶�Q�再�?���无效�?br />
     盔R�����点��C��间的距离�U�Cؓulp�Q�unit in the last place的羃写）。在Java 5�?Math.ulp�Ҏ��被引入来计算float或double值的ulp�?/tt>

�ȝ���Q?font color="#ff0000">不可能用float或double来表�C�无�I����另外，在一个大的��Q�Ҏ��上加一个小的��Q�Ҏ���Q���g��会改变。有点不合常理，实数�q�不是这栗���记住二�q�制���点数计���只是近��g��实数计算�?/font>
29 NaN
while (i != i) { } 

IEEE 754 ���点数计���保留了一个特�D�值来来表�C�Z��是数字的数量。NaN是��Q点计���不能很好定义的敎ͼ�比如0.0 / 0.0。规范定�?font color="#ff0000">NaN不等于�Q何数包括自己。因此double i = 0.0 / 0.0; 可让开始的�{�式不成立。也有标准库定义的常量：double i = Double.NaN; 如果一个或多个操作��CؓNaN�Q�那么��Q�Ҏ��计算��׃���{�于NaN�?/p>
�ȝ���Q�float和doule存在�Ҏ��的值NaN�Q�小心处理�?/p>
30

while (i != i + 0) { } �q�一�ơ不能��用float或者double�?br />
+操作�W�除了数字，���只能处理String�?操作�W�会被重载：对于String�c�d���Q�他做的是连接操作。如果操作数有非String�c�d���Q�会先做转换变�ؓString之后再做�q�接。i一般用作数字，要是对String型变量这么命名容易引赯���解�?/tt>

�ȝ���Q?font color="#ff0000">操作�W�重载非常容易误��g�h。好的变量名�Q�方法名�Q�类名和好的注释对于�E�序的可��L��一样重要�?/font>


yuxh 2010-11-15 16:39 发表评论


yuxh — Sat, 30 Oct 2010 05:46:00 GMT
19  单行注释

    public static void main(String[] args) {

        System.out.println(classify('n') + classify('+') + classify('2'));

    }

    static String classify(char ch) {

        if ("0123456789".indexOf(ch) >= 0)

            return "NUMERAL ";

        if ("abcdefghijklmnopqrstuvwxyz".indexOf(ch) >= 0)

            return "LETTER ";

       /* (Operators not supported yet)

        if ("+-*/&|!=".indexOf(ch) >= 0)

            return "OPERATOR ";

       */

        return "UNKNOWN ";

    }

�~�译出错�Q�块注释不能嵌套�Q�在注释内的文本都不会被�Ҏ��对待�?br />
// Code commented out with an if statement - doesn't always work!

if (false) {

    /* Add the numbers from 1 to n */

    int sum = 0;

    for (int i = 1; i <= n; i++)

        sum += i;

}

�q�是语言规范推荐的一�U�条件编译的技术，但不是非帔R��合注释代码。除非包含的语句都是有效的表辑ּ��Q�否则这�U�条件编译不能用作注释。最好的注释代码�Ҏ��是用单行注释�?br />


20   反斜�?br />
   Me.class.getName() �q�回的是Me�cȝ��完整名，�?tt>"com.javapuzzlers.Me"�?nbsp;

   System.out.println( Me.class.getName().replaceAll(".", "/") + ".class"); 

   应该得到com/javapuzzlers/Me.class�Q�不寏V��问题出�?span class="docEmphStrong">String.replaceAll把正则表辑ּ�作�ؓ�W�一个参敎ͼ�而不是字�W�。正则表达是“.”表示配对��M��单独的字�W�，所以类名的每一个字�W�都被斜�U�替代。�ؓ了只匚w��句号�Q�必��ȝ��反斜�U�（\�Q��{义。因为反斜线在字�W�串中有�Ҏ��意义——它是escape sequence的开始——反斜线自��n也必��ȝ��一个反斜线转义�?br />
正确�Q�System.out.println( Me.class.getName().replaceAll("\\.", "/") + ".class");

��Z��解决�q�类问题�Q�java 5提供了一个新的静态方�?tt>java.util.regex.Pattern.quote。用一个字�W�串作�ؓ参数�Q�增加�Q何需要的转义�Q�返回一个和输入字符串完全匹配的正则表达式字�W�串�Q?br />
  System.out.println(Me.class.getName().replaceAll(Pattern.quote("."), "/") + ".class");

�q�个�E�序的另外一问题���是依赖于��^台。不是所有的文�g�pȝ��都是用斜�U�来�l�织文�g。�ؓ了在你运行的�q�_��取得正确的文件名�Q�你必须使用正确的��^台分隔符来替换斜�Uѝ�?br />


21 

    System.out.println(MeToo.class.getName().

    replaceAll("\\.", File.separator) + ".class");

java.io.File.separator 是一个公��q��String 属性，指定用来包含�q�_��依赖的文件名分隔�W�。在UNIX上运行打�?tt>com/javapuzzlers/MeToo.class。然而，在Windows上程序抛出异常：

    StringIndexOutOfBoundsException: String index out of range: 1

�l�果�?tt>String.replaceAll 的第二个参数不是普通字�W�串而是一个在java.util.regex 规范中定义的 replacement string�Q�反斜线转义了后面的字符。当在Windows上运行的时候，替换字符是一个单独的反斜�U�，无效。JAVA 5提供了两个新�Ҏ��来解册���个问题，一个是java.util.regex.Matcher.quoteReplacement�Q�它替换字符串�ؓ相应的替换字�W�串�Q?br />
 System.out.println(MeToo.class.getName().replaceAll(

   "\\.",  Matcher.quoteReplacement(File.separator))+".class");

�W�二个方法提供了更好的解��x��法�?tt>String.replace(CharSequence, CharSequence)�?tt>String.replaceAll做同��L��事情�Q�但他把两个参数都作为字�W�串处理�Q�System.out.println(MeToo.class.getName().replace(".", File.separator) + ".class");   

如果用的是java早期版本���没有简单的�Ҏ��产生替换字符丌Ӏ�完全不用正则表辑ּ��Q����?tt>String.replace(char, char)跟容易一些：

System.out.println(MeToo.class.getName().replace('.', File.separatorChar) + ".class");

教训�Q�当用不熟悉的库�Ҏ��的时候，���心炏V��有怀疑的话，查看Javadoc。当然正则表辑ּ�也很���手�Q�他�~�译时可能没问题�q�行时却更容易出错�?/tt> 



22  statement label

     认真写注释，及时更新。去掉无用代�?/span>。如果有东西看�v来奇怪不真实�Q�很有可能是错误的�?

23

    private static Random rnd = new Random();

    public static void main(String[] args) {

      StringBuffer word = null;

      switch(rnd.nextInt(2)) {

          case 1:  word = new StringBuffer('P');

          case 2:  word = new StringBuffer('G');

          default: word = new StringBuffer('M');

      }

      word.append('a');

      word.append('i');

      word.append('n');

      System.out.println(word);

   }

在一�ơ又一�ơ的�q�行中，以相�{�的概率打印出Pain�Q�Gain�?Main�Q�答案它��L��在打印ain。一共有三个bug��D���q�种情况�?br />
一�?Random.nextInt(int) �Q�看规范可知�q�里�q�回的是0到int��g��间的前闭后开区间的随机数。因此程序中永远不会�q�回2�?/font>�q�是一个相当常见的问题源，被熟知�ؓ“栅栏柱错误（fencepost error�Q?#8221;。这个名字来源于对下面这个问题最常见的但却是错误的答案，如果你要建造一�?00英尺长的栅栏�Q�其栅栏柱间隔�ؓ10英尺�Q�那么你需要多���根栅栏柱呢�Q?1�Ҏ��9栚w��是正���答案，�q�取决于是否要在栅栏的两端树立栅栏柱�Q�但�?0根却是错误的。要当心栅栏柱错误，每当你在处理长度、范围或模数的时候，都要仔细���定其端�Ҏ��否应该被包括在内�Q��ƈ且要���保你的代码的行�����与其相对应�?br />
�W�二个bug�?case没有配套�?/span>break�?span style="widows: 2; text-transform: none; text-indent: 0px; border-collapse: separate; white-space: normal; orphans: 2; letter-spacing: normal; color: rgb(0,0,0); font-weight: normal; word-spacing: 0px" class="Apple-style-span">�?.0版本��P��javac提供�?Xlint:fallthrough标志�Q�当你忘记在一个case与下一个case之间��d��break语句是，它可以生成警告信息。不要从一个非�I�的case向下�q�入了另一个case。这是一�U�拙劣的风格�Q�因为它�q�不常用�Q�因此会误导读者。十�ơ中有九�ơ它都会包含错误。如果Java不是模仿C建模的，那么它倒是有可能不需要break。对语言设计者的教训是：应该考虑提供一个结构化的switch语句�?br />
最后一个，也是最微妙的一个bug是表辑ּ�new StringBuffer(‘M')可能没有做哪些你希望它做的事情。StringBuffer(char)构造器�Ҏ��不存在�?/span>StringBuffer有一个无参数的构造器�Q�一个接受一个String作�ؓ字符串缓冲区初始内容的构造器�Q�以及一个接受一个int作�ؓ�~�冲区初始容量的构造器。在本例中，�~�译器会选择接受int的构造器�Q�通过拓宽原始�c�d��转换把字�W�数�?M'转换��Z��个int数�?7[JLS 5.1.2]。换句话��_��new StringBuffer(‘M')�q�回的是一个具有初始容�?7的空的字�W�串�~�冲区。该�E�序余下的部分将字符a、i和n��d����C���q�个�I�字�W�串�~�冲��Z���Q��ƈ打印�����字符串缓冲区那��L��ain的内�?span style="color: red">�?span style="color: rgb(255,0,0)"> ��Z��避免�q�类问题�Q�不���在什么时候，都要���可能��用熟悉的惯用法和API。如果你必须使用不熟悉的API�Q�那么请仔细阅读其文�?/span>�?/span>在本例中�Q�程序应该��用常用的接受一个String的StringBuffer构造器�?/span> 


yuxh 2010-10-30 13:46 发表评论


Java Puzzlers(�?一 字符)
yuxh — Fri, 22 Oct 2010 00:49:00 GMT
11 字符相加

      System.out.print("H" + "a");System.out.print('H' + 'a'); //貌似输出HaHa�Q?/tt>

       最后输出的�?tt>Ha169�?tt>'H' �?tt>'a' 都是 char�Q�不�?tt>String�Q?操作�W�做的是加法操作而不是拼接字�W�串。编译器提升两个char值到int��|���?6位零扩展�?2位的int。一个是72另一个是97。从语义上说�Q�char值和字符串的�怼�是非常迷惑的。java语言仅仅把char看做无符��L��16位基本整数。库不这栯���为，他里面有许多�Ҏ��把char参数当作Unicode字符在处理。怎样�q�接字符�Q�可以��用库�Ҏ���Q�如�Q?br />
     StringBuffer sb = new StringBuffer();

     sb.append('H');sb.append('a');

     System.out.println(sb);  //可行但丑�?br />
    有很多方法避免这�U�繁琐，只要一个操作符是string���p��强制+操作�W�做拼接操作。习惯用法是在前面加一个空字符�?#8220;”�Q�如�Q?br />
     System.out.print("" + 'H' + 'a');//虽然有用�Q�但�q�是有点不雅而且�Ҏ����D��一点困�?nbsp;

     试试�Q�System.out.println("2 + 2 = " + 2+2);  如果用的是java 5�q�可以��用printf�Q�System.out.printf("%c%c", 'H', 'a');

      �ȝ���Q�小心应对字�W�串拼接操作�W��?font face="Courier New">“+”只有臛_��一个是String的时候才做字�W�串拼接�Q�否则做加法。如果没有String型，有几个选择�Q�加�I�字�W�串�Q�用String.valueOf把第一个值显�C���{换�ؓString�Q�用String buffer�Q�java 5的话用printf �?br />
12  字符数组

     String letters = "ABC";

     char[] numbers = { '1', '2', '3' };

     System.out.println(letters + " easy as " + numbers);  //�q�回ABC easy as [C@16f0472

 char 虽是基本整数�c�d���Q�但char值常常表�C�字�W�而不是整敎ͼ�很多库对他特�D�对待。比如，把char传给println 输出的是Unicode 字符而不是数字码。char数组获得同样对待�Q?tt>char[] 的重载是println输出数组中的所有字�W�，char[]�?tt>String.valueOf �?tt>StringBuffer.append 的重载也�c�M��。但是字�W�拼接操作符不是像这些方法，他是对两边做字符串�{换然后再拼接。对于对象引用包括数�l�，字符串�{换是�q�样定义的：如果应用是null�Q��{换�ؓ字符�?tt>"null"�Q�否则调用被引用对象�?tt>toString 无参数方法；如果toString �Ҏ���q�回的是null�Q�还是用“null”字符丌Ӏ�非null的char数组调用toString做什么操作？数组�?tt>Object �l�承来的toString,定义�Q?#8220;�q�回字符串含有对象实例类名，字符'@'�Q�对象的用无�W�号十六�q�制表示的hash�?#8221;�?nbsp;Class.getName 的说明表�C�对 char[] 该类对象调用该方法返�?nbsp;"[C"。两个方法修正，拼接之前可显�C���{换数�l��ؓString�Q?br />
     System.out.println(letters + " easy as " + String.valueOf(numbers));

�q�可以把the System.out.println 分开成两个来利用 char[] 对println的重载：

     System.out.print(letters + " easy as ");System.out.println(numbers);

 注意�q�些修正只是在你正确重蝲valueOf �?tt>println�Ҏ��才�v效。换句话��_��他们严重依赖�~�译时数�l�引用的�c�d���?/tt> 下面例子看�v来用来第二个修正�Ҏ���Q�但�q�是输出丑陋字符丌Ӏ�因��Z��调用了Object对println的重载而不是char[]的重载�?br />
// Broken - invokes the wrong overloading of println!

class Abc {

    public static void main(String[] args) {

        String letters = "ABC";

        Object numbers = new char[] { '1', '2', '3' };

        System.out.print(letters + " easy as ");

        System.out.println(numbers); // Invokes println(Object)

    }

}

�ȝ���Q�char数组不是字符丌Ӏ?span style="color: red">把char数组转换为字�W�串�Q�调�?nbsp;String.valueOf(char[])。一些库�Ҏ���l�char数组提供了像字符串的支持�Q�典型的是给Object提供一个重载再�l�char[]提供一个重载；后一个才是理想的操作�?/tt>



13 Interning 

      final String pig = "length: 10";

      final String dog = "length: " + pig.length();

      System.out.println("Animals are equal: "  + pig == dog);

compile-time constants of type String are interned.换句话说�Q��Q何两个有相同字符的String�c�d��的常量表辑ּ�是同一个对象引用表�C�的。所以如果用帔R��表达式初始化的话�Q�pig和dog会指向同一个对象，但dog没用帔R��表达式。Java语言限制哪些操作可以出现在常量表辑ּ�中，�Ҏ��调用是不允许的。因此，�E�序应该输出 Animals are equal: false�Q�对吧？事实上不是，�q�行发现只输�?tt>false 。操作符的优先��体现出来�Q�事实上�?br />
     System.out.println(("Animals are equal: " + pig) == dog);

有一�U�方法能避免�q�种困难�Q�但使用字符拼接操作�W�的时候，��L���l�重要操作数加上括号�Q�System.out.println("Animals are equal: " + (pig == dog));

辩证的说�Q�这栯���是有问题。Your code should rarely, if ever, depend on the interning of string constants。Interning 只是用来减少虚拟机内存的�Q�不是用来当作程序员工具的。由于字�W�串intern ��p�|带来的bug非常难以�����?span style="color: red">。对比两个对象引用的时候，应该用equals�Ҏ��而不�?=操作�W�除非你是想比较对象identity而不是�?/span>。所以我们的例子应该�q�样�Q�System.out.println("Animals are equal: " + pig.equals(dog));



14 转义�W?/span> 

    下面�E�序使用 Unicode escapes�Q�用他们的十六进制数字码表示Unicode 字符�?br />
    // \u0022 is the Unicode escape for double quote (")

    System.out.println("a\u0022.length() + \u0022b".length());

  Java provides no special treatment for Unicode escapes within string literals。编译器在把Unicode escapes�E�序解析为字�W�串之前�Q�先变�ؓ了他们表�C�的字符。可以���?span class="docEmphasis">escape sequences:即用\"表示双引�?�Q�例System.out.println("a\".length() + \"b".length()); 

�q�有很多escape sequences �Q?nbsp;single quote (\'), linefeed (\n), tab (\t), and backslash (\\).  escape sequences �{�程序先解析为符号之后才处理。ASCII是Unicode的子集。ASCII是最���的字符集，只有128个字�W�，Unicode�?nbsp;65,000的字�W�。Unicode escape 能被用来把Unicode 字符插入只能使用ASCII字符的程序中。一�?nbsp;Unicode escape意味着和他代表的字�W�完全相同的东西。但�E�序员用源文件的字符集不能插入一些字�W�的时候，可以使用 Unicode escape�Q�主要是把非ASCII字符变�ؓ标志�W�，字符�Ԍ��注释�{��?br />
  �ȝ���Q�在字符串和字符文字中，用escape sequences不用Unicode escapes 。不要用Unicode escapes  表示ASCII字符。在字符串和字符文字中，用escape sequences�Q�在外面的话直接把ASCII 字符插入源文件�?br />


15 

     Unicode escapes must be well formed, even if they appear in comments. 下面�q�个例子�~�译出错

/**

* Generated by the IBM IDL-to-Java compiler, version 1.0

* from F:\TestRoot\apps\a1\units\include\PolicyHome.idl

* Wednesday, June 17, 1998 6:44:40 o'clock AM GMT+00:00

*/

工具在把Windows 文�g名放入注释之前，必须把\��L���?br />
��M���Q?tt>\u不要出现在有效Unicode escape范围之外�Q�即使注释也不行。特别是自动产生代码的时候�?br />
16 

    line separator 用来表示分割文本行的字符�Q�每个��^台的line separator 不一栗���Windows 上，CR character (carriage return) followed by the LF character (linefeed)。UNIX上只有LF字符�Q�经常被较�ؓnewline character�Q�。下面把�q�些字符传给println

   // Note: \u000A is Unicode representation of linefeed (LF)

    char c = 0x000A;

    System.out.println(c);

�l�果�~�译错误�Q�仍然是�׃��注释中Unicode escape,�~�译器再抛弃注释内容和空��g��前就把Unicode escapes 转换为字�W��?span style="color: red">\u000A 代表linefeed character,因此�E�序最后�{换�ؓ 

    // Note:

   is Unicode representation of linefeed (LF)

   char c = 0x000A;

   System.out.println(c);

最���单的修改�Ҏ��是去�?nbsp;Unicode escape �Q�但更好的方法是用escape sequence 初始化c�Q�而不是用十六�q�制整数�Q�排除注释的需�?br />
   char c = '\n';

   System.out.println(c);

�q�样改后�E�序�q�是有问题，有��^��C��赖。在某些�q�_���Q�如UNIX�Q�他���输��Z��行完整的分割�W�；另外一些��^収ͼ�如Windows�Q�则不会。虽然肉眼看��h��一��P��但如果存在一个文件或���道里供其他�E�序处理�?是很�Ҏ��出问题的�?如果打算输出两行�I�白�Q�应该调用println两次。Java 5�Q�你可以使用printf带上格式"%n%n"�?/tt>代替println�Q�每一个出现的 %n是printf打印出��^台相应的行分隔符�?br />
道理�Q�非必需���量不用Unicode escapes 

17 

   Unicode escapes are essential when you need to insert characters that can't be represented in any other way into your program. Avoid them in all other cases.Unicode escapes 减少�E�序的清晰性，增加bug的出现。对语言设计者来��_��应该使Unicode escapes表示ASCII字符非法�?br />
18 字符�?br />
  byte bytes[] = new byte[256];

  for(int i = 0; i < 256; i++)

    bytes[i] = (byte)i;

  String str = new String(bytes);

  for(int i = 0, n = str.length(); i < n; i++)

    System.out.print((int)str.charAt(i) + " ");

  在不同的机器上运行，�l�果完全不一栗���原因是String(byte[])构造器。规范说“用��^台默认的字符集给指定的byte数组解码创徏一个新字符丌Ӏ�新字符串的长度是字�W�集的功能，因此可能和byte数组的长度不一栗���当�l�定的字节在默认字符集中无效�Ӟ��该构造器行�ؓ不确�?#8221;。什么是字符集？技术上��_��他是“the combination of a coded character set and a character-encoding scheme”。换句话��_��是一堆字�W�，表达字符的数字编码，以及一序列字符�~�码和字节互相�{换的�Ҏ��。�{换方案在不同的字�W�集中差异巨大。一些字�W�和字节一一对应�Q�大多数不这栗���只有默认字�W�集�?nbsp;ISO-8859-1�Q�更多被�U�CؓLatin-1 �Q�的时候上面的�E�序才会输出0�?55的整数。J2SE�q�行环境的默认编码是由底层操作系�l�和区域军_��的。在早期的JAVA版本��d���pȝ��属�?nbsp;"file.encoding"来得到JRE默认�~�码�Q�JAVA 5后以后的版本�Q�可使用 java.nio.charset.Charset.defaultCharset()�Ҏ��。幸�q�的是，你不是非得要面对默认字符集的变化多端。char序列和byte序列互相转换的时候，你可以�ƈ且大多数时候应当显式的指定字符�?/span>。一个以字符集名字和byte数组为参数的String构造器可完成此��d��。用下面�Ҏ���Q�上面程序就不会受默认字�W�集的媄响了�Q�String str = new String(bytes, "ISO-8859-1"); 该构造器抛出UnsupportedEncodingException�Q�你必须捕获�Q�当更好的方法是声明一个main�Ҏ��来抛��Z��否则不能�~�译通过。事实上�Q�上面的�E�序不会抛出异常。因�?tt>Charset 的规范指明�Q何JAVA�q�_��的实现必���L��持某些字�W�集�Q�ISO-8859-1是其中之一�?br />
  教训�Q?span style="color: red">每次从byte序列转换为String�Q�不���显�C�或隐式都在使用一�U�字�W�集。如果想�E�序不出意外�Q�每�ơ��用时昄���指定一�U�字�W�集�?br />


yuxh 2010-10-22 08:49 发表评论


Java Puzzlers�Q�一 表达式计���）
yuxh — Wed, 13 Oct 2010 05:27:00 GMT
1 奇数判断

  误：public static boolean isOdd(int i) { return i % 2 == 1; }   //没有考虑到负奇数的情�?br />
  正：return i % 2 != 0; 更好的性能�Q�return (i & 1) != 0;

 �ȝ���Q�求余操作需要考虑�W�号�Q?br />
2 ���点数计��?br />
   public static void main(String args[]) { System.out.println(2.00 - 1.10); } //天真以�ؓ得到0.90

    如果熟悉Double.toString 的文档，估计会觉�?double 会�{为string�Q�程序会打印�����够区�?tt>double值的���数部分�Q�小数点前或后面臛_��一位。这栯���来应该是0.9�Q�可惜运行程序发现是 0.8999999999999999。问题是数字1.1不能被double准确表示�Q�只能用最接近的double��D���C�。遗憄���是结果不是最接近0.9的double�?/tt>。更普遍的看�q�问题是�Q?strong>不是所有的十进制数都能用二�q�制���点数准���的表示 。如果用jdk5或以后版本，你可能会使用printf来准���设�|�：

// Poor solution - still uses binary floating-point! 

System.out.printf("%.2f%n", 2.00 - 1.10); 

  现在打印出来是正���的了，但治标不��L���Q�它仍然使用的是double�q�算�Q�二�q�制���点�Q�，���点计算在大范围内提供近��D�����，但不��L��产生准确的结果。二�q�制���点数特别不适合金融计算�Q�因��Z��不可能表�C?.1——或�Q�?0的负�q?#8212;—exactly as a finite-length binary fraction�?br />
一�U�解军_��法是使用基本�c�d���Q�比如int long�Q�然后扩大操作数倍数做计���。如果用�q�种���程�Q�确保基本类型��够大来表�C�Z��所有你用到的数据，�q�个例子中，int���_��了System.out.println((200 - 110) + " cents");

   另一�U�办法���?tt>BigDecimal�Q�他�q�行准确的十�q�制计算�Q�他�q�能通过JDBC和SQL�?/tt>DECIMAL�c�d��合作�?strong>有一个箴�a��Q���L��使用BigDecimal(String)构造器�Q�绝不���?/strong>BigDecimal(double).后面�q�个构造函数用参数的准���值创��Z��个实例：new BigDecimal(.1)�q�回一�?/tt>BigDecimal表示0.1000000000000000055511151231257827021181583404541015625。正�����用会得到预期�l�果0.90�Q?                                                    System.out.println(new BigDecimal("2.00"). subtract(new BigDecimal("1.10"))); �q�个例子不是特别漂亮�Q�java没有�l?/span>BigDecimal提供语言学上的支持，BigDecimal也可能比使用基本�c�d���Q�对大量使用十进制计���的�E�序比较有用�Q�更慢，大多数情冉|��有这个需要�?/tt>  

  �ȝ���Q�但需要准���答案的时候，避免使用float and double�Q�金融计���，使用int, long, or BigDecimal。对语言设计者来��_��提供十进制计���的语言支持。一个方法是�l�操作符重蝲提供有限的支持，�q�样计算操作�W�就能和数字引用�c�d��比如BigDecimal一起工作？。另一�U�方法就是像COBOL and PL/I一��P��提供基本十进制类型�?/tt> 

 3 长整型除�?br />
  被除数表�C�Z��天的微秒敎ͼ�除数表示一天的毫秒敎ͼ�

 public static void main(String[] args) {

        final long MICROS_PER_DAY = 24 * 60 * 60 * 1000 * 1000;

        final long MILLIS_PER_DAY = 24 * 60 * 60 * 1000;

        System.out.println(MICROS_PER_DAY / MILLIS_PER_DAY);

    }

你在想程序应该输�?tt>1000�Q�很不幸输出的是5�Q�问题出在计��?tt>MICROS_PER_DAY 时溢��Z���Q�虽然结果是满��long的，但不满��int。这个计���过�E�全部是按int 计算的，计算完之后才转�ؓlong。因此很明显计算�q�程中溢出。�ؓ什么会用int计算�Q�因为因子都是int型的�Q�Java没有 target typing�Ҏ��（���是�Ҏ���l�果的类型来���定计算�q�程所用类型）。解册���个问题很���单，把第一个因子设�|��ؓlong�Q�这样会强制所有以后的计算都用long�q�行。虽然很多地斚w��不需要这么做�Q�但�q�是一个好习惯�?br />
    final long MICROS_PER_DAY = 24L * 60 * 60 * 1000 * 1000;

    final long MILLIS_PER_DAY = 24L * 60 * 60 * 1000;

我们得到一个教训：和大数据打交道的时候，���心溢出�Q�一个变量能装得下结果，�q�不代表计算�q�程中会���保得到正确�c�d���?br />
4 ���学生都知道的事�?br />
    System.out.println(12345 + 5432l); // 毫无疑问�?tt>66666�Q?看仔�l�了�Q�输�?tt>17777

    教训�Q?span style="color: #ff0000">使用long的时候用大写的L�Q�绝不用���写的l�Q�类似的避免用l作�ؓ变量名。很隄��������出的�?�q�是l

// Bad code - uses el (l) as a variable name

   List l = new ArrayList();

   l.add("Foo");

   System.out.println(1);

5  十六�q�制的快�?br />
    System.out.println(Long.toHexString(0x100000000L + 0xcafebabe)); //输出cafebabe�Q�最左边�?丢了�Q?br />
   十进制有一个十六或八进刉���没有的优点：数字都是正的�Q�想表达负数需要一个负受���这��L��话写十进制的int或long�Q�不���正负都很方�ѝ��十六或八进制就不这样了�Q�必��ȝ��高位来决定正负。这个例子中�Q?tt>0xcafebabe 是一个int帔R���Q�最高位�?�Q�因此是负数=十进�?nbsp;-889275714。这里还有一个�؜合类型计���的额外操作�Q�左�Ҏ��作数是long�Q�右�Ҏ��int�Q�计���时Java通过widening primitive conversion 把int变�ؓlong�Q�再加这两个long。因为int是有�W�号整型�Q��{变执行了一个符��h��展：把负的int值提升�ؓ数值相�{�的long倹{��右边的0xcafebabe被提升�ؓlong�?nbsp;0xffffffffcafebabeL�Q�再加到左边0x100000000L�?/tt>。当被看作int型的时候，0xcafebabe扩展出来的高32位是-1�Q�而左�Ҏ��作数�?2位是1�Q�相加之后�ؓ0�Q�这解释了�ؓ什么最高位�?丢失。解��x��法是把右边的操作��C��写上long�Q�这样就避免了符��h��展的破坏�?br />
System.out.println(Long.toHexString(0x100000000L + 0xcafebabeL));

教训�Q�考虑十六或八�q�制自��n带正负，混合�c�d��计算让�h�q�h��。�ؓ避免出错�Q?span style="color: red">最好不要��用�؜合类型计��?/span>。对语言设计者来��_��考虑支持无符��h��数类型来��L���W�号扩展的可能。有��Z��论十六或八进制负数应该被���止�Q�但对于�E�序员来说非�怸�好，他们�l�常使用十六�q�制来表�C�符��h��有意义的数倹{�?br />
6 多重映射

   System.out.println((int) (char) (byte) -1);

    �?tt>int �c�d���?1开始，映射到byte�Q�到char�Q�最后返回int。第一��?2位变�?位，�?6位，最后回�?2位。最后发现值�ƈ没有回到原始�Q�输�?tt>65535

问题来自映射时的�W�号扩展问题。int�?1的所�?2位都�?�Q��{�?位byte很直观，只留下低八位���p���Q�仍然是-1.转char的时候，���p�����心了，byte是有�W�号的，char无符受���通常有可能保留数值的同时把一个整型�{到更“�?#8221;的类型，但不可能用char来表�C�Z��个负的byte倹{��Therefore, the conversion from byte to char is not considered a widening primitive conversion [JLS 5.1.2], but a widening and narrowing primitive conversion [JLS 5.1.4]: The byte is converted to an int and the int to a char。看��h��较复杂，但有一个简单规则描�q�窄变宽转换时的�W�号扩展�Q?span style="color: red">原始值有�W�号���做�W�号扩展�Q�不����{换成什么类型，char只做零扩展�?span style="color: #000000">因�ؓbyte是有�W�号的，byte -1转成char会有�W�号扩展。结果是�?�?6位，也就�?nbsp;2¹⁶ – 1�?5,535。char到int宽扩展，规则告诉我们做零扩展。int�c�d��的结果是65535。虽然规则简单，但最好不要写依赖�q�规则的�E�序。如果你是宽转换到char�Q�或从char转换�Q�char��L��无符��h��敎ͼ��Q�最好显式说明�?br />
   如果从char�c�d��的c宽�{换，�q�且不想�W�号扩展�Q�虽然不需要，但�ؓ了清晰可以这��P��

   int i = c & 0xffff;    

�q�可以写注释�Q?br />
int i = c; // Sign extension is not performed

 如果从char�c�d��的c宽�{换，�q�且想符��h��展，强制char到short�Q�宽度一样但有符��P��

int i = (short) c; // Cast causes sign extension

byte到char�Q�不要符�?/span>�Q�必��ȝ��位屏蔽抑制他�Q�这是惯例不用注�?0xff�q�种0x开头的默认是int�c�d��的？)

char c = (char) (b & 0xff);

byte to a char �Q�要�W�号�Q�写注释

char c = (char) b; // Sign extension is performed

�q�一译־����单：如果你不能清晰看出程序在�q�什么，他可能就没有按你希望的在�q�行。拼命寻求清晎ͼ�虽然整数转换的符��h��展规则简单，但大多程序员不知道。如果你的程序依赖于他，让你的意图明显�?

7 交换���味

   在一个简单表辑ּ�中，不要对一个变量赋��D���q�一�ơ。更普遍的说�Q�不要用“聪明”的程序技巧�?br />
8  Dos Equis

        char x = 'X';

        int i = 0;

        System.out.print(true  ? x : 0);

        System.out.print(false ? i : x);

输出XX�Q�可惜输出的�?tt>X88。注意第二三个操作数�c�d��不一��P���W?点说�q�，混合�c�d��计算让�h�q�h���Q�条件表辑ּ�中是最明显的地斏V��虽然觉得两个表辑ּ��l�果应该相同�Q�毕竟他们类型相��|��只是位置相反而已,但结果�ƈ不是�q�样�?br />
       军_��条�g表达式结果类型的规则很多�Q�但有三个关键点�Q?br />
       1 如果�W�二三个操作数类型一��P��表达式也是这个类型，�q�样���避免了混合�c�d��计算�?br />
       2  3 复杂略过 ��M���W�一个表辑ּ�是调用了PrintStream.print(char)�Q�第二个�?tt>PrintStream.print(int) 造成�l�果不同

    �ȝ���Q?span style="color: red">最好在条�g表达式中�W�二三个操作数用同一�U�类�?/span>

9 

    x += i;  // �{�同于x = x + i;�Q?br />
   compound assignment expressions automatically cast the result of the computation they perform to the type of the variable on their left-hand side// 暗含映射

    例如 short x = 0;int i = 123456;

     x += i; // –7,616�Q�int�?23456太大�Q�short装不下，高位两个字节被去�?br />
     x = x + i; // �~�译错误- "possible loss of precision"

    为避免危险，不要�?tt>byte, short, or char上面用复合赋值符。当在int上用�Ӟ�����保双���不是long, float, or double�c�d��。在float上用�Q�确保右边不是double�?br />
10  复合赋值符需要两�Ҏ��作数都�ؓ基本�c�d��或boxed primitives�Q�如int �Q?tt>Integer。有一例外�Q?tt>+= 左边为String的话�Q�允许右边�ؓ��L���c�d��。这时做的是字符串拼接操作�?br />
    Object x = "Buy ";

    String i = "Effective Java!";

    x = x + i; //x+i 为String�Q�和Object兼容�Q�因此表辑ּ�正确

    x += i; //非法左边不是String
注意�q�回�c�d���Q?/span>The 	  arithmetic, increment and decrement, bitwise, and shift 	  operators return a double if at least one 	  of the operands is a double. Otherwise, 	  they return a float if at least one of the 	  operands is a float. Otherwise, they return a 	  long if at least one of the operands is a 	  long. Otherwise, they return an 	  int, even if both operands are 	  byte, short, or 	  char types that are narrower than 	  int. 




yuxh 2010-10-13 13:27 发表评论


Beginning JO(interface/static/final)
yuxh — Wed, 16 Dec 2009 03:16:00 GMT
接口的方法默认�ؓpublic�Q�不能定义�ؓprivate�?br />
If a class implements two or more interfaces that call for methods with identical signatures,we need only implement one such method in the implementing class—that method will do “double duty” in satisfying both interfaces’ implementation requirements as far as the compiler is concerned.

定义 属性，�Ҏ��参数�Q�返回类型的时候尽可能使用接口�Q�客��L��代码调用�q�样的类会更加灵�z�R�?br />
List和Set都是Collection接口的子�c�，使用Collection可以更通用�?br />
    如果一定要自己创徏集合�c�而且不通过扩展存在的ArrayList�{�的话，臛_��实现Collection接口�Q�这��h��能在使用Collection的环境��用�?br />
    静态方法不能�ؓabstract�Q�不能调用非静态的属性或�Ҏ��。我们经常利用静态方法，属性实��C���?#8220;工具�c?#8221;�Q�比如java.lang中的Math.

    接口不允许定义变量，除了定义public static final 变量来作为全局帔R��。但是final�c�d��的变量必���L���C�初始化�Q�且初始化的�Ҏ��必须是在��x��时或者在构造方法中直接赋��|��而不能通过调用函数赋倹{�?br />
    j2se 5引入 �Q�import static Administrator.*; �q�样在代码中可以直接使用Administrator�cȝ��静态变量�?br />
查询了下关于是否用final限定�Ҏ��参数以及局部变量的问题�Q�有争议�Q?a >http://stackoverflow.com/questions/316352?sort=votes#sort-top�Q�，�c�M��习惯问题�Q�不�q�对传入的参数重新赋��g��是好习惯�Q�否则在�Ҏ��中��用该参数的时候你会考虑前面的代码是否对参数处理�q�，�q�有可能��p��的进行了赋倹{��們֐�于方法参��C��用final�Q�局部变量不使用。折中的办法是设�|�eclipse的重赋��D��告�?
 

yuxh 2009-12-16 11:16 发表评论


Beginning JO(2 Collection)
yuxh — Thu, 10 Dec 2009 03:38:00 GMT
    数组可以装基本类型或者引用，collections只能装引用�?br />
    通常有两�U�方法可以扩展collection 来满���一些需要：�l�承某种集合�c�d��和封装某�U�集合类型。第一�U�的优点是初始化的时候在内存中只产生一个对象，�q�是�l�承�Ҏ��决定的。后者的优点是我们可以方便控制被���装集合的各�U�属性�?br />
Whenever possible, it’s desirable to bury implementation details inside of a class rather than exposing client code to such details。例�Q?br />
�?�Q?br />
public class Student {

    private String name;

    private String studentId;  

    private ArrayList transcript; //成�W报告�?br />
    public void addTranscriptEntry(TranscriptEntry te) {   // 操作transcript辑ֈ�记录成�W

        // Store the TranscriptEntry in our ArrayList.

        transcript.add(te);

    }

}

客户端调用代码：

Student s = new Student("1234567", "James Huddleston");

Course c = new Course("LANG 800", "Advanced Language Studies");

TranscriptEntry te = new TranscriptEntry(c, "Fall 2006", "B+");

s.addTranscriptEntry(te);

�?�Q?br />
建立新对象，���装一个ArrayList�Q?br />
public class Transcript {

    private ArrayList transcriptEntries;

    public void courseCompleted(Course c, String semester, String grade) {

        // Instantiate and insert a brand-new TranscriptEntry object into the

        // ArrayList - details hidden away!

        transcriptEntries.add(new TranscriptEntry(c, semester, grade);

    }

}

public class Student {

    private String name;

    private String studentId;

    // This used to be declared as an ArrayList.

    private Transcript transcript;

    // etc.

}

客户端代码：

s.courseCompleted(c, "Spring 2006", "A+");

�W�二�U�方法��Student处理更少的细节，不用���transcripts怎么表达�Q�看不到TranscriptEntry的存在。客��L��代码更简单�?


yuxh 2009-12-10 11:38 发表评论


Beginning Java Objects
yuxh — Tue, 08 Dec 2009 08:57:00 GMT
Aggregation is a special form of association, alternatively referred to as the “consists of”, “is composed of”, or “has a” relationship.Like an association, an aggregation is used to represent a relationship between two classes, A and B. But, with an aggregation, we’re representing more than mere relationship: we’re stating that an object belonging to class A, known as an aggregate,is composed of, or contains, component objects belonging to class B.

  Note that these aggregation statements appear very similar to associations, where the name of the association just so happens to be is composed of or contains. That’s because an aggregation is an association in the broad sense of the term�Q�aggregation 是association的一�U�特�D�表现�Ş式）!aggregation 和associations UML表现不同但最�l�代码表现�Ş式一�?br />
  Composition is a strong form of aggregation, in which the “parts” cannot exist without the “whole.” As an example, given the relationship “a Book is composed of many Chapters”, we could argue that a chapter cannot exist if the book to which it belongs ceases to exist; whereas given the relationship “a Car is composed of many Wheels”, we know that a wheel can be removed from a car and still serve a useful purpose. Thus, we’d categorize the Book–Chapter relationship as composition and the Car–Wheel relationship as aggregation.

�l�承没留意的好处�Q?br />
• Best of all, we can derive a new class from an existing class even if we don’t own the source code for the latter! As long as we have the compiled bytecode version of a class, the inheritance mechanism works just fine; we don’t need the original source code of a class in order to extend it. This is one of the most dramatic ways to achieve productivity with an objectoriented language: find a class (either one written by someone else or one that is built into the language) that does much of what you need, and create a subclass of that class,adding just those features that you need for your own purposes.

• classification is the natural way that humans organize information; so, it only makes sense that we’d organize software along the same lines, making it much more intuitive and hence easier to develop, maintain,extend, and communicate with users about.

�l�承与Association, aggregation异同�Q�P186�Q�：

Association, aggregation, and inheritance are all said to be relationships between classes. Where inheritance differs from association and aggregation is at the object level.inheritance is indeed a relationship between classes, but not between distinct objects.

注意�Q�避免连锁反应，Whenever possible, avoid adding features to non-leaf classes once they have been established in code form in an application, to avoid ripple effects throughout an inheritance hierarchy. 说比做容易，�q�就要求在编码之前尽可多的花旉���在需求分析和对象建模阶段�Q�虽然不能避免新需求出玎ͼ�但至���避免忽视遗漏了当前的需求�?

     Overriding:子类�l�承父类�Q�重写唯一能改变的是方法的讉K��控制�Q�而且只能比父�c�L��宽松�Q�如父类用的是private�Q�子�c�d��以用public。参考了下thinking in java 4th P202 发现�q�种说法不对�Q�而且是一�?span style="color: red">陷阱�Q�父�cȝ��该方法根本对子类不可见！子类的该�Ҏ��实际上是一个全新的�Ҏ���Q�连重蝲都算不上。所以只能重写non-private�Ҏ��。遇到private�Ҏ��你得���心�Q�没有编译错误，但不会像你想象的工作�Q�最好给�Ҏ��重新取名�Q�避免陷阱�?br />


不要做的事情�Q?br />
We shouldn’t change the semantics—that is, the intention, or meaning—of a feature.For example:

• If the print method of a superclass such as Student is intended to display the values of all of an object’s attributes in the command window, then the print method of a subclass such as GraduateStudent shouldn’t, for example, be overridden so that it directs all of its output to a file instead.

• If the name attribute of a superclass such as Person is intended to store a person’s name in “last name, first name” order, then the name attribute of a subclass such as Student should be used in the same fashion.

  We can’t physically eliminate features, nor should we effectively eliminate them by ignoring them. To attempt to do so would break the spirit of the “is a” hierarchy. By definition, inheritance requires that all features of all ancestors of a class A must also apply to class A itself in order for A to truly be a proper subclass. If a GraduateStudent could eliminate the degreeSought attribute that it inherits from Student, for example, is a GraduateStudent really a Student after all? Strictly speaking, the answer is no.

  �q�一步从实用角度��_��如果我们重写一个方法但不在�q�方法里做�Q何事情，其他�l�承我们�cȝ��人就会出问题�Q�他们觉得我们的�Ҏ��是有意义的（特别是他们不能看到我们源代码的时候）。而我们则打破�?#8220;is a” 原则�Q�所以绝不要�q�样做！

      protected关键字的�q�用�Q�用于控制��承的讉K��控制�?br />
     �q�用super(arguments) 减少子类构造函数重复父�c�L��造函��C��码，和this�c�M��必须在构造函数最开始调用�?br />
Student s = new Student("Fred", "123-45-6789"); 执行�q�段代码�Q�Object的构造函��C��自动执行�Q�接着Student 的父�c�Person构造函��C���l�，然后是我们调用的Student构造函敎ͼ�如果调用的Student构造函数没有显�C����用父�c�L��造函敎ͼ�则相当于默认调用super() �?br />
java没有�cȝ��多��承，多��承很复杂的一点，如果两个父类都有相同的方法，子类怎么处理�Q?


yuxh 2009-12-08 16:57 发表评论


yuxh — Sun, 06 Dec 2009 14:19:00 GMT
We may wish to instantiate additional objects related to the Student object:

初始化与对象相关的一些额外对象：

public class Student() {

    // Every Student maintains a handle on his/her own individual Transcript object.

    private Transcript transcript;

    public Student() {

        // Create a new Transcript object for this new Student.

        transcript = new Transcript();

        // etc.

    }

}

��d��数据库来初始化对象属性：

public class Student {

    // Attributes.

    String studentId;

    String name;

    double gpa;

    // etc.

    // Constructor.

    public Student(String id) {

        studentId = id;

        // Pseudocode.

        use studentId as a primary key to retrieve data from the Student table of a

        relational database;

        if (studentId found in Student table) {

           retrieve all data in the Student record;

            name = name retrieved from database;

            gpa = value retrieved from database;

        // etc.

        }

    }

// etc.

}
和其他已存在的对象交���：

public class Student {

    // Details omitted.

    // Constructor.

    public Student(String major) {

        // Alert the student's designated major department that a new student has

        // joined the university.

        // Pseudocode.

        majorDept.notify(about this student ...);

    // etc.

    }

    // etc.

}



好习惯：如果需要有参数的构造函敎ͼ�最好同时显�C�声明一个无参构造函数�?br />
�Ҏ��出现的bug�Q�如果给构造函数加上void�~�译会通过�Q�不�q�会被当作方法而不是构造函敎ͼ�

当有多个构造函敎ͼ�而且都有共同的初始化内容�Ӟ����׃��出现很多重复的代码，比如构造一个新学生�Q�我们会做：

1 通知登记办公室学生的存在

2 �l�学生创建学生成�l�报告单

重复引�v以后修改必须修改多处�Q�如果��用this 会得到改�?/p>
public class Student {

 // Attribute details omitted.

 // Constructor #1.

 public Student() {

// Assign default values to selected attributes ... details omitted.

// Do the things common to all three constructors in this first

// constructor ...

// Pseudocode.

alert the registrar's office of this student's existence

// Create a transcript for this student.

transcript = new Transcript();

}
 // Constructor #2.

 public Student(String s) {

  // ... then, REUSE the code of the first constructor within the second!

  this();

  // Then, do whatever else extra is necessary for constructor #2.

  this.setSsn(s);

 }
 // Constructor #3.

 public Student(String s, String n, int i) {

  // ... and REUSE the code of the first constructor within the third!

  this();

  // Then, do whatever else extra is necessary for constructor #3.

  this.setSsn(s);

  this.setName(n);

  this.setAge(i);

 }

 // etc.

}
注意�Q�this必须在方法最前面调用


yuxh 2009-12-06 22:19 发表评论

欧美jjzz,精品乱码一区二区三区,成人国产一区二区

Java时区处理

区分getPath(), getAbsolutePath(), getCanonicalPath()

路径斜杠处理

Java Puzzlers(�?一字符)

Java Puzzlers�Q�一表达式计��）

Beginning JO(interface/static/final)

Beginning JO(2 Collection)

Beginning Java Objects

欧美jjzz,精品乱码一区二区三区,成人国产一区二区

Java时区处理

区分getPath(), getAbsolutePath(), getCanonicalPath()

路径斜杠处理

Java Puzzlers(�?一 字符)

Java Puzzlers�Q�一 表达式计���）

Beginning JO(interface/static/final)

Beginning JO(2 Collection)

Beginning Java Objects

Java Puzzlers(�?一字符)

Java Puzzlers�Q�一表达式计��）