Java中的语法糖

最新推荐文章于 2024-09-04 15:29:36 发布

Ordinary_km

最新推荐文章于 2024-09-04 15:29:36 发布

阅读量204

点赞数 1

文章标签：反编译 java

本文链接：https://blog.csdn.net/victoryyounger/article/details/109553939

版权

前言

语法糖

语法糖是一种用来方便程序员代码开发的手段，简化程序开发，但是不会提供实质性的功能改造，但可以提高开发效率或者语法的严谨性或者减少编码出错的机会。
总而言之，语法糖可以看作是编译器实现的一种小把戏。

解语法糖

语法糖的存在主要是方便开发人员使用。但其实，Java虚拟机并不支持这些语法糖。这些语法糖在编译阶段就会被还原成简单的基础语法结构，这个过程就是解语法糖。

编译

说到编译，大家肯定都知道，Java语言中，javac命令可以将后缀名为.java的源文件编译为后缀名为.class的可以运行于Java虚拟机的字节码。

反编译

如果你去看com.sun.tools.javac.main.JavaCompiler的源码，你会发现在compile()中有一个步骤就是调用desugar()，这个方法就是负责解语法糖的实现的。

Java 中最常用的语法糖主要有泛型、变长参数、条件编译、自动拆装箱、foreach ,枚举，内部类，switch,枚举

语法糖1–泛型

如:ArrayList、Map<K,V>、public void methodName(T t)。
Java 语言中的泛型，它只在程序的源码中存在，在编译后的字节码文件中，就是已经替换为原来的原生类型(Raw Type，也称为裸类型)了，并且在相应的地方插入了强制转换代码，因此，对于运行期的java语言来说，ArrayList与ArrayList就是同一个类，所以泛型技术实际上是java语言的一颗语法糖，java语言中的泛型实现方法称为类型擦除，基于这种方法实现的泛型称为伪泛型。

 private static void demo1() {
        Map<String, String> map = new HashMap<>();
        map.put("你好","恩");
        map.put("在吗", "吃了没？");
        System.out.println(map.get("你好"));
        System.out.println(map.get("在吗"));
    }

反编译结果

private static void demo1() {
    HashMap map = new HashMap();
    map.put("你好", "恩!");
    map.put("在吗", "吃了没？");
    System.out.println((String)map.get("你好"));
    System.out.println((String)map.get("在吗"));
}

语法糖2–变长参数

private static void demo1() {
    method1("123", "456","789");
}
private static void method1(String... str) {
    System.out.println(Arrays.toString(str));
}

反编译结果

private static void demo() {
   method(new String[]{"123", "456"."789"});
}
private static void method(String[] str) {
    System.out.println(Arrays.toString(str));
}

语法糖3–条件编译

    public static void main(String[] args) {
     private static final int NUMBER_INT = 1;
        if (true) {
            System.out.println("JAVA");
        }
        if (false) {
            System.out.println("JAVAEE");
        } 
        if (NUMBER_INT == 1){
            System.out.println("NUMBER_INT == 1");
         }
    }

反编译结果

      System.out.println("JAVA");
      System.out.println("NUMBER_INT == 1");

语法糖–4自动拆装箱

   Integer a = 0;
   int b = a;

反编译结果

Integer a = Integer.valueof(0);
int b = a.intValue();

语法糖–5 ForEach循环

集合

private static void demo() {
    List<String> list = new LinkedList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    for (String str : list) {
        System.out.println(str);
    }
}

反编译结果

private static void demo() {
    List list = new LinkedList();
    list.add("a");
    list.add("b");
    list.add("c");
    for (Iterator iterator =list.iterator();iterator.hasNext()) {
    System.out.println((String)iterator.next());
           }
 }

数组

  private static void demo() {
    int[] array = {1,2,3,4};
    for (int integer : array) {
        System.out.println(integer);
   }
}

反编译结果

private static void demo() {
    int[] array;
    int[] arrinteger = array = new int[]{1, 2, 3, 4};
    int n = arrinteger.length;
    for (int i = 0; i < n; ++i) {
        int integer = arrinteger[i];
        System.out.println(integer);
    }
}

因为只是遍历所以重新定义了一个新数组，也是为什么在for each遍历的时候赋新值也不会改变的原因。

语法糖6–枚举

public enum  EnumDemo {
    SPRING,
    SUMMER,
}

反编译结果

public final class EnumDemo extends Enum
{
    private EnumDemo(String s, int i)
    {
        super(s, i);
    }
    public static EnumDemo[] values()
    {
        EnumDemo enum2[];
        int i;
        EnumDemo enum1[];
        System.arraycopy(enum2 = ENUM_VALUES, 0, enum1 = new EnumDemo[i = enum2.length], 0, i);
        return enum1;
    }

    public static EnumDemo valueOf(String s)
    {
        return (EnumDemo)Enum.valueOf(s);
    }

    public static final EnumDemo SPRING;
    public static final EnumDemo SUMMER;
    private static final EnumDemo ENUM_VALUES[];
    static
    {
        SPRING = new T("SPRING", 0);
        SUMMER = new T("SUMMER", 1);
        ENUM_VALUES = (new EnumDemo[] {
            SPRING, SUMMER
        });
    }
}

语法糖7–内部类

public class OutterClass {
    private String userName;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public static void main(String[] args) {

    }

    class InnerClass{
        private String name;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

以上代码编译后会生成两个class文件：OutterClass$InnerClass.class 、OutterClass.class 。
当我们尝试使用jad对OutterClass.class文件进行反编译的时候，他会把两个文件全部进行反编译，然后一起生成一个OutterClass.jad文件。内容如下：
反编译结果


public class OutterClass
{
    class InnerClass
    {
        public String getName()
        {
            return name;
        }
        public void setName(String name)
        {
            this.name = name;
        }
        private String name;
        final OutterClass this$0;

        InnerClass()
        {
            this.this$0 = OutterClass.this;
            super();
        }
    }

    public OutterClass()
    {
    }
    public String getUserName()
    {
        return userName;
    }
    public void setUserName(String userName){
        this.userName = userName;
    }
    public static void main(String args1[])
    {
    }
    private String userName;
}

语法糖8-- switch 支持 String 与枚举

字符串

public class switchDemoString {
    public static void main(String[] args) {
        String str = "world";
        switch (str) {
        case "hello":
            System.out.println("hello");
            break;
        case "world":
            System.out.println("world");
            break;
        default:
            break;
        }
    }
}

反编译结果

public class switchDemoString
{
    public switchDemoString()
    {
    }
    public static void main(String args[])
    {
        String str = "world";
        String s;
        switch((s = str).hashCode())
        {
        default:
            break;
        case 99162322:
            if(s.equals("hello"))
                System.out.println("hello");
            break;
        case 113318802:
            if(s.equals("world"))
                System.out.println("world");
            break;
        }
    }
}

Java中的swith自身原本就支持基本类型。比如int、char等。
对于int类型，直接进行数值的比较。对于char类型则是比较其ascii码。所以，对于编译器来说，switch中其实只能使用整型，任何类型的比较都要转换成整型。比如byte。short，char(ascii码是整型)以及int。switch是通过equals()和hashCode()方法来实现的.
仔细看下可以发现，进行switch的实际是哈希值，然后通过使用equals方法比较进行安全检查，这个检查是必要的，因为哈希可能会发生碰撞。

枚举

class enum Enum{
      A,B,C,D;
}
public class Demo{
     Enum grade = Enum.A;
        switch (grade) {
            case A:
                System.out.println("Excellent");
                break;
            case B:
                System.out.println("Good");
                break;
            case C:
                System.out.println("Not bad");
                break;
            case D:
                System.out.println("Not good");
                break;
            default:
                System.out.println("unknown");
        }
 }

反编译结果

class enum Enum{
      A,B,C,D;
}
public class Demo{
     Enum grade = Enum.A;
        switch (grad.ordinal()) {
            case 0:
                System.out.println("Excellent");
                break;
            case 1:
                System.out.println("Good");
                break;
            case 2:
                System.out.println("Not bad");
                break;
            case 3:
                System.out.println("Not good");
                break;
            default:
                System.out.println("unknown");
        }
 }

可见枚举的反编译匹配是根据父类里面的 public final int ordinal()方法获取的值

总结网上的，加了一点自己的理解

Ordinary_km

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
Java中的语法糖

前言语法糖语法糖是一种用来方便程序员代码开发的手段，简化程序开发，但是不会提供实质性的功能改造，但可以提高开发效率或者语法的严谨性或者减少编码出错的机会。总而言之，语法糖可以看作是编译器实现的一种小把戏。解语法糖语法糖的存在主要是方便开发人员使用。但其实，Java虚拟机并不支持这些语法糖。这些语法糖在编译阶段就会被还原成简单的基础语法结构，这个过程就是解语法糖。编译说到编译，大家肯定都知道，Java语言中，javac命令可以将后缀名为.java的源文件编译为后缀名为.class的可以运行于Ja
复制链接

扫一扫