Java7带来的新的语言特性

 

 

1。二进制字面量值

// An 8-bit 'byte' value:

	byte aByte = (byte)0b00100001;

	// A 16-bit 'short' value:
	short aShort = (short)0b1010000101000101;

	// Some 32-bit 'int' values:
	int anInt1 = 0b10100001010001011010000101000101;
	int anInt2 = 0b101;
	int anInt3 = 0B101; // The B can be upper or lower case.

	// A 64-bit 'long' value. Note the "L" suffix:
	long aLong = 0b1010000101000101101000010100010110100001010001011010000101000101L;

 

2.可以在数字字面量中使用"下划线"("_")

 

 

        long creditCardNumber = 1234_5678_9012_3456L;
	long socialSecurityNumber = 999_99_9999L;
	float pi = 	3.14_15F;
	long hexBytes = 0xFF_EC_DE_5E;
	long hexWords = 0xCAFE_BABE;
	long maxLong = 0x7fff_ffff_ffff_ffffL;
	byte nybbles = 0b0010_0101;
	long bytes = 0b11010010_01101001_10010100_10010010;

 

 

要注意的是，下划线放在以下几个地方是不正确的：

(1).最前面; 如_52 ，这不是数字字面量，而是也是变量名了

(2).小数点的两边; 如float pi1 = 3_.1415F 和 float pi1 = 3._1415F 都是不正确的

(3).最后面; 如int x3 = 52_;

(4).不能放在0x这样前缀的中间，如：int x5 = 0_x52;

3.可以在switch语句中使用String类型的变量

public String getTypeOfDayWithSwitchStatement(String dayOfWeekArg) {
	     String typeOfDay;
	     switch (dayOfWeekArg) {
		 case "Monday":
		     typeOfDay = "Start of work week";
		     break;
		 case "Tuesday":
		 case "Wednesday":
		 case "Thursday":
		     typeOfDay = "Midweek";
		     break;
		 case "Friday":
		     typeOfDay = "End of work week";
		     break;
		 case "Saturday":
		 case "Sunday":
		     typeOfDay = "Weekend";
		     break;
		 default:
		     throw new IllegalArgumentException("Invalid day of the week: " + dayOfWeekArg);
	     }
	     return typeOfDay;
	}

 

4.类型推断，泛型构造器和非泛型的Classes

(Type Inference and Generic Constructors of Generic and Non-Generic Classes)

首先看一个泛型构造器和类型推断的例子：

class MyClass<X> {  
	  <T> MyClass(T t) {
	    // ...
	  }
	}

 

 

这里X是泛型类MyClass<X>的参数化类型，而T是其构造器的参数化类型。

那怎么样实例化它呢？

new MyClass<Integer>("")，这条语句创建了MyClass<Integer>一个实例，这条语句显式的指定了MyClass<X>

中的参数X的类型为Integer。 同时，因为实际调用构造器时参数是String类型，所以编译器推断String就是这

个T的类型,。

接下来看下面这两种例子：

1.MyClass<Integer> myObject = new MyClass<>("");

 在这里例子中，编译器推断Integer为泛型类MyClass<X>正式参数化类型X的类型，推断String为该泛型类构造器的正式参数化类型T

 的实际类型。

2.MyClass<Integer> myObject = new <String> MyClass<>("");

 在这里例子中，编译器推断Integer为泛型类MyClass<X>真是参数化类型X的类型，同时这条语句显式的指定了构造器的正式参数化类型T

 的实际类型。

 

5. Improved Compiler Warnings and Errors When Using Non-Reifiable Formal Parameters with Varargs Methods

不知道怎么翻译。 “当在可变长参数方法中使用不可具体化的参数时改良的警告和错误”，行么？

6.带有资源的try语句  

The try-with-resources Statement  

一个带有资源的try语句就是一个声明了一个或者多个资源的try语句，资源是指当程序结束后必须关闭的对象。带有资源的try语句

保证在语句结束的时候每个资源都会被关闭(调用其close()方法)。任何实现了java.lang.AutoCloseable 或者 java.io.Closeable接口的对象都可以被

用作为一个资源。

 

下面这个例子的作用是从一个文件中读取第一行。使用了一个BufferedReader从文件中读取数据，在这里BufferedReader就是一个在程序结束

后必须关闭的资源。

static String readFirstLineFromFile(String path) throws IOException {
	  try (BufferedReader br = new BufferedReader(new FileReader(path))) {
	    return br.readLine();
	  }
	}

 

 

上面说到可以在try语句中声明一个或多个资源，下面就是一个声明了多个资源的try语句，它的功能是获得打包在zip文件中的所有

文件的文件名，然后把这些文件名保存到一个txt文件中。

 

public static void writeToFileZipFileContents(String zipFileName, String outputFileName)
	    throws java.io.IOException {

	    java.nio.charset.Charset charset = java.nio.charset.Charset.forName("US-ASCII");
	    java.nio.file.Path outputFilePath = java.nio.file.Paths.get(outputFileName);

	    // Open zip file and create output file with try-with-resources statement

	    try (
	      java.util.zip.ZipFile zf = new java.util.zip.ZipFile(zipFileName);
	      java.io.BufferedWriter writer = java.nio.file.Files.newBufferedWriter(outputFilePath, charset)
	    ) {

	      // Enumerate each entry

	      for (java.util.Enumeration entries = zf.entries(); entries.hasMoreElements();) {

		// Get the entry name and write it to the output file

		String newLine = System.getProperty("line.separator");
		String zipEntryName = ((java.util.zip.ZipEntry)entries.nextElement()).getName() + newLine;
		writer.write(zipEntryName, 0, zipEntryName.length());
	      }
	    }
	  }

 

 

 大家需要知道的是，一个带有资源的try语句和普通的try语句一样可以有catch和finally语句块，但是任何catch或者

 finally块都是在所有的资源关闭后才执行的。

7.捕捉复合（Multiple）异常类型以及使用改良的类型检查重掷（Rethrowing）异常

在Java6以及以前版本一般我们这样捕获多个类型的异常：

catch (IOException ex) {
	     logger.log(ex);
	     throw ex;
	catch (SQLException ex) {
	     logger.log(ex);
	     throw ex;
	}

 

 

在Java7里可以这么干：

catch (IOException|SQLException ex) {
	    logger.log(ex);
	    throw ex;
	}

 

 

下面看一个抛出异常的例子：

JDK6及以前版本:

 

 static class FirstException extends Exception { }
	  static class SecondException extends Exception { }

	  public void rethrowException(String exceptionName) throws Exception {
	    try {
	      if (exceptionName.equals("First")) {
		throw new FirstException();
	      } else {
		throw new SecondException();
	      }
	    } catch (Exception e) {
	      throw e;
	    }
	  }

 

 

 JDK7:

  public void rethrowException(String exceptionName)
	  throws FirstException, SecondException {
	    try {
	      // ...
	    }
	    catch (Exception e) {
	      throw e;
	    }
	  }