Java 7在语言语法上主要新增以下语法特性：

1、二进制整数字面量

2、使用下划线来分隔数值字面量

3、在switch语句中可使用字符串对象作为判别表达式

4、泛型实例创建时的类型推导。这里直接在泛型类的构造器前加空的<>即可，里面无需填写实际类型。

5、在一条catch语句中可捕获多个类型的异常

6、在try语句中直接跟可自动关闭的资源。这其实相当于省去了finally步骤将打开的一些资源进行关闭。

由于这些语法特性比较简单，下面我们直接提供代码示例：

    private static class MyException1 extends Throwable {

        private static final long serialVersionUID = -8490578451746711940L;

        public String getMessage() {
            return "MyException1 thrown!";
        }
    }
    
    private static class MyException2 extends Throwable {
        
        private static final long serialVersionUID = -1350192327831760913L;

        public String getMessage() {
            return "MyException2 thrown!";
        }
    }
    
    private static class MyGenericTest<T> {

        MyGenericTest(T i) {
            System.out.println("MyGenericTest created! i = " + i);
        }
        
        <S> void method(S s) {
            System.out.println("s = " + s);
        }
        
        void test(int i) throws MyException1, MyException2 {
            if(i > 10)
                throw new MyException1();
            if(i < -10)
                throw new MyException2();
            
            System.out.println("The normal value is: " + i);
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        // 1、二进制整数字面量
        int x = 0b01001011;     // x的值为0x4b，十进制为75
        System.out.println("x = " + x);
        
        // 2、下划线做数值字面量的分隔
        long l = 12345678_0000L;
        System.out.println("l = " + l);
        double d = 12345678_1234.54321_01234;
        System.out.println("d = " + d);
        
        // 3、switch语句中使用字符串对象作为判别表达式
        String s = "Hello";
        switch(s) {
            case "Hi":
                System.out.println("Hi, there!");
                break;
                
            case "hello":
                System.out.println("Hello, there!");
                break;
                
            case "Hello":
                System.out.println("Hello, world");
                break;
        }
        
        // 4、泛型实例创建时的类型推导
        MyGenericTest<Integer> test = new MyGenericTest<>(x);
        test.method(d);
        
        // 5、一次捕获多个类型的异常
        try {
            test.test(100);
        }
        catch(MyException1 | MyException2 ex) {
            System.out.println("exception info: " + ex.getMessage());
        }
        
        try {
            test.test(-100);
        }
        catch(MyException1 | MyException2 ex) {
            System.out.println("exception info: " + ex.getMessage());
        }
    }

Java 8的新增语法特性主要是增加了方法引用与lambda表达式，详细可参考这篇博文——
http://www.cnblogs.com/zenny-chen/p/3687320.html

下面再举一些简单的例子。

interface MethodInterface {
    public void invoke(int a);
}

class Test {
    
    void method1(int i) {
        System.out.println("i + 1 = " + (i + 1));
    }
    
    void method2(int i) {
        System.out.println("i - 1 = " + (i - 1));
    }
}

public class Main {
    
    private static interface MethodCall {
        int call(int a);
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("Hello, world!");
	    
        Test tst = new Test();
	    
        MethodInterface mi = tst::method1;
        mi.invoke(100);
	    
        mi = tst::method2;
        mi.invoke(100);

        mi = (i) -> {
	        System.out.println("i = " + 1);
	    };
	    mi.invoke(20);

	    // Java中，如果要在lambda表达式中捕获外部对象，那么该对象必须是一个常量
	    final int a = 50;

	    // Java中的lambda表达式不需要给参数与返回值提供类型，因为前面声明的lambda引用已经提供了类型信息
	    MethodCall call = (i) -> {
	        return a * i;
	    };
	    
	    int b = a + call.call(30);
	    System.out.println("b = " + b);
	    
	    // Java中的lambda表达式不能单独作为一个独立的方法标识符，它只能放在赋值操作符的右边
	    // 倘若要直接写一个方法进行调用还得用以下这种传统的老方式，通过创建匿名类的方式。
	    b = new MethodCall() {
	        public int call(int a) {
	            return a + 10;
	        }
	    }.call(100);
    }
}

以上主要是对Java 7和Java 8在语法特性上的简单介绍。大家可以随意使用。