新型SEO思维就是从一个全新的层次上提升seo优化的水平,达到网络信息最佳化的展示效果!
马海祥博客 > 网站制作 > 编程语言 > 你知道Java内部的这些事儿吗?

你知道Java内部的这些事儿吗?

时间:2014-11-21   文章来源:马海祥博客   访问次数:

你是不是写Java已经有些年头了?还依稀记得这些吧:那些年,它还叫做Oak;那些年,OO还是个热门话题;那些年,C++同学们觉得Java是没有出路的;那些年,Applet还风头正劲……。

你知道Java内部的这些事儿吗?-马海祥博客

但我打赌下面的这些事中至少有一半你还不知道,今天马海祥就跟大家一起来聊聊这些会让你有些惊讶的Java内部的那些事儿吧!

1、其实没有受检异常(checked exception)

是的!JVM才不知道这类事情,只有Java语言才会知道。

今天,大家都赞同受检异常是个设计失误,一个Java语言中的设计失误,正如Bruce Eckel在布拉格的GeeCON会议上演示的总结中说的,Java之后的其它语言都没有再涉及受检异常了,甚至Java 8的新式流API(Streams API)都不再拥抱受检异常(以lambda的方式使用IO和JDBC,这个API用起来还是有些痛苦的)。

想证明JVM不理会受检异常?试试下面的这段代码:

public class Test {
      // 方法没有声明throws
      public static void main(String[] args) {
         doThrow(new SQLException());
      }
      static void doThrow(Exception e) {
         Test.<RuntimeException> doThrow0(e);
      }
      @SuppressWarnings("unchecked")
      static <E extends Exception>
      void doThrow0(Exception e) throws E {
         throw (E) e;
      }
  }

不仅可以编译通过,并且也抛出了SQLException,你甚至都不需要用上Lombok的SneakyThrows。

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

下面的代码不能编译,是吧?

class Test {
      Object x() { return "abc"; }
      String x() { return "123"; }
  }

是的!Java语言不允许一个类里有2个方法是“重载一致”的,而不会关心这2个方法的throws子句或返回类型实际是不同的。

但是等一下!来看看Class.getMethod(String, Class...)方法的Javadoc:

注意,可能在一个类中会有多个匹配的方法,因为尽管Java语言禁止在一个类中多个方法签名相同只是返回类型不同,但是JVM并不禁止,这让JVM可以更灵活地去实现各种语言特性。

比如,可以用桥方法(bridge method)来实现方法的协变返回类型;桥方法和被重载的方法可以有相同的方法签名,但返回类型不同。

嗯,这个说的通,实际上,当写了下面的代码时,就发生了这样的情况:

abstract class Parent<T> {
      abstract T x();
  }
  class Child extends Parent<String> {
      @Override
      String x() { return "abc"; }
  }

查看一下Child类所生成的字节码:

// Method descriptor #15 ()Ljava/lang/String;
  // Stack: 1, Locals: 1
  java.lang.String x();
    0  ldc <String "abc"> [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]

在字节码中,T实际上就是Object类型,这很好理解。

合成的桥方法实际上是由编译器生成的,因为在一些调用场景下,Parent.x()方法签名的返回类型期望是Object, 添加泛型而不生成这个桥方法,不可能做到二进制兼容。

所以,让JVM允许这个特性,可以愉快解决这个问题(实际上可以允许协变重载的方法包含有副作用的逻辑)。

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[][] = {{}};
  }

是不是觉得这个很2B?想象一下在上面的代码中使用JSR-308/Java 8的类型注解,语法糖的数目要爆炸了吧!

@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、你没有掌握条件表达式

你认为自己知道什么时候该使用条件表达式?面对现实吧,你还不知道,大部分人会下面的2个代码段是等价的:

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

哦!如果“需要”,条件运算符会做数值类型的类型提升,这个“需要”有非常非常非常强的引号,因为,你觉得下面的程序会抛出NullPointerException吗?

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、你没有掌握复合赋值运算符

是不是觉得不服?来看看下面的2行代码:

i += j;
  i = i + j;

直觉上认为,2行代码是等价的,对吧?但结果即不是!JLS(Java语言规范)指出:

复合赋值运算符表达式E1 op= E2等价于E1 = (T)((E1) op (E2))其中T是E1的类型,但E1只会被求值一次。

这个做法太漂亮了,请允许我引用Peter Lawrey在Stack Overflow上的回答:

使用*=或/=作为例子可以方便说明其中的转型问题:

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);
  }

然后要得到类似下面的输出(每次输出是随机结果):

92
  221
  45
  48
  236
  183
  39
  193
  33
  84

对于这个结果,你可能也是难以置信吧!难怪人们对Java的评价程度也是不一样的(具体可查看马海祥博客《关于C语言、C++、Java和Python这4种程序开发语言的评价》的相关介绍)。

7、GOTO

这条是我的最爱,Java是有GOTO的!打上这行代码:

int goto = 1;

结果是:

Test.java:44: error: <identifier> expected
      int goto = 1;
          ^

这是因为goto是个还未使用的关键字,保留了为以后可以用,但这不是我要说的让你兴奋的内容。

让你兴奋的是,你是可以用break、continue和有标签的代码块来实现goto的:

向前跳:

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是有类型别名的

在别的语言中(比如,Ceylon),可以方便地定义类型别名:

interface People => Set<Person>;

这样定义的People可以和Set<Person>互换地使用:

People?      p1 = null;
  Set<Person>? p2 = p1;
  People?      p3 = p2;

在Java中不能在顶级(top level)定义类型别名,但可以在类级别、或方法级别定义,如果对Integer、Long这样名字不满意,想更短的名字:I和L,很简单:

class Test<I extends Integer> {
      <L extends Long> void x(I i, L l) {
         System.out.println(
            i.intValue() + ", " +
            l.longValue()
         );
      }
  }

上面的代码中,在Test类级别中I是Integer的“别名”,在x方法级别,L是Long的“别名”,可以这样来调用这个方法:

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

当然这个用法不严谨,在例子中,Integer、Long都是final类型,结果I和L 效果上是个别名(大部分情况下是,赋值兼容性只是单向的),如果用非final类型(比如,Object),还是要使用原来的泛型参数类型。

玩够了这些恶心的小把戏,现在要上干货了!

9、有些类型的关系是不确定的

好,这条会很稀奇古怪,你先来杯咖啡,再集中精神来看,看看下面的2个类型:

// 一个辅助类。也可以直接使用List
  interface Type<T> {}
  class C implements Type<Type<? super C>> {}
  class D<P> implements Type<Type<? super D<D<P>>>> {}

类型C和D是啥意思呢?

这2个类型声明中包含了递归,和java.lang.Enum的声明类似(但有微妙的不同):

public abstract class Enum<E extends Enum<E>> { ... }

有了上面的类型声明,一个实际的enum实现只是语法糖:

// 这样的声明
  enum MyEnum {}
  // 实际只是下面写法的语法糖:
  class MyEnum extends Enum<MyEnum> { ... }

记住上面的这点后,回到我们的2个类型声明上,下面的代码可以编译通过吗?

class Test {
      Type<? super C> c = new C();
      Type<? super D<Byte>> d = new D<Byte>();
  }

很难的问题,Ross Tate回答过这个问题,答案实际上是不确定的:

C是Type<? super C>的子类吗?
  步骤 0) C <?: Type<? super C>
  步骤 1) Type<Type<? super C>> <?: Type (继承)
  步骤 2) C (检查通配符 ? super C)
  步骤 . . . (进入死循环)

然后:

D是Type<? super D<Byte>>的子类吗?
  步骤 0) D<Byte> <?: Type<? super C<Byte>>
  步骤 1) Type<Type<? super D<D<Byte>>>> <?: Type<? super D<Byte>>
  步骤 2) D<Byte> <?: Type<? super D<D<Byte>>>
  步骤 3) List<List<? super C<C>>> <?: List<? super C<C>>
  步骤 4) D<D<Byte>> <?: Type<? super D<D<Byte>>>
  步骤 . . . (进入永远的展开中)

试着在你的Eclipse中编译上面的代码,会Crash!(别担心,我已经提交了一个Bug)

10、类型交集(Type intersections)

Java有个很古怪的特性叫类型交集。你可以声明一个(泛型)类型,这个类型是2个类型的交集。比如:

class Test<T extends Serializable & Cloneable> {
  }

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

// 编译不通过!
  Test<String> s = null;
  // 编译通过
  Test<Date> d = null;

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

<T extends Runnable & Serializable> void execute(T t) {}

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

lambda是可以序列化的:

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

但即使满足这个条件,lambda表达式并没有自动实现Serializable这个标记接口(marker interface),为了强制成为这个类型,就必须使用转型,但如果只转型成Serializable的话:

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

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

所以,就需要同时转型成2个类型:

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

我们不得不说,Java中包含的诡异在程度上仅仅被它解决问题的能力超过。

马海祥博客点评:

Java技术具有卓越的通用性、高效性、平台移植性和安全性,广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网,同时拥有全球最大的开发者专业社群,在全球云计算和移动互联网的产业环境下,Java更具备了显著优势和广阔前景。

本文为马海祥博客原创文章,如想转载,请注明原文网址摘自于http://www.mahaixiang.cn/bcyy/925.html,注明出处;否则,禁止转载;谢谢配合!

相关热词搜索: Java

上一篇:初级Web开发技术人员必知的26项基本概念和技术
下一篇:详解Theron通过Actor模型解决C++并发编程的一种思维

今日话题更多>

SEO研究院 更多 >>