Whats new in Java 7

© IBM 2011. Licensed under EPL v1.0

SE 7 : What's New!

Ayushman JainJDT/Core committer

IBM


New features at a glance

● Project Coin – small enhancement and new language features.

● Support for dynamic languages.

● Unicode 6.0 – new rupee symbol, brahmi script, emoticons.

● New I/O and concurrent APIs.


Project coin features

● Binary literals and underscores in literals.

• Strings in switch.

• @SafeVarargs - Varargs warnings.

• Diamond - improved type inference for generic instance

creation.

• Multi-catch and more precise rethrow.

• try-with-resources (formerly known as Automatic

Resource Management or ARM).


Strings in switch

● When do you use a switch statement?

● Valid case labels upto javaSE 6 can be

– Int constants

– Enum constants

● String can also be constants!


Safe Varargs

● Variable arity method - public static <T> List<T> java.util.Arrays.asList(T... a)

● If T is the parameter type with variable arity and is also non-reifiable, a new warning on declaration of variable arity methods with parameter of type T.

● A new annotation @SafeVarargs to suppress the warning at both declaration site and call site.


Reifiable types

● A type whose type information is fully available at runtime, that is, a type that does not lose information in the course of type erasure.

● Any type with type parameters is available to the JVM as the raw type because of type erasure.

● So List<Number> and List<String> are both seen as List by the JVM.

● Hence parameterized types are non-reifiable.

● On the other hand, types such as “String” are reifiable.


Safe Varargs

● A variable arity parameter of a generic type can cause heap pollution.

● public static <T> List<T> java.util.Arrays.asList(T... a)

● Heap pollution - A situation where a variable of a parameterized type refers to an object that is not of that parameterized type.

● Usually, the method body is well behaved and only iterates over the elements.

● Hence, unchecked warning is mostly a distraction.


@SafeVarargs

● Annotation legal on static or final variable arity methods or constructors.

● Not legal on

– Fixed arity methods or constructors.

– Variable arity methods or constructors that are neither final nor static.

● Some java APIs already retrofitted with the annotation in JDK 7.


Binary Integer Literals and Underscores in numeric literals

● Binary integer literals structured just like hex interger literals. Differences:

– Binary digits used instead of hex digits

– 0b now used instead of 0x

● In numeric literals, underscores now permitted as separators between digits.

● Applies to literals in any base: binary, octal, hexadecimal, or decimal

● Applies to both integer literals and floating point literals


Multi-catch and more precise rethrow

● Different catch blocks performing the same action on the caught exception.

● They can now be combined into one single catch block using Disjunctive types.

● Disjunctive type = ExceptionA | ExceptionB | ....

● Disjunctive types implicitly final.

● Also, now only the actually thrown exception is now rethrown and not its parent type.


Try With Resources

● Language & Library changes to

– Ease management of objects that require explicit freeing/disposal/destruction.

– Prevent resource leaks (handles, streams ...)

– A la Destructors in C++ (and others)

● Library changes:

– A new interface java.lang.AutoCloseable.

– Libraries retrofitted to implement the new interface

– Facilities to manage suppressed exceptions on java.lang.Throwable


What is a Resource

● Basically a final variable local to the try block.

● Must be of type AutoCloseable.

● Must be initialized in the resource section.

● Language guarantees that every successfully initialized non-null resource will be “closed”.

● Will be closed regardless of normal or abrupt completion.

● In LIFC order: Last initialized first closed.


Suppressed exceptions

● “Primary” exception will be the exception seen by a user supplied catch block.

● Exception from close methods are added to the suppressed list of primary exception (unless it is the primary exception.)

● An interested party can query and process suppressed exceptions. New APIs in class Throwable:

– public final void addSuppressed(Throwable);

– public final Throwable [] getSuppressed();


Diamond

● Improved type inference for generic instance creation.

● Before,

● List<String> list = new ArrayList<String>();

● Now,

● List<String> list = new ArrayList<>();

● Why not List<String> list = new ArrayList() ?


Support for dynamic languages

● A growing interest in running programs written in dynamic languages on JVM.

● Particularly scripting languages-JRuby,Jpython,Groovy.

● Motivation – make implementation in such languages efficient and fast.

● Current Problem - JVM instruction to invoke a method takes method descriptor as the argument

– Method descriptor is the method name, argument types and the return type.

● Solution – new invokeDynamic instruction and dynamic linking through method handles.


JVM bytecode instructions

● invokevirtual - Invokes a method on a class. This is the typical type of method invocation.

● invokeinterface - Invokes a method on an interface.

● invokestatic - Invokes a static method on a class. This is the only kind of invocation that lacks a receiver argument.

● invokespecial - Invokes a method without reference to the type of the receiver.

● invokedynamic - enables an implementer of a dynamic language to translate a method invocation into bytecode without having to specify a target type that contains the method.


Method handles

● Consider hypothetical dynamic language code

function max (x,y) {

if x.lessThan(y) then y else x }

● To compile this for JVM

MyObject function max (MyObject x,MyObject y) {

if x.lessThan(y) then y else x }

● Or use reflection.

● With Java7, use method handles!


Use Eclipse for java 7

● No builds available as of today.

● Setup Eclipse to work for java 7 as described in http://wiki.eclipse.org/JDT_Core/Java7


Thank You!

Technology

Whats new in Java 7