Java 8 Type Annotations
By
·
·
Interview
Likes
(4)
Likes
There are no likes...yet! 👀
Be the first to like this post!
It looks like you're not logged in.
Sign in to see who liked this post!
Comment
Save
82.8K Views
Join the DZone community and get the full member experience.
Join For FreeLambda expressions are by far the most discussed and promoted feature of Java 8. While I agree that Lambdas are a large improvement I think that some other Java 8 feature go a bit short because of the Lambda hype. In this post I want to show a number of examples from another nice Java 8 feature: Type Annotations.
Type Annotations are annotations that can be placed anywhere you use a type. This includes the new operator, type casts, implements clauses and throws clauses. Type Annotations allow improved analysis of Java code and can ensure even stronger type checking.
In source code this means we get two new ElementTypes for annotations:
The enum value TYPE_PARAMETER allows an annotation to be applied at type variables (e.g. MyClass<T>). Annotations with target TYPE_USE can be applied at any type use.
Please note that the annotations from the following examples will not work out of the box when Java 8 is released. Java 8 only provides the ability to define these types of annotations. It is then up to framework and tool developers to actually make use of it. So this is a collection of annotations frameworks could give us in the future. Most of the examples are taken from the Type Annotations specification and various Java 8 presentations.
Simple type definitions with type annotations look like this:
Type annotations can also be applied to nested types
Constructors with type annotations:
They work with nested (non static) class constructors too:
Type casts:
Inheritance:
We can use type Annotations with generic type arguments:
Of course we can nest them:
Or apply them to intersection Types:
Including parameter bounds and wildcard bounds:
Generic method invocation with type annotations looks like this:
For generic constructors, the annotation follows the explicit type arguments:
Throwing exceptions:
Type annotations in instanceof statements:
And finally Java 8 method and constructor references:
Conclusion
Type annotations are an interesting addition to the Java type system. They can be applied to any use of a type and enable a more detailed code analysis. If you want to use Type annotations right now you should have a look at the Checker Framework.
Type Annotations are annotations that can be placed anywhere you use a type. This includes the new operator, type casts, implements clauses and throws clauses. Type Annotations allow improved analysis of Java code and can ensure even stronger type checking.
In source code this means we get two new ElementTypes for annotations:
@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
public @interface Test {
}Please note that the annotations from the following examples will not work out of the box when Java 8 is released. Java 8 only provides the ability to define these types of annotations. It is then up to framework and tool developers to actually make use of it. So this is a collection of annotations frameworks could give us in the future. Most of the examples are taken from the Type Annotations specification and various Java 8 presentations.
Simple type definitions with type annotations look like this:
@NotNull String str1 = ... @Email String str2 = ... @NotNull @NotBlank String str3 = ...
Map.@NonNull Entry = ...
new @Interned MyObject() new @NonEmpty @Readonly List<String>(myNonEmptyStringSet)
myObject.new @Readonly NestedClass()
myString = (@NonNull String) myObject; query = (@Untainted String) str;
class UnmodifiableList<T> implements @Readonly List<T> { ... }List<@Email String> emails = ... List<@ReadOnly @Localized Message> messages = ... Graph<@Directional Node> directedGraph = ...
Map<@NonNull String, @NonEmpty List<@Readonly Document>> documents;
public <E extends @ReadOnly Composable<E> & @Localized MessageSource> void foo(...) { ... }class Folder<F extends @Existing File> { ... }
Collection<? super @Existing File> c = ...
List<@Immutable ? extends Comparable<T>> unchangeable = ...myObject.<@NotBlank String>myMethod(...);
1 | new <String> @Interned MyObject() |
void monitorTemperature() throws @Critical TemperatureException { ... }
void authenticate() throws @Fatal @Logged AccessDeniedException { ... }boolean isNonNull = myString instanceof @NonNull String; boolean isNonBlankEmail = myString instanceof @NotBlank @Email String;
@Vernal Date::getDay List<@English String>::size Arrays::<@NonNegative Integer>sort
Conclusion
Type annotations are an interesting addition to the Java type system. They can be applied to any use of a type and enable a more detailed code analysis. If you want to use Type annotations right now you should have a look at the Checker Framework.
Annotation
Java (programming language)
Published at DZone with permission of Michael Scharhag, DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.
Comments