开发者资讯

1. 其实没有受检异常（checked exception）

public class Test {

 

    // 方法没有声明throws

    public static void main(String[] args) {

        doThrow(new SQLException());

    }

 

    static void doThrow(Exception e) {

        Test. doThrow0(e);

    }

 

    @SuppressWarnings("unchecked")

    static 

    void doThrow0(Exception e) throws E {

        throw (E) e;

    }

}

2. 可以有只是返回类型不同的重载方法

class Test {

    Object x() { return "abc"; }

    String x() { return "123"; }

}

abstract class Parent {

    abstract T x();

}

 

class Child extends Parent {

    @Override

    String x() { return "abc"; }

}

// Method descriptor #15 ()Ljava/lang/String;

// Stack: 1, Locals: 1

java.lang.String x();

  0  ldc  [16]

  2  areturn

    Line numbers:

      [pc: 0, line: 7]

    Local variable table:

      [pc: 0, pc: 3] local: this index: 0 type: Child

 

// Method descriptor #18 ()Ljava/lang/Object;

// Stack: 1, Locals: 1

bridge synthetic java.lang.Object x();

  0  aload_0 [this]

  1  invokevirtual Child.x() : java.lang.String [19]

  4  areturn

    Line numbers:

      [pc: 0, line: 1]

3. 所有这些写法都是二维数组！

class Test {

    int[][] a()  { return new int[0][]; }

    int[] b() [] { return new int[0][]; }

    int c() [][] { return new int[0][]; }

}

class Test {

    int[][] a = {{}};

    int[] b[] = {{}};

    int c[][] = {{}};

}

@Target(ElementType.TYPE_USE)

@interface Crazy {}

 

class Test {

    @Crazy int[][]  a1 = {{}};

    int @Crazy [][] a2 = {{}};

    int[] @Crazy [] a3 = {{}};

 

    @Crazy int[] b1[]  = {{}};

    int @Crazy [] b2[] = {{}};

    int[] b3 @Crazy [] = {{}};

 

    @Crazy int c1[][]  = {{}};

    int c2 @Crazy [][] = {{}};

    int c3[] @Crazy [] = {{}};

}

在我4周休假前的最后一个提交里，我写了这样的代码，然后。。。

【译注：然后，亲爱的同事你，就有得火救啦，哼，哼哼，哦哈哈哈哈～】

4. 你没有掌握条件表达式

Object o1 = true ? new Integer(1) : new Double(2.0);

Object o2;

 

if (true)

    o2 = new Integer(1);

else

    o2 = new Double(2.0);

System.out.println(o1);

System.out.println(o2);

1.0

1

Integer i = new Integer(1);

if (i.equals(1))

    i = null;

Double d = new Double(2.0);

Object o = true ? i : d; // NullPointerException!

System.out.println(o);

5. 你没有掌握复合赋值运算符

i += j;

i = i + j;

byte b = 10;

b *= 5.7;

System.out.println(b); // prints 57

 

byte b = 100;

b /= 2.5;

System.out.println(b); // prints 40

 

char ch = '0';

ch *= 1.1;

System.out.println(ch); // prints '4'

 

char ch = 'A';

ch *= 1.5;

System.out.println(ch); // prints 'a'

6. 随机Integer

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

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

}

【译注：然后，亲爱的同事你，就有得火救啦，哼，哼哼，哦哈哈哈哈～】

7. GOTO

int goto = 1;

Test.java:44: error:  expected

    int goto = 1;

        ^

label: {

  // do stuff

  if (check) break label;

  // do more stuff

}

2  iload_1 [check]

3  ifeq 6          // 向前跳

6  ..

label: do {

  // do stuff

  if (check) continue label;

  // do more stuff

  break label;

} while(true);

2  iload_1 [check]

3  ifeq 9

6  goto 2          // 向后跳

9  ..

8. Java是有类型别名的

interface People => Set

People?      p1 = null;

Set? p2 = p1;

People?      p3 = p2;

class Test {

     void x(I i, L l) {

        System.out.println(

            i.intValue() + ", " + 

            l.longValue()

        );

    }

}

new Test().x(1, 2L);

// 一个辅助类。也可以直接使用List

interface Type {}

 

class C implements Type> {}

class D
 implements Type>>> {}

public abstract class Enum> { ... }

enum MyEnum {}

class MyEnum extends Enum { ... }

class Test {

    Type c = new C();

    Type> d = new D();

}

步骤 0) C 

步骤 1) Type> 


然后：

 
D是Type>的子类吗？

 

步骤 0) D >

步骤 1) Type>>> >

步骤 2) D >>

步骤 3) List>> >

步骤 4) D> >>

步骤 . . . （进入永远的展开中）


试着在你的Eclipse中编译上面的代码，会Crash！（别担心，我已经提交了一个Bug。）

 

我们继续深挖下去……

 

在Java中有些类型的关系是不确定的！

如果你有兴趣知道更多古怪Java行为的细节，可以读一下Ross Tate的论文『驯服Java类型系统的通配符』 （由Ross Tate、Alan Leung和Sorin Lerner合著），或者也可以看看我们在子类型多态和泛型多态的关联方面的思索。

 
10. 类型交集（Type intersections）
 

Java有个很古怪的特性叫类型交集。你可以声明一个（泛型）类型，这个类型是2个类型的交集。比如：

 
class Test {

}


绑定到类Test的实例上的泛型类型参数T必须同时实现Serializable和Cloneable。比如，String不能做绑定，但Date可以：

 
// 编译不通过！

Test s = null;

 

// 编译通过

Test d = null;


Java 8保留了这个特性，你可以转型成临时的类型交集。这有什么用？ 几乎没有一点用，但如果你想强转一个lambda表达式成这样的一个类型，就没有其它的方法了。 假定你在方法上有了这个蛋疼的类型限制：

 
 void execute(T t) {}


你想一个Runnable同时也是个Serializable，这样你可能在另外的地方执行它并通过网络发送它。lambda和序列化都有点古怪。

 

lambda是可以序列化的：

 

如果lambda表达式的目标类型和它捕获的参数（captured arguments）是可以序列化的，则这个lambda表达式是可序列化的。

但即使满足这个条件，lambda表达式并没有自动实现Serializable这个标记接口（marker interface）。 为了强制成为这个类型，就必须使用转型。但如果只转型成Serializable …

 
execute((Serializable) (() -> {}));


… 则这个lambda表达式不再是一个Runnable。

 

呃……

 

So……

 

同时转型成2个类型：

 
execute((Runnable & Serializable) (() -> {}));


结论

 

一般我只对SQL会说这样的话，但是时候用下面的话来结束这篇文章了：

 

Java中包含的诡异在程度上仅仅被它解决问题的能力超过。

 

  

原文链接： Jooq 翻译： ImportNew.com - Jerry Lee

译文链接： http://www.importnew.com/13859.html
                

                

                    

                        

                            
收藏(3)
                            
赞(44)
                            
举报
                        
                    
                
                    分享到：