format code

Author: maskleo

ch04/04_How_Erasure_Works.md

@@ -23,81 +23,86 @@
 例如，这里有一个有两种便利方法的类。 一个将整数列表中的每个整数加在一起，另一个将字符串列表中的每个字符串连接在一起：	
 
 ```java
-   class Overloaded {
-     public static int sum(List<Integer> ints) {
-       int sum = 0;
-	   for (int i : ints) sum += i;
-	   return sum;
-     }
-     public static String sum(List<String> strings) {
-       StringBuffer sum = new StringBuffer();
-       for (String s : strings) sum.append(s);
-       return sum.toString();
-     }
+class Overloaded {
+  public static int sum(List<Integer> ints) {
+    int sum = 0;
+    for (int i : ints) 
+      sum += i;
+    return sum;
   }
+  public static String sum(List<String> strings) {
+    StringBuffer sum = new StringBuffer();
+    for (String s : strings) 
+      sum.append(s);
+    return sum.toString();
+  }
+}
 ```
 
 这按预期工作：
 
 ```java
-   assert sum(Arrays.asList(1,2,3)) == 6;
-   assert sum(Arrays.asList("a","b")).equals("ab");
+assert sum(Arrays.asList(1,2,3)) == 6;
+assert sum(Arrays.asList("a","b")).equals("ab");
 ```
 
 以下是两种方法签名的删除：
 
 ```java
-  int sum(List)
-  String sum(List)
+int sum(List)
+String sum(List)
 ```
 
 这两种方法有不同的返回类型，这足以让 `Java` 区分它们。
 
 但是，假设我们改变了方法，以便每个方法都将其结果附加到参数列表的末尾，而不是返回一个值：
 
 ```java
-   class Overloaded2 {
-     // 编译时错误，不能重载两个擦除相同的方法
-	 public static boolean allZero(List<Integer> ints) {
-	   for (int i : ints) if (i != 0) return false;
-	     return true;
-	 }
-	 public static boolean allZero(List<String> strings) {
-	  for (String s : strings) if (s.length() != 0) return false;
-		return true;
-	 }
-   }
+class Overloaded2 {
+  // 编译时错误，不能重载两个擦除相同的方法
+  public static boolean allZero(List<Integer> ints) {
+    for (int i : ints) if (i != 0) return false;
+    return true;
+  }
+  public static boolean allZero(List<String> strings) {
+    for (String s : strings) if (s.length() != 0) 
+      return false;
+    return true;
+  }
+}
 ```
 
 我们打算让这个代码工作如下：
 
 ```java
-   assert allZero(Arrays.asList(0,0,0));
-   assert allZero(Arrays.asList("","",""));
+assert allZero(Arrays.asList(0,0,0));
+assert allZero(Arrays.asList("","",""));
 ```
 
 但是，在这种情况下，两种方法的签名的删除是相同的：
 
 ```java
-   boolean allZero(List)
+boolean allZero(List)
 ```
 
 因此，编译时会报告名称冲突。 不可能给两个方法使用相同的名称，并尝试通过重载来区分它们，因为在擦除之后不可能区分一个方法调用和另一个方法调用。
 
 再举一个例子，这里是整数类的一个不好的版本，它试图使一个整数与一个整数或一个长整数进行比较：
 
 ```java
-   class Integer implements Comparable<Integer>, Comparable<Long> {
-     // 编译时错误，不能实现两个擦除相同的接口
-     private final int value;
-     public Integer(int value) { this.value = value; }
-     public int compareTo(Integer i) {
-       return (value < i.value) ? -1 : (value == i.value) ? 0 : 1;
-     }
-     public int compareTo(Long l) {
-       return (value < l.value) ? -1 : (value == l.value) ? 0 : 1;
-     }
-   }
+class Integer implements Comparable<Integer>, Comparable<Long> {
+  // 编译时错误，不能实现两个擦除相同的接口
+  private final int value;
+  public Integer(int value) { 
+    this.value = value; 
+  }
+  public int compareTo(Integer i) {
+    return (value < i.value) ? -1 : (value == i.value) ? 0 : 1;
+  } 
+  public int compareTo(Long l) {
+    return (value < l.value) ? -1 : (value == l.value) ? 0 : 1;
+  }
+}
 ```
 
 如果这得到支持，通常需要对桥接方法进行复杂而混乱的定义（参见第 `3.7` 节）。 到目前为止，最简单和最容易理解的选择是禁止这种情况。