java 会默认做的那些事

这是一个基础类的源码文件

public class Demo { public static void main(String[] args) { System.out.println("HelloWorld!"); } }

反编译过后的

# javap -c Demo Compiled from "Demo.java" public class Demo extends java.lang.Object{ public Demo(); Code: 0: aload_0 1: invokespecial #1; //Method java/lang/Object."<init>":()V 4: return public static void main(java.lang.String[]); Code: 0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream; 3: ldc #3; //String helloWorld! 5: invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 8: return }

反编译过后可以看到

• 自定义一个类会默认继承 java.lang.Object, 这也是 Object 利用多态能接受任意对象的原因
• 一个类中会默认有一个构造方法，他的默认实现是调用到父类的空构造方法
• 当你自定义了一个构造方法后jdk就不会默认给你加空构造了
• 这里要注意构造方法中super(...)一定是第一行代码，就算你不写super(...)她会默认调用父类的空构造

接下来在来看一段源码

import java.util.Arrays; import java.util.List; public class Demo { public static void main(String[] args) { List<String> list = Arrays.asList("Java", "JavaME", "JavaSE", "JavaEE"); String data = ""; for (String s : list) { data += s + ","; } System.out.println(data); } }

反编译后的结果为

# javap -c Demo Compiled from "Demo.java" public class Demo extends java.lang.Object{ public Demo(); Code: 0: aload_0 1: invokespecial #1; //Method java/lang/Object."<init>":()V 4: return public static void main(java.lang.String[]); Code: 0: iconst_4 1: anewarray #2; //class java/lang/String 4: dup 5: iconst_0 6: ldc #3; //String Java 8: aastore 9: dup 10: iconst_1 11: ldc #4; //String JavaME 13: aastore 14: dup 15: iconst_2 16: ldc #5; //String JavaSE 18: aastore 19: dup 20: iconst_3 21: ldc #6; //String JavaEE 23: aastore 24: invokestatic #7; //Method java/util/Arrays.asList:([Ljava/lang/Object;)Ljava/util/List; 27: astore_1 28: ldc #8; //String 30: astore_2 31: aload_1 32: invokeinterface #9, 1; //InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator; 37: astore_3 38: aload_3 39: invokeinterface #10, 1; //InterfaceMethod java/util/Iterator.hasNext:()Z 44: ifeq 86 47: aload_3 48: invokeinterface #11, 1; //InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object; 53: checkcast #2; //class java/lang/String 56: astore 4 58: new #12; //class java/lang/StringBuilder 61: dup 62: invokespecial #13; //Method java/lang/StringBuilder."<init>":()V 65: aload_2 66: invokevirtual #14; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder; 69: aload 4 71: invokevirtual #14; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder; 74: ldc #15; //String , 76: invokevirtual #14; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder; 79: invokevirtual #16; //Method java/lang/StringBuilder.toString:()Ljava/lang/String; 82: astore_2 83: goto 38 86: getstatic #17; //Field java/lang/System.out:Ljava/io/PrintStream; 89: aload_2 90: invokevirtual #18; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 93: return }

从反编译中能看出

• 关于字符串拼接

  • 在少量字符串拼接时jdk会默认给我们转成StringBuilder来实现，这也是为什么少量字符串拼接可以使用String对象的原因

• 在使用 for (String s : list) {}时

  • 会默认调用到java.util.Iterator接口中的方法

  • 我们自定义类如果想使用这种迭代方式就需要满足一下两种条件

    • 是集合架构中的一员
    • 自定义实现Iterator中的方法

自定义枚举类

public enum Demo { SUCCESS(0, "成功"), ERROR(1, "失败"); private Integer code; private String msg; Demo(Integer code, String msg) { this.code = code; this.msg = msg; } }

反编译枚举后可以看到

# javap Demo Compiled from "Demo.java" public final class Demo extends java.lang.Enum{ public static final Demo SUCCESS; public static final Demo ERROR; public static final Demo[] values(); public static Demo valueOf(java.lang.String); static {}; }

从反编译结果中可以看到

• 枚举类实际上是一个加了 final class 他会默认继承自java.lang.Enum
• 每一个枚举类型都会转成 public static final 的对象

自定义注解

import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface Demo { String value(); }

反编译的结果

# javap Demo Compiled from "Demo.java" public interface Demo extends java.lang.annotation.Annotation{ public abstract java.lang.String value(); }

从反编译结果中可以看出

• 可以看出注解会默认继承java.lang.annotation.Annotation
• 一个属性就是一个抽象方法

还有一些常识

• Java 会默认导入 java.lang 包

  • 这个自动导入使得我们在使用 Integer,Object,System 等类的时候不需要手动导包
• System.out.println(); 的时候会默认调用到对象中的 toString(); 方法

• HashSet在存储时会默认调用到对象的hashCode()::equals()方法

  • HashSet 在判断元素重复时借助了hashCode()的hash算法来筛选掉一批不重复的数据
  • 在hash值相等的时候在借助equals()判断是否重复如果重复就不录入了
  • 为什么要使用到两个方法来判断是否重复这里是hash算法的一个特点了, 在HashMap中如果hash值相等值不相等就会在hash表中形成一个hash链

• TreeSet在存储时，要求元素实现Comparable接口

  • TreeSet使用了树状结构需要使用到 java.lang.Comparable#compareTo 方法的返回值
  • 通过返回来决定元素是否重复: [0元素重复,<0左子树,>0右子树]

Integer 的自动封装和catch

先来看一段源码代码

Integer val1 = 1; Integer val2 = 1; System.out.println(val1 == val2); Integer val3 = 996; Integer val4 = 996; System.out.println(val3 == val4);

反编译结果

# javap -c Demo Compiled from "Demo.java" public class Demo { public Demo(); Code: 0: aload_0 1: invokespecial #1 // Method java/lang/Object."<init>":()V 4: return public static void main(java.lang.String[]); Code: 0: iconst_1 1: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; 4: astore_1 5: iconst_1 6: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; 9: astore_2 10: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream; 13: aload_1 14: aload_2 15: if_acmpne 22 18: iconst_1 19: goto 23 22: iconst_0 23: invokevirtual #4 // Method java/io/PrintStream.println:(Z)V 26: sipush 996 29: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; 32: astore_3 33: sipush 996 36: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; 39: astore 4 41: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream; 44: aload_3 45: aload 4 47: if_acmpne 54 50: iconst_1 51: goto 55 54: iconst_0 55: invokevirtual #4 // Method java/io/PrintStream.println:(Z)V 58: return }

• 在Integer类型自动拆装箱实际上是使用了Integer.valueOf()方法
• 我们可以通过了解 valueOf() 的源码来理解 Integer -128~127缓存

Integer.valueOf() 的实现

public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); }

Integer缓存核心实现

private static class IntegerCache { static final int low = -128; static final int high; static final Integer cache[]; static { // high value may be configured by property int h = 127; String integerCacheHighPropValue = sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high"); if (integerCacheHighPropValue != null) { try { int i = parseInt(integerCacheHighPropValue); i = Math.max(i, 127); // Maximum array size is Integer.MAX_VALUE h = Math.min(i, Integer.MAX_VALUE - (-low) -1); } catch( NumberFormatException nfe) { // If the property cannot be parsed into an int, ignore it. } } high = h; cache = new Integer[(high - low) + 1]; int j = low; for(int k = 0; k < cache.length; k++) cache[k] = new Integer(j++); // range [-128, 127] must be interned (JLS7 5.1.7) assert IntegerCache.high >= 127; } private IntegerCache() {} }

内部类访问变量时的隐式操作

public static void main(String[] args) { String str = "hello"; new Transfer() { @Override void transfer() { System.out.println(str); str = "world!"; System.out.println(str); } }.transfer(); } public static abstract class Transfer { abstract void transfer(); }

• 在案例中 String 类型的 str 实际上会隐式的给我们加上 final 修饰