java 会默认做的那些事-阿里云开发者社区

java 会默认做的那些事

2020-04-18 855

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介：

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

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 修饰

java 会默认做的那些事

反编译过后可以看到

从反编译中能看出

自定义枚举类

自定义注解

还有一些常识

Integer.valueOf() 的实现

热门文章

最新文章

相关课程

相关电子书

相关实验场景