语法糖(syntactic suger)–简书

--write by zhuwx 2019-06-24 20:57:55 +0800 CST

点击量:10

96

北风第一支关注2017.05.29 23:04* 字数 554 阅读 180评论 0喜欢 0

语法糖(Syntactic Sugar),也叫糖衣语法,是英国计算机科学家彼得·约翰·兰达(Peter J. Landin)发明的一个术语。指的是,在计算机语言中添加某种语法,这种语法能使程序员更方便的使用语言开发程序,同时增强程序代码的可读性,避免出错的机会;但是这种语法对语言的功能并没有影响。

泛型

与C#中的泛型相比,Java的泛型可以算是“伪泛型”了。在C#中,不论是在程序源码中、在编译后的中间语言,还是在运行期泛型都是真实存在的。Java则不同,Java的泛型只在源代码存在,只供编辑器检查使用,编译后的字节码文件已擦除了泛型类型,同时在必要的地方插入了强制转型的代码。
源码:

 private void showLists(){
        List<String> stringList = new ArrayList<String>();
        stringList.add('oliver');
        System.out.println(stringList.get(0));
    }

编译后:

    private void showLists() {
        ArrayList stringList = new ArrayList();
        stringList.add('oliver');
        System.out.println((String)stringList.get(0));
    }

自动拆箱/装箱

自动拆箱/装箱是在编译期,依据代码的语法,决定是否进行拆箱和装箱动作。
装箱过程:把基本类型用它们对应的包装类型进行包装,使基本类型具有对象特征。
拆箱过程:与装箱过程相反,把包装类型转换成基本类型。
需要注意的是:包装类型的“==”运算在没有遇到算数运算符的情况下不会自动拆箱,而其包装类型的equals()方法不会处理数据类型转换:

    public void packing(){
        int a =2 ;
        int b =2;
        System.out.println( a ==b );
    }

==>

    public void packing() {
        byte a = 2; //没有拆装箱
        byte b = 2;
        System.out.println(a == b);
    }

而:

    public void packing(){
        Integer a =2 ;
        Integer b =2;
        System.out.println( a ==b );
    }

==>

    public void packing() {
        Integer a = Integer.valueOf(2); //自动装箱
        Integer b = Integer.valueOf(2);
        System.out.println(a == b);
    }

再;

    public void packing(){
        Long a =2L ;
        long b =2L;
        System.out.println( a + b );
    }

==>

    public void packing() {
        Long a = Long.valueOf(2L); //自动装箱
        long b = 2L;
        System.out.println(a.longValue() + b); //自动拆箱
    }

注意:

    public void intTransgfer(){
        int a =2 ;
        String a1 = a+'';
        transfer0(a);
        transfer1(a1);
        System.out.println('now a is ' + a);
        System.out.println('now a1 is ' + a1);
    }
   private void  transfer0(int a ){
       a = a +1 ;
       System.out.println('transfered a is ' + a);
   }
    private void  transfer1(String  a ){
        a = a +1 ;
        System.out.println('transfered a1 is ' + a);
    }
transfered a is 3
transfered a1 is 21
now a is 2
now a1 is 2

从上面看出,a和a1并没有发生改变,说明a和a1在内存中是常量不会改变的,除非return 重新指定引用地址。要么封装在一个对象中,依靠对象的引用地址来获取新值。

循环历遍

    public  void foreachs(){
        List<Integer> list = new ArrayList<Integer>();
        for(Integer num : list){
            System.out.println(num);
        }
    }

==>

    public void foreachs() {
        ArrayList list = new ArrayList();
        Iterator var2 = list.iterator();
        while(var2.hasNext()) {
            Integer num = (Integer)var2.next();
            System.out.println(num);
        }
    }

条件语句

    public  void ifs(){
        if(true){ //永真
            System.out.println('oliver');
        }else{
            System.out.println('lee');
        }
    }

==>

    public void ifs() {
        System.out.println('oliver');
    }

在编译器中,将会把分支不成立的代码消除

枚举

public enum EnumTest {
    OLIVER,LEE;
}

==>

public enum EnumTest {
    OLIVER,
    LEE;
    private EnumTest() { //添加了构造方法
    }
}

内部类

在jdk8 无特征..