语法糖(Syntactic Sugar)

语法糖（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 无特征..