Java基础方面陷阱

1判断是否是奇数

public static boolean  isOdd( int i ){

          return  i  % 2 != 0;  // return i % 2 ==1(如果是负数这就错了)

    }

     public  static  void  main(String[]  args ) {

         for ( int  i  = -10;  i  <= 10;  i ++) {

            System. out .println(isOdd( i ));

        }

    }

2.比较2个浮点数

public  static  void  main(String[]  args ) {

        System. out .println(2.0-1.1);    // 0.8999999999999999

        System. out .println( new  BigDecimal( "2.0" ).subtract( new  BigDecimal( "1.1" ))); //0.9

        System. out .printf( "%.1f" , 2.0-1.1);  //0.9(格式化)

    }

3.长整型后面要加L

public  static  void  main(String[]  args ) {

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

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

        System. out .println( MICROS_PER_DAY / MILLIS_PER_DAY );  //1000,如果不加L就是5

    }

4.交换数据

public  static  void  main(String[]  args ) {

         int  x  = 1984;

         int  y  = 2001;

         /*y=(x^= (y^= x))^ y;

        System.out.println("x= " + x + "; y= " + y); */

         x = x ^ y ;

         y = x ^ y ;

         x = x ^ y ;

        System. out .println( "x= "  +  x  +  "; y= "  +  y );

        

    }

5.char类型会自动转为int

public  static  void  main(String[]  args ) {

        System. out .println( "H"  +  "a" );    //Ha

        System. out .println( 'H'  +  'a' );   // 169

    }

6.和字符串拼接

public  static  void  main(String[]  args ) {

      String  letters  =  "ABC" ;

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

      System. out .println( letters  +  " easy as " + numbers );  // ABC easy as [C@15db9742

      System. out .println( numbers );  // 123

    }

7.转义字符

public  static  void  main(String[]  args ) {

         // \u0022 是双引号的 Unicode转义字符

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

        System. out .println( "a" .length() + "b" .length());             //2

    }

8.打印输出类名

public  static  void  main(String[]  args ) {

          System. out .println(

                  MyClass. class .getName().

                      replaceAll( "\\." , "/" ) +  ".class" );  //不加\\就是这样( ///.class )no8/MyClass.class

    }

9.随机数问题

  private  static  Random  rnd  =  new  Random();

     public  static  void  main(String[]  args ) {

         StringBuffer  word  =  null ;

          switch ( rnd .nextInt(3)) {  //是0~2之间

              case  1:   word  =  new  StringBuffer( "P" ); break ;  //如果是'p'会转为int那就是他的容量了

              case  2:   word  =  new  StringBuffer( "G" ); break ;

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

         }

          word .append( 'a' );

          word .append( 'i' );

          word .append( 'n' );

         System. out .println( word );  //如果'p'这种形式答案就是ain ,所以要加""

    }

10.无情的增量操作

public  static  void  main(String[]  args ) {

         int  j  = 0;

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

             j =  j ++;

        }

        System. out .println( j );   //0

    }

11.整数边界的问题

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 ++)   //如果是i<=END 那就进入死循环了, MAX_VALUE会变为负数

               count ++;

          System. out .println( count );  //100

    }

12  计数器的问题

public  static  void  main(String[]  args ) {

       int  minutes  = 0;

       for  ( int  ms  = 0;  ms  < 60*60*1000;  ms ++)

           if  ( ms  % 60*1000 == 0)

               minutes ++;

      System. out .println( minutes );   //

    }

13  优柔寡断的返回值

public  static  void  main(String[]  args ) {

          System. out .println(decision());

    }

    

     public  static  boolean  decision() {

          try  {

              return  true ;    //会捕获这个true并不会终止程序

         }  finally  {

              return  false ;     //false

         }

     } 

14  你好，再见

public  static  void  main(String[]  args ) {

         try  {

            System. out .println( "Hello world" );

            System.exit(0);     // Hello world,后面代码不会执行(虚拟机关闭了)

        }  finally  {

            System. out .println( "Goodbye world" );

        }

    }

15  到底关闭了吗

public  static  void  main(String[]  args ) {

        

    }

     public  static  void  copy(String  src , String  dest )  throws  IOException {

        InputStream  in  =  null ;

        OutputStream  out  =  null ;

         try  {

             in  =  new  FileInputStream( src );

             out  =  new  FileOutputStream( dest );

             byte []  buf  =  new  byte [1024];

             int  n ;

             while  (( n  =  in .read( buf )) > 0)

                 out .write( buf , 0,  n );

        }  finally  {

             if  ( in  !=  null ) {

                 try  {

                     in .close();   //这个可以也会抛异常

                }  catch  (Exception  e ) {

                     in = null ;

                }

            }

             if  ( out  !=  null ){

                 try  {

                     out .close();

                }  catch  (Exception  e ) {

                     out = null ;

                }

                

            }

        } 

    }

16  所有的动物都是平等的。

public  static  void  main(String[]  args ){

         final  String  pig  =  "length: 10" ;

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

        System. out . println( "Animals are equal: "

        +  pig  ==  dog );   //false  (先执行+,比较字符串用equals)

    

    }

17

public  static  void  main(String[]  args ){

         char  x  =  'X' ;

         int  i  = 0;

        System. out .println( true  ?  x  : 0);  //X

        System. out .println( false  ?  i  :  x ); //88

    

    }

( • 如果第二个和第三个操作数具有相同的类型，那么它就是条件表达式的类
型。换句话说，你可以通过绕过混合类型的计算来避免大麻烦。
• 如果一个操作数的类型是 T，T 表示 byte、short 或 char，而另一个操作
数是一个 int 类型的常量表达式，它的值是可以用类型 T 表示的，那么条
件表达式的类型就是 T。
• 否则，将对操作数类型运用二进制数字提升，而条件表达式的类型就是第
二个和第三个操作数被提升之后的类型。

)

18

/**

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

* from F:\TestRoot\apps\a1\units\include\PolicyHome.idl  (\u是个转义开始)

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

*/

public  class  Demo1{

public  static  void  main(String[] args){

System.out.print( "Hell" );

System.out.println( "o world" );

}

}//编译失败

(

（\u）表示的是一个 Unicode 转义字符的开始。遗憾

的是，这些字符后面没有紧跟四个十六进制的数字，因此，这个 Unicode 转义字
符是病构的，而编译器则被要求拒绝该程序。Unicode 转义字符必须是良构的，
即使是出现在注释中也是如此

)

19

public  class  Demo1 {

         private  Demo1(Object  o ) {

            System. out .println( "Object" );

            }

             private  Demo1( double []  dArray ) {

            System. out .println( "double array" );

            }

             public  static  void  main(String[]  args ) {

             new  Demo1( null );

            }

}

( 构造器
Confusing(Object)可以接受任何传递给 Confusing(double[ ])的参数，因此
Confusing(Object)相对缺乏精确性。（每一个 double 数组都是一个 Object，
但是每一个 Object 并不一定是一个 double 数组。）因此，最精确的构造器就是
Confusing(double[ ])，这也就解释了为什么程序会产生这样的输出。

, 要想用一个 null 参数来调用 Confusing(Object)构造器，你需要这样写代码：
new Confusing((Object)null)。这可以确保只有 Confusing(Object)是可应用
的。更一般地讲，要想强制要求编译器选择一个精确的重载版本，需要将实际的
参数转型为形式参数所声明的类型。

)