diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/WhiteSpaceProcessor.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/WhiteSpaceProcessor.java
index b14a793..9e2f569 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/WhiteSpaceProcessor.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/WhiteSpaceProcessor.java
@@ -35,6 +35,12 @@
 //        return result.toString();
 //    }
 
+    /**
+     * Default constructor.
+     */
+    protected WhiteSpaceProcessor() {
+    }
+
     public static String replace(String text) {
         return replace( (CharSequence)text ).toString();
     }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/annotation/XmlIsSet.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/annotation/XmlIsSet.java
index 606fae6..4b1e2ac 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/annotation/XmlIsSet.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/annotation/XmlIsSet.java
@@ -90,6 +90,7 @@
  */
 @Retention(RUNTIME)
 @Target({FIELD,METHOD})
+@Deprecated
 public @interface XmlIsSet {
     /**
      * Specifies the name of the property to attach to.
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/api/ErrorListener.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/api/ErrorListener.java
index fd1e049..d472c10 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/api/ErrorListener.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/api/ErrorListener.java
@@ -30,8 +30,11 @@
  * @since 2.1 EA2
  */
 public interface ErrorListener extends ErrorHandler {
+    @Override
     void error(SAXParseException exception);
+    @Override
     void fatalError(SAXParseException exception);
+    @Override
     void warning(SAXParseException exception);
     /**
      * Used to report possibly verbose information that
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/api/impl/NameConverter.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/api/impl/NameConverter.java
index f3a95cc..1c0e4be 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/api/impl/NameConverter.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/api/impl/NameConverter.java
@@ -79,15 +79,26 @@
     public static final NameConverter standard = new Standard();
 
     static class Standard extends NameUtil implements NameConverter {
+
+        /**
+         * Default constructor.
+         */
+        public Standard() {
+        }
+
+        @Override
         public String toClassName(String s) {
             return toMixedCaseName(toWordList(s), true);
         }
+        @Override
         public String toVariableName(String s) {
             return toMixedCaseName(toWordList(s), false);
         }
+        @Override
         public String toInterfaceName( String token ) {
             return toClassName(token);
         }
+        @Override
         public String toPropertyName(String s) {
             String prop = toClassName(s);
             // property name "Class" with collide with Object.getClass,
@@ -96,6 +107,7 @@
                 prop = "Clazz";
             return prop;
         }
+        @Override
         public String toConstantName( String token ) {
             return super.toConstantName(token);
         }
@@ -106,6 +118,7 @@
          * @return
          *      null if it fails to derive a package name.
          */
+        @Override
         public String toPackageName( String nsUri ) {
             // remove scheme and :, if present
             // spec only requires us to remove 'http' and 'urn'...
@@ -189,7 +202,7 @@
 
         private static ArrayList<String> tokenize( String str, String sep ) {
             StringTokenizer tokens = new StringTokenizer(str,sep);
-            ArrayList<String> r = new ArrayList<String>();
+            ArrayList<String> r = new ArrayList<>();
 
             while(tokens.hasMoreTokens())
                 r.add( tokens.nextToken() );
@@ -198,7 +211,7 @@
         }
 
         private static <T> ArrayList<T> reverse( List<T> a ) {
-            ArrayList<T> r = new ArrayList<T>();
+            ArrayList<T> r = new ArrayList<>();
 
             for( int i=a.size()-1; i>=0; i-- )
                 r.add( a.get(i) );
@@ -206,8 +219,8 @@
             return r;
         }
 
-        private static String combine( List r, char sep ) {
-            StringBuilder buf = new StringBuilder(r.get(0).toString());
+        private static String combine( List<String> r, char sep ) {
+            StringBuilder buf = new StringBuilder(r.get(0));
 
             for( int i=1; i<r.size(); i++ ) {
                 buf.append(sep);
@@ -225,14 +238,17 @@
      * and not as a word separator.
      */
     public static final NameConverter jaxrpcCompatible = new Standard() {
+        @Override
         protected boolean isPunct(char c) {
             return (c == '.' || c == '-' || c == ';' /*|| c == '_'*/ || c == '\u00b7'
                     || c == '\u0387' || c == '\u06dd' || c == '\u06de');
         }
+        @Override
         protected boolean isLetter(char c) {
             return super.isLetter(c) || c=='_';
         }
 
+        @Override
         protected int classify(char c0) {
             if(c0=='_') return NameUtil.OTHER_LETTER;
             return super.classify(c0);
@@ -243,6 +259,7 @@
      * Smarter converter used for RELAX NG support.
      */
     public static final NameConverter smart = new Standard() {
+        @Override
         public String toConstantName( String token ) {
             String name = super.toConstantName(token);
             if(!SourceVersion.isKeyword(name))
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/api/impl/NameUtil.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/api/impl/NameUtil.java
index f92c83b..fce297c 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/api/impl/NameUtil.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/api/impl/NameUtil.java
@@ -182,7 +182,7 @@
      * {"Abc", "100","Ghi"}.
      */
     public List<String> toWordList(String s) {
-        ArrayList<String> ss = new ArrayList<String>();
+        ArrayList<String> ss = new ArrayList<>();
         int n = s.length();
         for (int i = 0; i < n;) {
 
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/DataWriter.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/DataWriter.java
index 42670e6..e76fa4e 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/DataWriter.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/DataWriter.java
@@ -131,6 +131,7 @@
      * @deprecated
      *      Only return the length of the indent string.
      */
+    @Deprecated
     public int getIndentStep ()
     {
         return indentStep.length();
@@ -147,6 +148,7 @@
      * @deprecated
      *      Should use the version that takes string.
      */
+    @Deprecated
     public void setIndentStep (int indentStep)
     {
         StringBuilder buf = new StringBuilder();
@@ -174,14 +176,16 @@
      *
      * @see XMLWriter#reset()
      */
+    @Override
     public void reset ()
     {
         depth = 0;
         state = SEEN_NOTHING;
-        stateStack = new Stack<Object>();
+        stateStack = new Stack<>();
         super.reset();
     }
 
+    @Override
     protected void writeXmlDecl(String decl) throws IOException {
         super.writeXmlDecl(decl);
         write('\n');
@@ -207,6 +211,7 @@
      *            down the chain raises an exception.
      * @see XMLWriter#startElement(String, String, String, Attributes)
      */
+    @Override
     public void startElement (String uri, String localName,
                               String qName, Attributes atts)
         throws SAXException
@@ -240,6 +245,7 @@
      *            down the chain raises an exception.
      * @see XMLWriter#endElement(String, String, String)
      */
+    @Override
     public void endElement (String uri, String localName, String qName)
         throws SAXException
     {
@@ -252,6 +258,7 @@
         state = stateStack.pop();
     }
 
+    @Override
     public void endDocument() throws SAXException {
         try {
             write('\n');
@@ -304,6 +311,7 @@
      *            down the chain raises an exception.
      * @see XMLWriter#characters(char[], int, int)
      */
+    @Override
     public void characters (char ch[], int start, int length)
         throws SAXException
     {
@@ -352,7 +360,7 @@
     ////////////////////////////////////////////////////////////////////
 
     private Object state = SEEN_NOTHING;
-    private Stack<Object> stateStack = new Stack<Object>();
+    private Stack<Object> stateStack = new Stack<>();
 
     private String indentStep = "";
     private int depth = 0;
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/DumbEscapeHandler.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/DumbEscapeHandler.java
index e680f23..bc0c667 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/DumbEscapeHandler.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/DumbEscapeHandler.java
@@ -29,6 +29,7 @@
     
     public static final CharacterEscapeHandler theInstance = new DumbEscapeHandler(); 
     
+    @Override
     public void escape(char[] ch, int start, int length, boolean isAttVal, Writer out) throws IOException {
         int limit = start+length;
         for (int i = start; i < limit; i++) {
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/Messages.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/Messages.java
index 020a121..1b34f00 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/Messages.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/Messages.java
@@ -18,8 +18,10 @@
  * 
  * @since JAXB 1.0
  */
-public class Messages
-{
+public class Messages {
+
+    private Messages() {}
+
     public static String format( String property ) {
         return format( property, null );
     }
@@ -67,6 +69,7 @@
     /**
      * @deprecated use ERR_MISSING_OBJECT2
      */
+    @Deprecated
     public static final String ERR_MISSING_OBJECT = // 0 args
         "SAXMarshaller.MissingObject";
     
@@ -81,12 +84,14 @@
     /**
      * @deprecated only used from 1.0
      */
+    @Deprecated
     public static final String ERR_DANGLING_IDREF = // 1 arg
         "SAXMarshaller.DanglingIDREF";
 
     /**
      * @deprecated only used from 1.0
      */
+    @Deprecated
     public static final String ERR_NOT_IDENTIFIABLE = // 0 args
         "SAXMarshaller.NotIdentifiable";
 
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/MinimumEscapeHandler.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/MinimumEscapeHandler.java
index 8c13a16..5601c43 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/MinimumEscapeHandler.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/MinimumEscapeHandler.java
@@ -26,6 +26,7 @@
     
     public static final CharacterEscapeHandler theInstance = new MinimumEscapeHandler(); 
     
+    @Override
     public void escape(char[] ch, int start, int length, boolean isAttVal, Writer out) throws IOException {
         // avoid calling the Writerwrite method too much by assuming
         // that the escaping occurs rarely.
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/NoEscapeHandler.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/NoEscapeHandler.java
index e6ca870..edf0ede 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/NoEscapeHandler.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/NoEscapeHandler.java
@@ -23,6 +23,12 @@
 
     public static final NoEscapeHandler theInstance = new NoEscapeHandler();
 
+    /**
+     * Default constructor.
+     */
+    public NoEscapeHandler() {
+    }
+
     @Override
     public void escape(char[] ch, int start, int length, boolean isAttVal, Writer out) throws IOException {
         out.write(ch, start, length);
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/SAX2DOMEx.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/SAX2DOMEx.java
index 558a830..d4e2df8 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/SAX2DOMEx.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/SAX2DOMEx.java
@@ -37,8 +37,8 @@
 
     private Node node = null;
     private boolean isConsolidate;
-    protected final Stack<Node> nodeStack = new Stack<Node>();
-    private final FinalArrayList<String> unprocessedNamespaces = new FinalArrayList<String>();
+    protected final Stack<Node> nodeStack = new Stack<>();
+    private final FinalArrayList<String> unprocessedNamespaces = new FinalArrayList<>();
     /**
      * Document object that owns the specified node.
      */
@@ -71,7 +71,7 @@
     /**
      * Creates a fresh empty DOM document and adds nodes under this document.
      */
-    public SAX2DOMEx(DocumentBuilderFactory f) throws ParserConfigurationException {        
+    public SAX2DOMEx(DocumentBuilderFactory f) throws ParserConfigurationException {
         f.setValidating(false);
         document = f.newDocumentBuilder().newDocument();
         node = document;
@@ -80,8 +80,9 @@
 
     /**
      * Creates a fresh empty DOM document and adds nodes under this document.
-     * @deprecated 
+     * @deprecated
      */
+    @Deprecated
     public SAX2DOMEx() throws ParserConfigurationException {
         DocumentBuilderFactory factory = XmlFactory.createDocumentBuilderFactory(false);
         factory.setValidating(false);
@@ -99,9 +100,11 @@
         return node;
     }
 
+    @Override
     public void startDocument() {
     }
 
+    @Override
     public void endDocument() {
     }
 
@@ -131,6 +134,7 @@
         element.setAttributeNS("http://www.w3.org/2000/xmlns/", qname, uri);
     }
 
+    @Override
     public void startElement(String namespace, String localName, String qName, Attributes attrs) {
         Node parent = nodeStack.peek();
 
@@ -172,10 +176,12 @@
         nodeStack.push(element);
     }
 
+    @Override
     public void endElement(String namespace, String localName, String qName) {
         nodeStack.pop();
     }
 
+    @Override
     public void characters(char[] ch, int start, int length) {
         characters(new String(ch, start, length));
     }
@@ -194,26 +200,32 @@
         return text;
     }
 
+    @Override
     public void ignorableWhitespace(char[] ch, int start, int length) {
     }
 
+    @Override
     public void processingInstruction(String target, String data) throws org.xml.sax.SAXException {
         Node parent = nodeStack.peek();
         Node n = document.createProcessingInstruction(target, data);
         parent.appendChild(n);
     }
 
+    @Override
     public void setDocumentLocator(Locator locator) {
     }
 
+    @Override
     public void skippedEntity(String name) {
     }
 
+    @Override
     public void startPrefixMapping(String prefix, String uri) {
         unprocessedNamespaces.add(prefix);
         unprocessedNamespaces.add(uri);
     }
 
+    @Override
     public void endPrefixMapping(String prefix) {
     }
 }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/XMLWriter.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/XMLWriter.java
index 8b3ec10..eada395 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/XMLWriter.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/marshaller/XMLWriter.java
@@ -380,7 +380,8 @@
     }
     
 
-    private final HashMap<String,String> locallyDeclaredPrefix = new HashMap<String,String>();
+    private final HashMap<String,String> locallyDeclaredPrefix = new HashMap<>();
+    @Override
     public void startPrefixMapping( String prefix, String uri ) throws SAXException {
         locallyDeclaredPrefix.put(prefix,uri);
     }
@@ -400,6 +401,7 @@
      *            the filter chain raises an exception.
      * @see org.xml.sax.ContentHandler#startDocument()
      */
+    @Override
     public void startDocument ()
         throws SAXException
     {
@@ -438,6 +440,7 @@
      *            the filter chain raises an exception.
      * @see org.xml.sax.ContentHandler#endDocument()
      */
+    @Override
     public void endDocument ()
         throws SAXException
     {
@@ -469,6 +472,7 @@
      *            the filter chain raises an exception.
      * @see org.xml.sax.ContentHandler#startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)
      */
+    @Override
     public void startElement (String uri, String localName,
                               String qName, Attributes atts)
         throws SAXException
@@ -537,6 +541,7 @@
      *            the filter chain raises an exception.
      * @see org.xml.sax.ContentHandler#endElement(java.lang.String, java.lang.String, java.lang.String)
      */
+    @Override
     public void endElement (String uri, String localName, String qName)
         throws SAXException
     {
@@ -571,6 +576,7 @@
      *            the filter chain raises an exception.
      * @see org.xml.sax.ContentHandler#characters(char[], int, int)
      */
+    @Override
     public void characters (char ch[], int start, int len)
         throws SAXException
     {
@@ -600,6 +606,7 @@
      *            the filter chain raises an exception.
      * @see org.xml.sax.ContentHandler#ignorableWhitespace(char[], int, int)
      */
+    @Override
     public void ignorableWhitespace (char ch[], int start, int length)
         throws SAXException
     {
@@ -625,6 +632,7 @@
      *            the filter chain raises an exception.
      * @see org.xml.sax.ContentHandler#processingInstruction(java.lang.String, java.lang.String)
      */
+    @Override
     public void processingInstruction (String target, String data)
         throws SAXException
     {
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/unmarshaller/DOMScanner.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/unmarshaller/DOMScanner.java
index ed0c0a9..0d7109d 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/unmarshaller/DOMScanner.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/unmarshaller/DOMScanner.java
@@ -42,8 +42,7 @@
  * @author <ul><li>Kohsuke Kawaguchi, Sun Microsystems, Inc.</li></ul>
  * @since JAXB 1.0
  */
-public class DOMScanner implements LocatorEx,InfosetScanner/*<Node> --- but can't do this to protect 1.0 clients, or can I? */
-{
+public class DOMScanner implements LocatorEx,InfosetScanner<Node> {
     
     /** reference to the current node being scanned - used for determining
      *  location info for validation events */
@@ -68,7 +67,8 @@
         this.locator = loc;
     }
 
-    public void scan(Object node) throws SAXException {
+    @Override
+    public void scan(Node node) throws SAXException {
         if( node instanceof Document ) {
             scan( (Document)node );
         } else {
@@ -89,15 +89,15 @@
         NamespaceSupport nss = new NamespaceSupport();
         buildNamespaceSupport( nss, e.getParentNode() );
         
-        for( Enumeration en = nss.getPrefixes(); en.hasMoreElements(); ) {
-            String prefix = (String)en.nextElement();
+        for( Enumeration<String> en = nss.getPrefixes(); en.hasMoreElements(); ) {
+            String prefix = en.nextElement();
             receiver.startPrefixMapping( prefix, nss.getURI(prefix) );
         }
         
         visit(e);
         
-        for( Enumeration en = nss.getPrefixes(); en.hasMoreElements(); ) {
-            String prefix = (String)en.nextElement();
+        for( Enumeration<String> en = nss.getPrefixes(); en.hasMoreElements(); ) {
+            String prefix = en.nextElement();
             receiver.endPrefixMapping( prefix );
         }
         
@@ -113,6 +113,7 @@
      * @deprecated in JAXB 2.0
      *      Use {@link #scan(Element)}
      */
+    @Deprecated
     public void parse( Element e, ContentHandler handler ) throws SAXException {
         // it might be better to set receiver at the constructor.
         receiver = handler;
@@ -134,6 +135,7 @@
      * @deprecated in JAXB 2.0
      *      Use {@link #scan(Element)}
      */
+    @Deprecated
     public void parseWithContext( Element e, ContentHandler handler ) throws SAXException {
         setContentHandler(handler);
         scan(e);
@@ -272,29 +274,38 @@
         return currentNode;
     }
 
-    public Object getCurrentElement() {
+    @Override
+    public Node getCurrentElement() {
         return currentNode;
     }
 
+    @Override
     public LocatorEx getLocator() {
         return this;
     }
 
+    @Override
     public void setContentHandler(ContentHandler handler) {
         this.receiver = handler;
     }
 
+    @Override
     public ContentHandler getContentHandler() {
         return this.receiver;
     }
 
 
     // LocatorEx implementation
+    @Override
     public String getPublicId() { return null; }
+    @Override
     public String getSystemId() { return null; }
+    @Override
     public int getLineNumber() { return -1; }
+    @Override
     public int getColumnNumber() { return -1; }
 
+    @Override
     public ValidationEventLocator getLocation() {
         return new ValidationEventLocatorImpl(getCurrentLocation());
     }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/util/SecureLoader.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/util/SecureLoader.java
index ab9e5d1..e9f8b2c 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/util/SecureLoader.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/util/SecureLoader.java
@@ -24,6 +24,7 @@
         } else {
             return java.security.AccessController.doPrivileged(
                     new java.security.PrivilegedAction<ClassLoader>() {
+                        @Override
                         public ClassLoader run() {
                             return Thread.currentThread().getContextClassLoader();
                         }
@@ -31,12 +32,13 @@
         }
     }
 
-    static ClassLoader getClassClassLoader(final Class c) {
+    static ClassLoader getClassClassLoader(final Class<?> c) {
         if (System.getSecurityManager() == null) {
             return c.getClassLoader();
         } else {
             return java.security.AccessController.doPrivileged(
                     new java.security.PrivilegedAction<ClassLoader>() {
+                        @Override
                         public ClassLoader run() {
                             return c.getClassLoader();
                         }
@@ -50,6 +52,7 @@
         } else {
             return java.security.AccessController.doPrivileged(
                     new java.security.PrivilegedAction<ClassLoader>() {
+                        @Override
                         public ClassLoader run() {
                             return ClassLoader.getSystemClassLoader();
                         }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/util/Which.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/util/Which.java
index ace4eb6..8b8ae19 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/util/Which.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/util/Which.java
@@ -20,7 +20,9 @@
  */
 public class Which {
 
-    public static String which( Class clazz ) {
+    private Which() {}
+
+    public static String which( Class<?> clazz ) {
         return which( clazz.getName(), SecureLoader.getClassClassLoader(clazz));
     }
 
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/ClassFactory.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/ClassFactory.java
index a89051d..3bf88d6 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/ClassFactory.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/ClassFactory.java
@@ -48,10 +48,12 @@
     private static final ThreadLocal<Map<Class, WeakReference<Constructor>>> tls = new ThreadLocal<Map<Class,WeakReference<Constructor>>>() {
         @Override
         public Map<Class,WeakReference<Constructor>> initialValue() {
-            return new WeakHashMap<Class,WeakReference<Constructor>>();
+            return new WeakHashMap<>();
         }
     };
 
+    private ClassFactory() {}
+
     public static void cleanCache() {
         if (tls != null) {
             try {
@@ -96,7 +98,7 @@
                 }
             }
 
-            m.put(clazz,new WeakReference<Constructor>(cons));
+            m.put(clazz,new WeakReference<>(cons));
         }
 
         return cons.newInstance(emptyObject);
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/TODO.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/TODO.java
index 39311cf..c4e70b6 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/TODO.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/TODO.java
@@ -16,6 +16,13 @@
  * @author Kohsuke Kawaguchi (kk@kohsuke.org)
  */
 public abstract class TODO {
+
+    /**
+     * Default constructor.
+     */
+    public TODO() {
+    }
+
     /**
      * When this method is called,
      * that means we need to check the spec and corrects
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/AttributePropertyInfo.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/AttributePropertyInfo.java
index 13e525d..9e4554b 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/AttributePropertyInfo.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/AttributePropertyInfo.java
@@ -28,6 +28,7 @@
      * @return
      *      always non-null.
      */
+    @Override
     NonElement<T,C> getTarget();
 
     /**
@@ -43,5 +44,6 @@
      */
     QName getXmlName();
 
+    @Override
     Adapter<T,C> getAdapter();
 }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/BuiltinLeafInfo.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/BuiltinLeafInfo.java
index 67130d9..72ff020 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/BuiltinLeafInfo.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/BuiltinLeafInfo.java
@@ -32,5 +32,6 @@
      * @return
      *      never null.
      */
+    @Override
     public QName getTypeName();
 }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ElementInfo.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ElementInfo.java
index 38e643f..aa41789 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ElementInfo.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ElementInfo.java
@@ -62,6 +62,7 @@
      * <p>
      * This returns the signature in Java and thus isn't affected by the adapter.
      */
+    @Override
     T getType();
 
     /**
@@ -69,6 +70,7 @@
      *
      * {@link ElementInfo} can only substitute {@link ElementInfo}.
      */
+    @Override
     ElementInfo<T,C> getSubstitutionHead();
 
     /**
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ElementPropertyInfo.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ElementPropertyInfo.java
index 560d2d8..41a6ae6 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ElementPropertyInfo.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ElementPropertyInfo.java
@@ -104,5 +104,6 @@
      */
     boolean isRequired();
 
+    @Override
     Adapter<T,C> getAdapter();
 }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/EnumLeafInfo.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/EnumLeafInfo.java
index 0d78551..a1c3ee0 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/EnumLeafInfo.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/EnumLeafInfo.java
@@ -54,5 +54,5 @@
      * @return
      *      never null. Can be empty (really?).
      */
-    Iterable<? extends EnumConstant> getConstants();
+    Iterable<? extends EnumConstant<?, ?>> getConstants();
 }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/Ref.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/Ref.java
index 2d0b2c5..74230d7 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/Ref.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/Ref.java
@@ -62,7 +62,7 @@
                T type, XmlJavaTypeAdapter xjta, XmlList xl ) {
         Adapter<T,C> adapter=null;
         if(xjta!=null) {
-            adapter = new Adapter<T,C>(xjta,reader,nav);
+            adapter = new Adapter<>(xjta,reader,nav);
             type = adapter.defaultType;
         }
 
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ReferencePropertyInfo.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ReferencePropertyInfo.java
index aaca2f0..5ee8f1f 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ReferencePropertyInfo.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ReferencePropertyInfo.java
@@ -49,6 +49,7 @@
      * If this {@link ReferencePropertyInfo} has a wildcard in it,
      * then the returned list will contain {@link WildcardTypeInfo}. 
      */
+    @Override
     Collection<? extends TypeInfo<T,C>> ref();
 
     /**
@@ -105,5 +106,6 @@
      */
     boolean isRequired();
 
+    @Override
     Adapter<T,C> getAdapter();
 }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ValuePropertyInfo.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ValuePropertyInfo.java
index b37d3a0..c594e3a 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ValuePropertyInfo.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/core/ValuePropertyInfo.java
@@ -16,5 +16,6 @@
  * @author Kohsuke Kawaguchi
  */
 public interface ValuePropertyInfo<T,C> extends PropertyInfo<T,C>, NonElementRef<T,C> {
+    @Override
     Adapter<T,C> getAdapter();
 }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/GenericArrayTypeImpl.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/GenericArrayTypeImpl.java
index cc5c07f..4f80d77 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/GenericArrayTypeImpl.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/GenericArrayTypeImpl.java
@@ -32,10 +32,12 @@
      *         of this array
      * @since 1.5
      */
+    @Override
     public Type getGenericComponentType() {
         return genericComponentType; // return cached component type
     }
 
+    @Override
     public String toString() {
         Type componentType = getGenericComponentType();
         StringBuilder sb = new StringBuilder();
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/Navigator.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/Navigator.java
index df37920..e1f1bd2 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/Navigator.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/Navigator.java
@@ -182,7 +182,7 @@
      *      can be a primitive, array, class, or anything.
      *      (therefore the return type has to be T, not C)
      */
-    T ref(Class c);
+    T ref(Class<?> c);
 
     /**
      * Gets the T for the given C.
@@ -205,7 +205,7 @@
      * The behavior is undefined if the class object represents
      * primitives, arrays, and other types that are not class declaration.
      */
-    C asDecl(Class c);
+    C asDecl(Class<?> c);
 
     /**
      * Checks if the type is an array type.
@@ -255,7 +255,7 @@
      * @param primitiveType
      *      must be Class objects like {@link Integer#TYPE}.
      */
-    T getPrimitive(Class primitiveType);
+    T getPrimitive(Class<?> primitiveType);
 
     /**
      * Returns a location of the specified class.
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/ParameterizedTypeImpl.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/ParameterizedTypeImpl.java
index 85f8ebc..2c35636 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/ParameterizedTypeImpl.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/ParameterizedTypeImpl.java
@@ -39,7 +39,7 @@
     }
 
     private void validateConstructorArguments() {
-        TypeVariable/*<?>*/[] formals = rawType.getTypeParameters();
+        TypeVariable<?>[] formals = rawType.getTypeParameters();
         // check correct arity of actual type args
         if (formals.length != actualTypeArguments.length) {
             throw new MalformedParameterizedTypeException();
@@ -51,14 +51,17 @@
 */
     }
 
+    @Override
     public Type[] getActualTypeArguments() {
         return actualTypeArguments.clone();
     }
 
+    @Override
     public Class<?> getRawType() {
         return rawType;
     }
 
+    @Override
     public Type getOwnerType() {
         return ownerType;
     }
@@ -124,6 +127,7 @@
                 (rawType == null ? 0 : rawType.hashCode());
     }
 
+    @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
 
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/ReflectionNavigator.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/ReflectionNavigator.java
index 83cb81b..46383b0 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/ReflectionNavigator.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/ReflectionNavigator.java
@@ -31,7 +31,7 @@
  * {@link Navigator} implementation for {@code java.lang.reflect}.
  *
  */
-/*package*/final class ReflectionNavigator implements Navigator<Type, Class, Field, Method> {
+/*package*/final class ReflectionNavigator implements Navigator<Type, Class<?>, Field, Method> {
 
 //  ----------  Singleton -----------------
     private static final ReflectionNavigator INSTANCE = new ReflectionNavigator();
@@ -44,20 +44,22 @@
     }
 //  ---------------------------------------
 
-    public Class getSuperClass(Class clazz) {
+    @Override
+    public Class<?> getSuperClass(Class<?> clazz) {
         if (clazz == Object.class) {
             return null;
         }
-        Class sc = clazz.getSuperclass();
+        Class<?> sc = clazz.getSuperclass();
         if (sc == null) {
             sc = Object.class;        // error recovery
         }
         return sc;
     }
 
-    private static final TypeVisitor<Type, Class> baseClassFinder = new TypeVisitor<Type, Class>() {
+    private static final TypeVisitor<Type, Class<?>> baseClassFinder = new TypeVisitor<Type, Class<?>>() {
 
-        public Type onClass(Class c, Class sup) {
+        @Override
+        public Type onClass(Class<?> c, Class<?> sup) {
             // t is a raw type
             if (sup == c) {
                 return sup;
@@ -83,8 +85,9 @@
             return null;
         }
 
-        public Type onParameterizdType(ParameterizedType p, Class sup) {
-            Class raw = (Class) p.getRawType();
+        @Override
+        public Type onParameterizdType(ParameterizedType p, Class<?> sup) {
+            Class<?> raw = (Class<?>) p.getRawType();
             if (raw == sup) {
                 // p is of the form sup<...>
                 return p;
@@ -107,16 +110,19 @@
             }
         }
 
-        public Type onGenericArray(GenericArrayType g, Class sup) {
+        @Override
+        public Type onGenericArray(GenericArrayType g, Class<?> sup) {
             // not clear what I should do here
             return null;
         }
 
-        public Type onVariable(TypeVariable v, Class sup) {
+        @Override
+        public Type onVariable(TypeVariable v, Class<?> sup) {
             return visit(v.getBounds()[0], sup);
         }
 
-        public Type onWildcard(WildcardType w, Class sup) {
+        @Override
+        public Type onWildcard(WildcardType w, Class<?> sup) {
             // not clear what I should do here
             return null;
         }
@@ -160,10 +166,12 @@
     }
     private static final TypeVisitor<Type, BinderArg> binder = new TypeVisitor<Type, BinderArg>() {
 
-        public Type onClass(Class c, BinderArg args) {
+        @Override
+        public Type onClass(Class<?> c, BinderArg args) {
             return c;
         }
 
+        @Override
         public Type onParameterizdType(ParameterizedType p, BinderArg args) {
             Type[] params = p.getActualTypeArguments();
 
@@ -187,6 +195,7 @@
             return new ParameterizedTypeImpl((Class<?>) p.getRawType(), params, newOwner);
         }
 
+        @Override
         public Type onGenericArray(GenericArrayType g, BinderArg types) {
             Type c = visit(g.getGenericComponentType(), types);
             if (c == g.getGenericComponentType()) {
@@ -196,10 +205,12 @@
             return new GenericArrayTypeImpl(c);
         }
 
+        @Override
         public Type onVariable(TypeVariable v, BinderArg types) {
             return types.replace(v);
         }
 
+        @Override
         public Type onWildcard(WildcardType w, BinderArg types) {
             // TODO: this is probably still incorrect
             // bind( "? extends T" ) with T= "? extends Foo" should be "? extends Foo",
@@ -228,17 +239,20 @@
         }
     };
 
-    public Type getBaseClass(Type t, Class sup) {
+    @Override
+    public Type getBaseClass(Type t, Class<?> sup) {
         return baseClassFinder.visit(t, sup);
     }
 
-    public String getClassName(Class clazz) {
+    @Override
+    public String getClassName(Class<?> clazz) {
         return clazz.getName();
     }
 
+    @Override
     public String getTypeName(Type type) {
         if (type instanceof Class) {
-            Class c = (Class) type;
+            Class<?> c = (Class) type;
             if (c.isArray()) {
                 return getTypeName(c.getComponentType()) + "[]";
             }
@@ -247,11 +261,13 @@
         return type.toString();
     }
 
-    public String getClassShortName(Class clazz) {
+    @Override
+    public String getClassShortName(Class<?> clazz) {
         return clazz.getSimpleName();
     }
 
-    public Collection<? extends Field> getDeclaredFields(final Class clazz) {
+    @Override
+    public Collection<? extends Field> getDeclaredFields(final Class<?> clazz) {
         Field[] fields = AccessController.doPrivileged(new PrivilegedAction<Field[]>() {
             @Override
             public Field[] run() {
@@ -261,7 +277,8 @@
         return Arrays.asList(fields);
     }
 
-    public Field getDeclaredField(final Class clazz, final String fieldName) {
+    @Override
+    public Field getDeclaredField(final Class<?> clazz, final String fieldName) {
         return AccessController.doPrivileged(new PrivilegedAction<Field>() {
             @Override
             public Field run() {
@@ -274,7 +291,8 @@
         });
     }
 
-    public Collection<? extends Method> getDeclaredMethods(final Class clazz) {
+    @Override
+    public Collection<? extends Method> getDeclaredMethods(final Class<?> clazz) {
         Method[] methods =
             AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
                 @Override
@@ -285,17 +303,20 @@
         return Arrays.asList(methods);
     }
 
-    public Class getDeclaringClassForField(Field field) {
+    @Override
+    public Class<?> getDeclaringClassForField(Field field) {
         return field.getDeclaringClass();
     }
 
-    public Class getDeclaringClassForMethod(Method method) {
+    @Override
+    public Class<?> getDeclaringClassForMethod(Method method) {
         return method.getDeclaringClass();
     }
 
+    @Override
     public Type getFieldType(Field field) {
         if (field.getType().isArray()) {
-            Class c = field.getType().getComponentType();
+            Class<?> c = field.getType().getComponentType();
             if (c.isPrimitive()) {
                 return Array.newInstance(c, 0).getClass();
             }
@@ -303,47 +324,58 @@
         return fix(field.getGenericType());
     }
 
+    @Override
     public String getFieldName(Field field) {
         return field.getName();
     }
 
+    @Override
     public String getMethodName(Method method) {
         return method.getName();
     }
 
+    @Override
     public Type getReturnType(Method method) {
         return fix(method.getGenericReturnType());
     }
 
+    @Override
     public Type[] getMethodParameters(Method method) {
         return method.getGenericParameterTypes();
     }
 
+    @Override
     public boolean isStaticMethod(Method method) {
         return Modifier.isStatic(method.getModifiers());
     }
 
+    @Override
     public boolean isFinalMethod(Method method) {
         return Modifier.isFinal(method.getModifiers());
     }
 
+    @Override
     public boolean isSubClassOf(Type sub, Type sup) {
         return erasure(sup).isAssignableFrom(erasure(sub));
     }
 
-    public Class ref(Class c) {
+    @Override
+    public Class<?> ref(Class<?> c) {
         return c;
     }
 
-    public Class use(Class c) {
+    @Override
+    public Class<?> use(Class<?> c) {
         return c;
     }
 
-    public Class asDecl(Type t) {
+    @Override
+    public Class<?> asDecl(Type t) {
         return erasure(t);
     }
 
-    public Class asDecl(Class c) {
+    @Override
+    public Class<?> asDecl(Class<?> c) {
         return c;
     }
     /**
@@ -351,26 +383,31 @@
      */
     private static final TypeVisitor<Class, Void> eraser = new TypeVisitor<Class, Void>() {
 
-        public Class onClass(Class c, Void v) {
+        @Override
+        public Class<?> onClass(Class<?> c, Void v) {
             return c;
         }
 
-        public Class onParameterizdType(ParameterizedType p, Void v) {
+        @Override
+        public Class<?> onParameterizdType(ParameterizedType p, Void v) {
             // TODO: why getRawType returns Type? not Class?
             return visit(p.getRawType(), null);
         }
 
-        public Class onGenericArray(GenericArrayType g, Void v) {
+        @Override
+        public Class<?> onGenericArray(GenericArrayType g, Void v) {
             return Array.newInstance(
                     visit(g.getGenericComponentType(), null),
                     0).getClass();
         }
 
-        public Class onVariable(TypeVariable tv, Void v) {
+        @Override
+        public Class<?> onVariable(TypeVariable tv, Void v) {
             return visit(tv.getBounds()[0], null);
         }
 
-        public Class onWildcard(WildcardType w, Void v) {
+        @Override
+        public Class<?> onWildcard(WildcardType w, Void v) {
             return visit(w.getUpperBounds()[0], null);
         }
     };
@@ -390,28 +427,32 @@
      * layer for two different underlying reflection library. The other way
      * is to throw away the entire parameterization and go to the wrapper approach.
      */
+    @Override
     public <T> Class<T> erasure(Type t) {
         return eraser.visit(t, null);
     }
 
-    public boolean isAbstract(Class clazz) {
+    @Override
+    public boolean isAbstract(Class<?> clazz) {
         return Modifier.isAbstract(clazz.getModifiers());
     }
 
-    public boolean isFinal(Class clazz) {
+    @Override
+    public boolean isFinal(Class<?> clazz) {
         return Modifier.isFinal(clazz.getModifiers());
     }
 
     /**
      * Returns the {@link Type} object that represents {@code clazz<T1,T2,T3>}.
      */
-    public Type createParameterizedType(Class rawType, Type... arguments) {
+    public Type createParameterizedType(Class<?> rawType, Type... arguments) {
         return new ParameterizedTypeImpl(rawType, arguments, null);
     }
 
+    @Override
     public boolean isArray(Type t) {
         if (t instanceof Class) {
-            Class c = (Class) t;
+            Class<?> c = (Class) t;
             return c.isArray();
         }
         if (t instanceof GenericArrayType) {
@@ -420,9 +461,10 @@
         return false;
     }
 
+    @Override
     public boolean isArrayButNotByteArray(Type t) {
         if (t instanceof Class) {
-            Class c = (Class) t;
+            Class<?> c = (Class) t;
             return c.isArray() && c != byte[].class;
         }
         if (t instanceof GenericArrayType) {
@@ -432,9 +474,10 @@
         return false;
     }
 
+    @Override
     public Type getComponentType(Type t) {
         if (t instanceof Class) {
-            Class c = (Class) t;
+            Class<?> c = (Class) t;
             return c.getComponentType();
         }
         if (t instanceof GenericArrayType) {
@@ -444,6 +487,7 @@
         throw new IllegalArgumentException();
     }
 
+    @Override
     public Type getTypeArgument(Type type, int i) {
         if (type instanceof ParameterizedType) {
             ParameterizedType p = (ParameterizedType) type;
@@ -453,24 +497,28 @@
         }
     }
 
+    @Override
     public boolean isParameterizedType(Type type) {
         return type instanceof ParameterizedType;
     }
 
+    @Override
     public boolean isPrimitive(Type type) {
         if (type instanceof Class) {
-            Class c = (Class) type;
+            Class<?> c = (Class) type;
             return c.isPrimitive();
         }
         return false;
     }
 
-    public Type getPrimitive(Class primitiveType) {
+    @Override
+    public Type getPrimitive(Class<?> primitiveType) {
         assert primitiveType.isPrimitive();
         return primitiveType;
     }
 
-    public Location getClassLocation(final Class clazz) {
+    @Override
+    public Location getClassLocation(final Class<?> clazz) {
         return new Location() {
 
             @Override
@@ -480,6 +528,7 @@
         };
     }
 
+    @Override
     public Location getFieldLocation(final Field field) {
         return new Location() {
 
@@ -490,6 +539,7 @@
         };
     }
 
+    @Override
     public Location getMethodLocation(final Method method) {
         return new Location() {
 
@@ -500,7 +550,8 @@
         };
     }
 
-    public boolean hasDefaultConstructor(Class c) {
+    @Override
+    public boolean hasDefaultConstructor(Class<?> c) {
         try {
             c.getDeclaredConstructor();
             return true;
@@ -509,23 +560,28 @@
         }
     }
 
+    @Override
     public boolean isStaticField(Field field) {
         return Modifier.isStatic(field.getModifiers());
     }
 
+    @Override
     public boolean isPublicMethod(Method method) {
         return Modifier.isPublic(method.getModifiers());
     }
 
+    @Override
     public boolean isPublicField(Field field) {
         return Modifier.isPublic(field.getModifiers());
     }
 
-    public boolean isEnum(Class c) {
+    @Override
+    public boolean isEnum(Class<?> c) {
         return Enum.class.isAssignableFrom(c);
     }
 
-    public Field[] getEnumConstants(Class clazz) {
+    @Override
+    public Field[] getEnumConstants(Class<?> clazz) {
         try {
             Object[] values = clazz.getEnumConstants();
             Field[] fields = new Field[values.length];
@@ -539,11 +595,13 @@
         }
     }
 
+    @Override
     public Type getVoidType() {
         return Void.class;
     }
 
-    public String getPackageName(Class clazz) {
+    @Override
+    public String getPackageName(Class<?> clazz) {
         String name = clazz.getName();
         int idx = name.lastIndexOf('.');
         if (idx < 0) {
@@ -554,7 +612,7 @@
     }
 
     @Override
-    public Class loadObjectFactory(Class referencePoint, String pkg) {
+    public Class<?> loadObjectFactory(Class<?> referencePoint, String pkg) {
         ClassLoader cl = SecureLoader.getClassClassLoader(referencePoint);
         if (cl == null)
             cl = SecureLoader.getSystemClassLoader();
@@ -566,11 +624,13 @@
         }
     }
 
+    @Override
     public boolean isBridgeMethod(Method method) {
         return method.isBridge();
     }
 
-    public boolean isOverriding(Method method, final Class base) {
+    @Override
+    public boolean isOverriding(Method method, final Class<?> base) {
         // this isn't actually correct,
         // as the JLS considers
         // class Derived extends Base<Integer> {
@@ -589,7 +649,7 @@
 
                     @Override
                     public Boolean run() {
-                        Class clazz = base;
+                        Class<?> clazz = base;
                         while (clazz != null) {
                             try {
                                 Method m = clazz.getDeclaredMethod(name, params);
@@ -607,15 +667,18 @@
         );
     }
 
-    public boolean isInterface(Class clazz) {
+    @Override
+    public boolean isInterface(Class<?> clazz) {
         return clazz.isInterface();
     }
 
+    @Override
     public boolean isTransient(Field f) {
         return Modifier.isTransient(f.getModifiers());
     }
 
-    public boolean isInnerClass(Class clazz) {
+    @Override
+    public boolean isInnerClass(Class<?> clazz) {
         return clazz.getEnclosingClass() != null && !Modifier.isStatic(clazz.getModifiers());
     }
 
@@ -637,7 +700,7 @@
 
         GenericArrayType gat = (GenericArrayType) t;
         if (gat.getGenericComponentType() instanceof Class) {
-            Class c = (Class) gat.getGenericComponentType();
+            Class<?> c = (Class<?>) gat.getGenericComponentType();
             return Array.newInstance(c, 0).getClass();
         }
 
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/SecureLoader.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/SecureLoader.java
index d674dec..be173ab 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/SecureLoader.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/SecureLoader.java
@@ -31,7 +31,7 @@
         }
     }
 
-    static ClassLoader getClassClassLoader(final Class c) {
+    static ClassLoader getClassClassLoader(final Class<?> c) {
         if (System.getSecurityManager() == null) {
             return c.getClassLoader();
         } else {
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/TypeVisitor.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/TypeVisitor.java
index b6e8d1f..a33242a 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/TypeVisitor.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/TypeVisitor.java
@@ -24,7 +24,7 @@
         assert t!=null;
 
         if (t instanceof Class)
-            return onClass((Class)t,param);
+            return onClass((Class<?>)t,param);
         if (t instanceof ParameterizedType)
             return onParameterizdType( (ParameterizedType)t,param);
         if(t instanceof GenericArrayType)
@@ -39,7 +39,7 @@
         throw new IllegalArgumentException();
     }
 
-    protected abstract T onClass(Class c, P param);
+    protected abstract T onClass(Class<?> c, P param);
     protected abstract T onParameterizdType(ParameterizedType p, P param);
     protected abstract T onGenericArray(GenericArrayType g, P param);
     protected abstract T onVariable(TypeVariable v, P param);
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/WildcardTypeImpl.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/WildcardTypeImpl.java
index 006800f..ce2f3c5 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/WildcardTypeImpl.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/model/nav/WildcardTypeImpl.java
@@ -27,18 +27,22 @@
         this.lb = lb;
     }
 
+    @Override
     public Type[] getUpperBounds() {
         return ub;
     }
 
+    @Override
     public Type[] getLowerBounds() {
         return lb;
     }
 
+    @Override
     public int hashCode() {
         return Arrays.hashCode(lb) ^ Arrays.hashCode(ub);
     }
 
+    @Override
     public boolean equals(Object obj) {
         if (obj instanceof WildcardType) {
             WildcardType that = (WildcardType) obj;
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/IllegalAnnotationException.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/IllegalAnnotationException.java
index 20d0a95..3e9cff6 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/IllegalAnnotationException.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/IllegalAnnotationException.java
@@ -70,7 +70,7 @@
     }
 
     private List<List<Location>> build(Locatable... srcs) {
-        List<List<Location>> r = new ArrayList<List<Location>>();
+        List<List<Location>> r = new ArrayList<>();
         for( Locatable l : srcs ) {
             if(l!=null) {
                 List<Location> ll = convert(l);
@@ -87,7 +87,7 @@
     private List<Location> convert(Locatable src) {
         if(src==null)   return null;
 
-        List<Location> r = new ArrayList<Location>();
+        List<Location> r = new ArrayList<>();
         for( ; src!=null; src=src.getUpstream())
             r.add(src.getLocation());
         return Collections.unmodifiableList(r);
@@ -158,6 +158,7 @@
      * this crucial detail to show up even when this exception is nested
      * inside other exceptions.
      */
+    @Override
     public String toString() {
         StringBuilder sb = new StringBuilder(getMessage());
 
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/Location.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/Location.java
index 55abf5c..ada3567 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/Location.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/Location.java
@@ -26,5 +26,6 @@
      * @return
      *      never null.
      */
+    @Override
     String toString();
 }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/RuntimeUtil.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/RuntimeUtil.java
index bc084b0..020b6db 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/RuntimeUtil.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/RuntimeUtil.java
@@ -20,14 +20,26 @@
  * @author Kohsuke Kawaguchi
  */
 public class RuntimeUtil {
+
+    private RuntimeUtil() {}
+
     /**
      * XmlAdapter for printing arbitrary object by using {@link Object#toString()}.
      */
     public static final class ToStringAdapter extends XmlAdapter<String,Object> {
+
+        /**
+         * Default constructor.
+         */
+        public ToStringAdapter() {
+        }
+
+        @Override
         public Object unmarshal(String s) {
             throw new UnsupportedOperationException();
         }
 
+        @Override
         public String marshal(Object o) {
             if(o==null)     return null;
             return o.toString();
@@ -40,15 +52,15 @@
      * <p>
      * e.g., {@code int -> Integer}.
      */
-    public static final Map<Class,Class> boxToPrimitive;
+    public static final Map<Class<?>, Class<?>> boxToPrimitive;
 
     /**
      * Reverse map of {@link #boxToPrimitive}.
      */
-    public static final Map<Class,Class> primitiveToBox;
+    public static final Map<Class<?>, Class<?>> primitiveToBox;
 
     static {
-        Map<Class,Class> b = new HashMap<Class,Class>();
+        Map<Class<?>, Class<?>> b = new HashMap<>();
         b.put(Byte.TYPE,Byte.class);
         b.put(Short.TYPE,Short.class);
         b.put(Integer.TYPE,Integer.class);
@@ -61,8 +73,8 @@
 
         primitiveToBox = Collections.unmodifiableMap(b);
 
-        Map<Class,Class> p = new HashMap<Class,Class>();
-        for( Map.Entry<Class,Class> e :  b.entrySet() )
+        Map<Class<?>, Class<?>> p = new HashMap<>();
+        for( Map.Entry<Class<?>, Class<?>> e :  b.entrySet() )
             p.put(e.getValue(),e.getKey());
 
         boxToPrimitive = Collections.unmodifiableMap(p);
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/SwaRefAdapterMarker.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/SwaRefAdapterMarker.java
index e2b6c44..bdf9feb 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/SwaRefAdapterMarker.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/SwaRefAdapterMarker.java
@@ -20,10 +20,18 @@
  */
 public class SwaRefAdapterMarker extends XmlAdapter<String, DataHandler> {
 
+    /**
+     * Default constructor.
+     */
+    public SwaRefAdapterMarker() {
+    }
+
+    @Override
     public DataHandler unmarshal(String v) throws Exception {
         throw new IllegalStateException("Not implemented");
     }
 
+    @Override
     public String marshal(DataHandler v) throws Exception {
         throw new IllegalStateException("Not implemented");
     }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/unmarshaller/LocatorEx.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/unmarshaller/LocatorEx.java
index b542791..3e4cff5 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/unmarshaller/LocatorEx.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/runtime/unmarshaller/LocatorEx.java
@@ -53,38 +53,47 @@
             node = vel.getNode();
         }
 
+        @Override
         public Object getObject() {
             return object;
         }
 
+        @Override
         public Node getNode() {
             return node;
         }
 
+        @Override
         public int getOffset() {
             return offset;
         }
 
+        @Override
         public URL getURL() {
             return url;
         }
 
+        @Override
         public int getColumnNumber() {
             return columnNumber;
         }
 
+        @Override
         public int getLineNumber() {
             return lineNumber;
         }
 
+        @Override
         public String getSystemId() {
             return systemId;
         }
 
+        @Override
         public String getPublicId() {
             return publicId;
         }
 
+        @Override
         public ValidationEventLocator getLocation() {
             return this;
         }
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/util/EditDistance.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/util/EditDistance.java
index f3773df..1bed381 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/util/EditDistance.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/util/EditDistance.java
@@ -41,7 +41,7 @@
      */
     public static int editDistance( String a, String b ) {
         // let's check cache
-        AbstractMap.SimpleEntry<String,String> entry = new AbstractMap.SimpleEntry<String, String>(a, b); // using this class to avoid creation of my own which will handle PAIR of values
+        AbstractMap.SimpleEntry<String,String> entry = new AbstractMap.SimpleEntry<>(a, b); // using this class to avoid creation of my own which will handle PAIR of values
         Integer result = null;
         if (CACHE.containsKey(entry))
             result = CACHE.get(entry); // looks like we have it
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/util/FlattenIterator.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/util/FlattenIterator.java
index 09e654f..e1f0298 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/util/FlattenIterator.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/util/FlattenIterator.java
@@ -31,15 +31,18 @@
     }
 
 
+    @Override
     public void remove() {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public boolean hasNext() {
         getNext();
         return next!=null;
     }
 
+    @Override
     public T next() {
         T r = next;
         next = null;
diff --git a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/util/XmlFactory.java b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/util/XmlFactory.java
index 9072986..6cb73d4 100644
--- a/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/util/XmlFactory.java
+++ b/jaxb-ri/core/src/main/java/org/glassfish/jaxb/core/v2/util/XmlFactory.java
@@ -62,6 +62,8 @@
             }
     );
 
+    private XmlFactory() {}
+
     private static boolean isXMLSecurityDisabled(boolean runtimeSetting) {
         return XML_SECURITY_DISABLED || runtimeSetting;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/AccessorFactoryImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/AccessorFactoryImpl.java
index ac29007..e83dc72 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/AccessorFactoryImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/AccessorFactoryImpl.java
@@ -32,6 +32,7 @@
      * @param readOnly  the isStatic value of the field's modifier.
      * @return Accessor the accessor for this field
      */
+    @Override
     public Accessor createFieldAccessor(Class bean, Field field, boolean readOnly) {
         return readOnly
                 ? new Accessor.ReadOnlyFieldReflection(field)
@@ -47,6 +48,7 @@
      * @param supressWarning supress security warning about accessing fields through reflection
      * @return Accessor the accessor for this field
      */
+    @Override
     public Accessor createFieldAccessor(Class bean, Field field, boolean readOnly, boolean supressWarning) {
         return readOnly
                 ? new Accessor.ReadOnlyFieldReflection(field, supressWarning)
@@ -61,6 +63,7 @@
      * @param setter the setter method to be accessed. The value can be null.
      * @return Accessor the accessor for these methods
      */
+    @Override
     public Accessor createPropertyAccessor(Class bean, Method getter, Method setter) {    
         if (getter == null) {
             return new Accessor.SetterOnlyReflection(setter);
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/AnyTypeAdapter.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/AnyTypeAdapter.java
index 0059f40..f7fd7a6 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/AnyTypeAdapter.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/AnyTypeAdapter.java
@@ -25,6 +25,7 @@
     /**
      * Noop. Just returns the object given as the argument.
      */
+    @Override
     public Object unmarshal(Object v) {
         return v;
     }
@@ -32,6 +33,7 @@
     /**
      * Noop. Just returns the object given as the argument.
      */
+    @Override
     public Object marshal(Object v) {
         return v;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/DatatypeConverterImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/DatatypeConverterImpl.java
index 209ec23..c56ef02 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/DatatypeConverterImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/DatatypeConverterImpl.java
@@ -713,6 +713,7 @@
 
     public static DatatypeFactory getDatatypeFactory() {
         ClassLoader tccl = AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
+            @Override
             public ClassLoader run() {
                 return Thread.currentThread().getContextClassLoader();
             }
@@ -884,102 +885,122 @@
     // DEPRECATED METHODS, KEPT FOR JAXB1 GENERATED CLASSES COMPATIBILITY, WILL BE REMOVED IN FUTURE
 
     @Deprecated
+    @Override
     public String parseString(String lexicalXSDString) {
         return lexicalXSDString;
     }
 
     @Deprecated
+    @Override
     public BigInteger parseInteger(String lexicalXSDInteger) {
         return _parseInteger(lexicalXSDInteger);
     }
 
     @Deprecated
+    @Override
     public String printInteger(BigInteger val) {
         return _printInteger(val);
     }
 
     @Deprecated
+    @Override
     public int parseInt(String s) {
         return _parseInt(s);
     }
 
     @Deprecated
+    @Override
     public long parseLong(String lexicalXSLong) {
         return _parseLong(lexicalXSLong);
     }
 
     @Deprecated
+    @Override
     public short parseShort(String lexicalXSDShort) {
         return _parseShort(lexicalXSDShort);
     }
 
     @Deprecated
+    @Override
     public String printShort(short val) {
         return _printShort(val);
     }
 
     @Deprecated
+    @Override
     public BigDecimal parseDecimal(String content) {
         return _parseDecimal(content);
     }
 
     @Deprecated
+    @Override
     public float parseFloat(String lexicalXSDFloat) {
         return _parseFloat(lexicalXSDFloat);
     }
 
     @Deprecated
+    @Override
     public String printFloat(float v) {
         return _printFloat(v);
     }
 
     @Deprecated
+    @Override
     public double parseDouble(String lexicalXSDDouble) {
         return _parseDouble(lexicalXSDDouble);
     }
 
     @Deprecated
+    @Override
     public boolean parseBoolean(String lexicalXSDBoolean) {
         Boolean b = _parseBoolean(lexicalXSDBoolean);
         return (b == null) ? false : b.booleanValue();
     }
 
     @Deprecated
+    @Override
     public String printBoolean(boolean val) {
         return val ? "true" : "false";
     }
 
     @Deprecated
+    @Override
     public byte parseByte(String lexicalXSDByte) {
         return _parseByte(lexicalXSDByte);
     }
 
     @Deprecated
+    @Override
     public String printByte(byte val) {
         return _printByte(val);
     }
 
     @Deprecated
+    @Override
     public QName parseQName(String lexicalXSDQName, NamespaceContext nsc) {
         return _parseQName(lexicalXSDQName, nsc);
     }
 
     @Deprecated
+    @Override
     public Calendar parseDateTime(String lexicalXSDDateTime) {
         return _parseDateTime(lexicalXSDDateTime);
     }
 
     @Deprecated
+    @Override
     public String printDateTime(Calendar val) {
         return _printDateTime(val);
     }
 
     @Deprecated
+    @Override
     public byte[] parseBase64Binary(String lexicalXSDBase64Binary) {
         return _parseBase64Binary(lexicalXSDBase64Binary);
     }
 
     @Deprecated
+    @Override
     public byte[] parseHexBinary(String s) {
         final int len = s.length();
 
@@ -1021,6 +1042,7 @@
     private static final char[] hexCode = "0123456789ABCDEF".toCharArray();
 
     @Deprecated
+    @Override
     public String printHexBinary(byte[] data) {
         StringBuilder r = new StringBuilder(data.length * 2);
         for (byte b : data) {
@@ -1031,86 +1053,103 @@
     }
 
     @Deprecated
+    @Override
     public long parseUnsignedInt(String lexicalXSDUnsignedInt) {
         return _parseLong(lexicalXSDUnsignedInt);
     }
 
     @Deprecated
+    @Override
     public String printUnsignedInt(long val) {
         return _printLong(val);
     }
 
     @Deprecated
+    @Override
     public int parseUnsignedShort(String lexicalXSDUnsignedShort) {
         return _parseInt(lexicalXSDUnsignedShort);
     }
 
     @Deprecated
+    @Override
     public Calendar parseTime(String lexicalXSDTime) {
         return getDatatypeFactory().newXMLGregorianCalendar(lexicalXSDTime).toGregorianCalendar();
     }
 
     @Deprecated
+    @Override
     public String printTime(Calendar val) {
         return CalendarFormatter.doFormat("%h:%m:%s%z", val);
     }
 
     @Deprecated
+    @Override
     public Calendar parseDate(String lexicalXSDDate) {
         return getDatatypeFactory().newXMLGregorianCalendar(lexicalXSDDate).toGregorianCalendar();
     }
 
     @Deprecated
+    @Override
     public String printDate(Calendar val) {
         return _printDate(val);
     }
 
     @Deprecated
+    @Override
     public String parseAnySimpleType(String lexicalXSDAnySimpleType) {
         return lexicalXSDAnySimpleType;
     }
 
     @Deprecated
+    @Override
     public String printString(String val) {
         return val;
     }
 
     @Deprecated
+    @Override
     public String printInt(int val) {
         return _printInt(val);
     }
 
     @Deprecated
+    @Override
     public String printLong(long val) {
         return _printLong(val);
     }
 
     @Deprecated
+    @Override
     public String printDecimal(BigDecimal val) {
         return _printDecimal(val);
     }
 
     @Deprecated
+    @Override
     public String printDouble(double v) {
         return _printDouble(v);
     }
 
     @Deprecated
+    @Override
     public String printQName(QName val, NamespaceContext nsc) {
         return _printQName(val, nsc);
     }
 
     @Deprecated
+    @Override
     public String printBase64Binary(byte[] val) {
         return _printBase64Binary(val);
     }
 
     @Deprecated
+    @Override
     public String printUnsignedShort(int val) {
         return String.valueOf(val);
     }
 
     @Deprecated
+    @Override
     public String printAnySimpleType(String val) {
         return val;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/api/BridgeContext.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/api/BridgeContext.java
index 13aff01..e673a74 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/api/BridgeContext.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/api/BridgeContext.java
@@ -38,6 +38,7 @@
  *      The caller no longer needs to use this, as {@link Bridge} has
  *      methods that can work without {@link BridgeContext}.
  */
+@Deprecated
 public abstract class BridgeContext {
     protected BridgeContext() {}
     
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/api/JAXBRIContext.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/api/JAXBRIContext.java
index 63d7b9c..f3ed546 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/api/JAXBRIContext.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/api/JAXBRIContext.java
@@ -119,7 +119,7 @@
        boolean allNillable,
        boolean retainPropertyInfo,
        boolean supressAccessorWarnings) throws JAXBException {
-        Map<String, Object> properties = new HashMap<String, Object>();
+        Map<String, Object> properties = new HashMap<>();
         if (typeRefs != null) properties.put(JAXBRIContext.TYPE_REFERENCES, typeRefs);
         if (subclassReplacements != null) properties.put(JAXBRIContext.SUBCLASS_REPLACEMENTS, subclassReplacements);
         if (defaultNamespaceRemap != null) properties.put(JAXBRIContext.DEFAULT_NAMESPACE_REMAP, defaultNamespaceRemap);
@@ -136,6 +136,7 @@
      * @deprecated
      *      Compatibility with older versions.
      */
+    @Deprecated
     public static JAXBRIContext newInstance(@NotNull Class[] classes,
         @Nullable Collection<TypeReference> typeRefs,
         @Nullable String defaultNamespaceRemap, boolean c14nSupport ) throws JAXBException {
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/marshaller/NioEscapeHandler.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/marshaller/NioEscapeHandler.java
index a29cc7d..98215b3 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/marshaller/NioEscapeHandler.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/marshaller/NioEscapeHandler.java
@@ -47,6 +47,7 @@
         this.encoder = Charset.forName(charsetName).newEncoder(); 
     }
     
+    @Override
     public void escape(char[] ch, int start, int length, boolean isAttVal, Writer out) throws IOException {
         int limit = start+length;
         for (int i = start; i < limit; i++) {
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/util/AttributesImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/util/AttributesImpl.java
index c72a09d..92daea5 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/util/AttributesImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/util/AttributesImpl.java
@@ -96,6 +96,7 @@
      * @return The number of attributes in the list.
      * @see org.xml.sax.Attributes#getLength()
      */
+    @Override
     public int getLength ()
     {
 	return length;
@@ -110,6 +111,7 @@
      *         available, or null if the index is out of range.
      * @see org.xml.sax.Attributes#getURI(int)
      */
+    @Override
     public String getURI (int index)
     {
 	if (index >= 0 && index < length) {
@@ -128,6 +130,7 @@
      *         none is available, or null if the index if out of range.
      * @see org.xml.sax.Attributes#getLocalName(int)
      */
+    @Override
     public String getLocalName (int index)
     {
 	if (index >= 0 && index < length) {
@@ -146,6 +149,7 @@
      *         none is available, or null if the index is out of bounds.
      * @see org.xml.sax.Attributes#getQName(int)
      */
+    @Override
     public String getQName (int index)
     {
 	if (index >= 0 && index < length) {
@@ -164,6 +168,7 @@
      *         if the index is out of bounds.
      * @see org.xml.sax.Attributes#getType(int)
      */
+    @Override
     public String getType (int index)
     {
 	if (index >= 0 && index < length) {
@@ -181,6 +186,7 @@
      * @return The attribute's value or null if the index is out of bounds.
      * @see org.xml.sax.Attributes#getValue(int)
      */
+    @Override
     public String getValue (int index)
     {
 	if (index >= 0 && index < length) {
@@ -204,6 +210,7 @@
      * @return The attribute's index, or -1 if none matches.
      * @see org.xml.sax.Attributes#getIndex(java.lang.String,java.lang.String)
      */
+    @Override
     public int getIndex (String uri, String localName)
     {
 	int max = length * 5;
@@ -236,6 +243,7 @@
      * @return The attribute's index, or -1 if none matches.
      * @see org.xml.sax.Attributes#getIndex(java.lang.String)
      */
+    @Override
     public int getIndex (String qName)
     {
 	int max = length * 5;
@@ -258,6 +266,7 @@
      *         matching attribute.
      * @see org.xml.sax.Attributes#getType(java.lang.String,java.lang.String)
      */
+    @Override
     public String getType (String uri, String localName)
     {
 	int max = length * 5;
@@ -278,6 +287,7 @@
      *         matching attribute.
      * @see org.xml.sax.Attributes#getType(java.lang.String)
      */
+    @Override
     public String getType (String qName)
     {
 	int max = length * 5;
@@ -300,6 +310,7 @@
      *         matching attribute.
      * @see org.xml.sax.Attributes#getValue(java.lang.String,java.lang.String)
      */
+    @Override
     public String getValue (String uri, String localName)
     {
 	int max = length * 5;
@@ -320,6 +331,7 @@
      *         matching attribute.
      * @see org.xml.sax.Attributes#getValue(java.lang.String)
      */
+    @Override
     public String getValue (String qName)
     {
 	int max = length * 5;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/util/ValidationEventLocatorExImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/util/ValidationEventLocatorExImpl.java
index 45ef0ae..1f511f6 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/util/ValidationEventLocatorExImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/util/ValidationEventLocatorExImpl.java
@@ -29,6 +29,7 @@
         this.fieldName = fieldName;
     }
     
+    @Override
     public String getFieldName() {
         return fieldName;
     }
@@ -36,6 +37,7 @@
     /**
      * Returns a nice string representation for better debug experience.
      */
+    @Override
     public String toString() {
         StringBuffer buf = new StringBuffer();
         buf.append("[url=");
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/ContextFactory.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/ContextFactory.java
index d897ded..a9f6a05 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/ContextFactory.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/ContextFactory.java
@@ -50,7 +50,7 @@
         if(properties==null)
             properties = Collections.emptyMap();
         else
-            properties = new HashMap<String,Object>(properties);
+            properties = new HashMap<>(properties);
 
         String defaultNsUri = getPropertyValue(properties, JAXBRIContext.DEFAULT_NAMESPACE_REMAP,String.class);
 
@@ -222,7 +222,7 @@
      */
     public static JAXBContext createContext( String contextPath,
                                              ClassLoader classLoader, Map<String,Object> properties ) throws JAXBException {
-        FinalArrayList<Class> classes = new FinalArrayList<Class>();
+        FinalArrayList<Class> classes = new FinalArrayList<>();
         StringTokenizer tokens = new StringTokenizer(contextPath,":");
         List<Class> indexedClasses;
 
@@ -285,7 +285,7 @@
         BufferedReader in =
                 new BufferedReader(new InputStreamReader(resourceAsStream, "UTF-8"));
         try {
-            FinalArrayList<Class> classes = new FinalArrayList<Class>();
+            FinalArrayList<Class> classes = new FinalArrayList<>();
             String className = in.readLine();
             while (className != null) {
                 className = className.trim();
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/AbstractInlineAnnotationReaderImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/AbstractInlineAnnotationReaderImpl.java
index 17737ce..6232fbb 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/AbstractInlineAnnotationReaderImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/AbstractInlineAnnotationReaderImpl.java
@@ -30,6 +30,7 @@
 
     private ErrorHandler errorHandler;
 
+    @Override
     public void setErrorHandler(ErrorHandler errorHandler) {
         if(errorHandler==null)
             throw new IllegalArgumentException();
@@ -44,6 +45,7 @@
         return errorHandler;
     }
 
+    @Override
     public final <A extends Annotation> A getMethodAnnotation(Class<A> annotation, M getter, M setter, Locatable srcPos) {
         A a1 = getter==null?null:getMethodAnnotation(annotation,getter,srcPos);
         A a2 = setter==null?null:getMethodAnnotation(annotation,setter,srcPos);
@@ -68,6 +70,7 @@
         }
     }
 
+    @Override
     public boolean hasMethodAnnotation(Class<? extends Annotation> annotation, String propertyName, M getter, M setter, Locatable srcPos) {
         boolean x = ( getter != null && hasMethodAnnotation(annotation, getter) );
         boolean y = ( setter != null && hasMethodAnnotation(annotation, setter) );
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/ClassLocatable.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/ClassLocatable.java
index 40a2c64..8c19776 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/ClassLocatable.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/ClassLocatable.java
@@ -30,10 +30,12 @@
         this.nav = nav;
     }
 
+    @Override
     public Locatable getUpstream() {
         return upstream;
     }
 
+    @Override
     public Location getLocation() {
         return nav.getClassLocation(clazz);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/FieldLocatable.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/FieldLocatable.java
index a29a1f4..b6ffc9e 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/FieldLocatable.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/FieldLocatable.java
@@ -30,10 +30,12 @@
         this.nav = nav;
     }
 
+    @Override
     public Locatable getUpstream() {
         return upstream;
     }
 
+    @Override
     public Location getLocation() {
         return nav.getFieldLocation(field);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/LocatableAnnotation.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/LocatableAnnotation.java
index 51e77b0..aceb4af 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/LocatableAnnotation.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/LocatableAnnotation.java
@@ -68,14 +68,17 @@
         this.upstream = upstream;
     }
 
+    @Override
     public Locatable getUpstream() {
         return upstream;
     }
 
+    @Override
     public Location getLocation() {
         return this;
     }
 
+    @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         try {
             if(method.getDeclaringClass()==Locatable.class)
@@ -94,6 +97,7 @@
         }
     }
 
+    @Override
     public String toString() {
         return core.toString();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/Messages.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/Messages.java
index e6c3a5c..b37d2ed 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/Messages.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/Messages.java
@@ -24,6 +24,7 @@
 
     private static final ResourceBundle rb = ResourceBundle.getBundle(Messages.class.getName());
 
+    @Override
     public String toString() {
         return format();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/MethodLocatable.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/MethodLocatable.java
index f4e8fb5..da4a9ac 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/MethodLocatable.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/MethodLocatable.java
@@ -30,10 +30,12 @@
         this.nav = nav;
     }
 
+    @Override
     public Locatable getUpstream() {
         return upstream;
     }
 
+    @Override
     public Location getLocation() {
         return nav.getMethodLocation(method);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/Quick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/Quick.java
index 7deea74..bacb0e2 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/Quick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/Quick.java
@@ -42,14 +42,17 @@
      */
     protected abstract Quick newInstance( Locatable upstream, Annotation core );
 
+    @Override
     public final Location getLocation() {
         return this;
     }
 
+    @Override
     public final Locatable getUpstream() {
         return upstream;
     }
 
+    @Override
     public final String toString() {
         return getAnnotation().toString();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/RuntimeInlineAnnotationReader.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/RuntimeInlineAnnotationReader.java
index 5285f90..84fe392 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/RuntimeInlineAnnotationReader.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/RuntimeInlineAnnotationReader.java
@@ -29,18 +29,22 @@
 public final class RuntimeInlineAnnotationReader extends AbstractInlineAnnotationReaderImpl<Type,Class,Field,Method>
     implements RuntimeAnnotationReader {
 
+    @Override
     public <A extends Annotation> A getFieldAnnotation(Class<A> annotation, Field field, Locatable srcPos) {
         return LocatableAnnotation.create(field.getAnnotation(annotation),srcPos);
     }
 
+    @Override
     public boolean hasFieldAnnotation(Class<? extends Annotation> annotationType, Field field) {
         return field.isAnnotationPresent(annotationType);
     }
 
+    @Override
     public boolean hasClassAnnotation(Class clazz, Class<? extends Annotation> annotationType) {
         return clazz.isAnnotationPresent(annotationType);
     }
 
+    @Override
     public Annotation[] getAllFieldAnnotations(Field field, Locatable srcPos) {
         Annotation[] r = field.getAnnotations();
         for( int i=0; i<r.length; i++ ) {
@@ -49,14 +53,17 @@
         return r;
     }
 
+    @Override
     public <A extends Annotation> A getMethodAnnotation(Class<A> annotation, Method method, Locatable srcPos) {
         return LocatableAnnotation.create(method.getAnnotation(annotation),srcPos);
     }
 
+    @Override
     public boolean hasMethodAnnotation(Class<? extends Annotation> annotation, Method method) {
         return method.isAnnotationPresent(annotation);
     }
 
+    @Override
     public Annotation[] getAllMethodAnnotations(Method method, Locatable srcPos) {
         Annotation[] r = method.getAnnotations();
         for( int i=0; i<r.length; i++ ) {
@@ -65,6 +72,7 @@
         return r;
     }
 
+    @Override
     public <A extends Annotation> A getMethodParameterAnnotation(Class<A> annotation, Method method, int paramIndex, Locatable srcPos) {
         Annotation[] pa = method.getParameterAnnotations()[paramIndex];
         for( Annotation a : pa ) {
@@ -74,6 +82,7 @@
         return null;
     }
 
+    @Override
     public <A extends Annotation> A getClassAnnotation(Class<A> a, Class clazz, Locatable srcPos) {
         return LocatableAnnotation.create(((Class<?>)clazz).getAnnotation(a),srcPos);
     }
@@ -83,15 +92,16 @@
      * Cache for package-level annotations.
      */
     private final Map<Class<? extends Annotation>,Map<Package,Annotation>> packageCache =
-            new HashMap<Class<? extends Annotation>,Map<Package,Annotation>>();
+            new HashMap<>();
 
+    @Override
     public <A extends Annotation> A getPackageAnnotation(Class<A> a, Class clazz, Locatable srcPos) {
         Package p = clazz.getPackage();
         if(p==null) return null;
 
         Map<Package,Annotation> cache = packageCache.get(a);
         if(cache==null) {
-            cache = new HashMap<Package,Annotation>();
+            cache = new HashMap<>();
             packageCache.put(a,cache);
         }
 
@@ -104,6 +114,7 @@
         }
     }
 
+    @Override
     public Class getClassValue(Annotation a, String name) {
         try {
             return (Class)a.annotationType().getMethod(name).invoke(a);
@@ -118,6 +129,7 @@
         }
     }
 
+    @Override
     public Class[] getClassArrayValue(Annotation a, String name) {
         try {
             return (Class[])a.annotationType().getMethod(name).invoke(a);
@@ -132,6 +144,7 @@
         }
     }
 
+    @Override
     protected String fullName(Method m) {
         return m.getDeclaringClass().getName()+'#'+m.getName();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/SecureLoader.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/SecureLoader.java
index c0d7d9d..dbfbe5d 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/SecureLoader.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/SecureLoader.java
@@ -24,6 +24,7 @@
         } else {
             return (ClassLoader) java.security.AccessController.doPrivileged(
                     new java.security.PrivilegedAction() {
+                        @Override
                         public java.lang.Object run() {
                             return Thread.currentThread().getContextClassLoader();
                         }
@@ -37,6 +38,7 @@
         } else {
             return (ClassLoader) java.security.AccessController.doPrivileged(
                     new java.security.PrivilegedAction() {
+                        @Override
                         public java.lang.Object run() {
                             return c.getClassLoader();
                         }
@@ -50,6 +52,7 @@
         } else {
             return (ClassLoader) java.security.AccessController.doPrivileged(
                     new java.security.PrivilegedAction() {
+                        @Override
                         public java.lang.Object run() {
                             return ClassLoader.getSystemClassLoader();
                         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlAttributeQuick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlAttributeQuick.java
index 68c4de5..6960b07 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlAttributeQuick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlAttributeQuick.java
@@ -32,26 +32,32 @@
         this.core = core;
     }
 
+    @Override
     protected Annotation getAnnotation() {
         return core;
     }
 
+    @Override
     protected Quick newInstance(Locatable upstream, Annotation core) {
         return new XmlAttributeQuick(upstream, ((XmlAttribute) core));
     }
 
+    @Override
     public Class<XmlAttribute> annotationType() {
         return XmlAttribute.class;
     }
 
+    @Override
     public String name() {
         return core.name();
     }
 
+    @Override
     public String namespace() {
         return core.namespace();
     }
 
+    @Override
     public boolean required() {
         return core.required();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementDeclQuick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementDeclQuick.java
index 9f2a523..2697f32 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementDeclQuick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementDeclQuick.java
@@ -32,38 +32,47 @@
         this.core = core;
     }
 
+    @Override
     protected Annotation getAnnotation() {
         return core;
     }
 
+    @Override
     protected Quick newInstance(Locatable upstream, Annotation core) {
         return new XmlElementDeclQuick(upstream, ((XmlElementDecl) core));
     }
 
+    @Override
     public Class<XmlElementDecl> annotationType() {
         return XmlElementDecl.class;
     }
 
+    @Override
     public String name() {
         return core.name();
     }
 
+    @Override
     public Class scope() {
         return core.scope();
     }
 
+    @Override
     public String namespace() {
         return core.namespace();
     }
 
+    @Override
     public String defaultValue() {
         return core.defaultValue();
     }
 
+    @Override
     public String substitutionHeadNamespace() {
         return core.substitutionHeadNamespace();
     }
 
+    @Override
     public String substitutionHeadName() {
         return core.substitutionHeadName();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementQuick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementQuick.java
index 14476a2..9b52f3a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementQuick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementQuick.java
@@ -32,38 +32,47 @@
         this.core = core;
     }
 
+    @Override
     protected Annotation getAnnotation() {
         return core;
     }
 
+    @Override
     protected Quick newInstance(Locatable upstream, Annotation core) {
         return new XmlElementQuick(upstream, ((XmlElement) core));
     }
 
+    @Override
     public Class<XmlElement> annotationType() {
         return XmlElement.class;
     }
 
+    @Override
     public String name() {
         return core.name();
     }
 
+    @Override
     public Class type() {
         return core.type();
     }
 
+    @Override
     public String namespace() {
         return core.namespace();
     }
 
+    @Override
     public String defaultValue() {
         return core.defaultValue();
     }
 
+    @Override
     public boolean required() {
         return core.required();
     }
 
+    @Override
     public boolean nillable() {
         return core.nillable();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementRefQuick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementRefQuick.java
index 5f6cb90..ac8a26f 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementRefQuick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementRefQuick.java
@@ -32,30 +32,37 @@
         this.core = core;
     }
 
+    @Override
     protected Annotation getAnnotation() {
         return core;
     }
 
+    @Override
     protected Quick newInstance(Locatable upstream, Annotation core) {
         return new XmlElementRefQuick(upstream, ((XmlElementRef) core));
     }
 
+    @Override
     public Class<XmlElementRef> annotationType() {
         return XmlElementRef.class;
     }
 
+    @Override
     public String name() {
         return core.name();
     }
 
+    @Override
     public Class type() {
         return core.type();
     }
 
+    @Override
     public String namespace() {
         return core.namespace();
     }
 
+    @Override
     public boolean required() {
         return core.required();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementRefsQuick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementRefsQuick.java
index 524f528..700a6cf 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementRefsQuick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlElementRefsQuick.java
@@ -33,18 +33,22 @@
         this.core = core;
     }
 
+    @Override
     protected Annotation getAnnotation() {
         return core;
     }
 
+    @Override
     protected Quick newInstance(Locatable upstream, Annotation core) {
         return new XmlElementRefsQuick(upstream, ((XmlElementRefs) core));
     }
 
+    @Override
     public Class<XmlElementRefs> annotationType() {
         return XmlElementRefs.class;
     }
 
+    @Override
     public XmlElementRef[] value() {
         return core.value();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlEnumQuick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlEnumQuick.java
index 34d078c..2041c9b 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlEnumQuick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlEnumQuick.java
@@ -32,18 +32,22 @@
         this.core = core;
     }
 
+    @Override
     protected Annotation getAnnotation() {
         return core;
     }
 
+    @Override
     protected Quick newInstance(Locatable upstream, Annotation core) {
         return new XmlEnumQuick(upstream, ((XmlEnum) core));
     }
 
+    @Override
     public Class<XmlEnum> annotationType() {
         return XmlEnum.class;
     }
 
+    @Override
     public Class value() {
         return core.value();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlRootElementQuick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlRootElementQuick.java
index ca36aca..6e66ce6 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlRootElementQuick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlRootElementQuick.java
@@ -32,22 +32,27 @@
         this.core = core;
     }
 
+    @Override
     protected Annotation getAnnotation() {
         return core;
     }
 
+    @Override
     protected Quick newInstance(Locatable upstream, Annotation core) {
         return new XmlRootElementQuick(upstream, ((XmlRootElement) core));
     }
 
+    @Override
     public Class<XmlRootElement> annotationType() {
         return XmlRootElement.class;
     }
 
+    @Override
     public String name() {
         return core.name();
     }
 
+    @Override
     public String namespace() {
         return core.namespace();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlSchemaQuick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlSchemaQuick.java
index 1112ec0..676fc0c 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlSchemaQuick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlSchemaQuick.java
@@ -34,34 +34,42 @@
         this.core = core;
     }
 
+    @Override
     protected Annotation getAnnotation() {
         return core;
     }
 
+    @Override
     protected Quick newInstance(Locatable upstream, Annotation core) {
         return new XmlSchemaQuick(upstream, ((XmlSchema) core));
     }
 
+    @Override
     public Class<XmlSchema> annotationType() {
         return XmlSchema.class;
     }
 
+    @Override
     public String location() {
         return core.location();
     }
 
+    @Override
     public String namespace() {
         return core.namespace();
     }
 
+    @Override
     public XmlNs[] xmlns() {
         return core.xmlns();
     }
 
+    @Override
     public XmlNsForm elementFormDefault() {
         return core.elementFormDefault();
     }
 
+    @Override
     public XmlNsForm attributeFormDefault() {
         return core.attributeFormDefault();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlSchemaTypeQuick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlSchemaTypeQuick.java
index 41a8c7c..c0670b7 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlSchemaTypeQuick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlSchemaTypeQuick.java
@@ -32,26 +32,32 @@
         this.core = core;
     }
 
+    @Override
     protected Annotation getAnnotation() {
         return core;
     }
 
+    @Override
     protected Quick newInstance(Locatable upstream, Annotation core) {
         return new XmlSchemaTypeQuick(upstream, ((XmlSchemaType) core));
     }
 
+    @Override
     public Class<XmlSchemaType> annotationType() {
         return XmlSchemaType.class;
     }
 
+    @Override
     public String name() {
         return core.name();
     }
 
+    @Override
     public Class type() {
         return core.type();
     }
 
+    @Override
     public String namespace() {
         return core.namespace();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlTransientQuick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlTransientQuick.java
index cb4eaa5..3388ab3 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlTransientQuick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlTransientQuick.java
@@ -32,14 +32,17 @@
         this.core = core;
     }
 
+    @Override
     protected Annotation getAnnotation() {
         return core;
     }
 
+    @Override
     protected Quick newInstance(Locatable upstream, Annotation core) {
         return new XmlTransientQuick(upstream, ((XmlTransient) core));
     }
 
+    @Override
     public Class<XmlTransient> annotationType() {
         return XmlTransient.class;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlTypeQuick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlTypeQuick.java
index db3f377..f1b8bfd 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlTypeQuick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlTypeQuick.java
@@ -32,34 +32,42 @@
         this.core = core;
     }
 
+    @Override
     protected Annotation getAnnotation() {
         return core;
     }
 
+    @Override
     protected Quick newInstance(Locatable upstream, Annotation core) {
         return new XmlTypeQuick(upstream, ((XmlType) core));
     }
 
+    @Override
     public Class<XmlType> annotationType() {
         return XmlType.class;
     }
 
+    @Override
     public String name() {
         return core.name();
     }
 
+    @Override
     public String namespace() {
         return core.namespace();
     }
 
+    @Override
     public String[] propOrder() {
         return core.propOrder();
     }
 
+    @Override
     public Class factoryClass() {
         return core.factoryClass();
     }
 
+    @Override
     public String factoryMethod() {
         return core.factoryMethod();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlValueQuick.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlValueQuick.java
index dfa8fec..daba353 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlValueQuick.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/annotation/XmlValueQuick.java
@@ -32,14 +32,17 @@
         this.core = core;
     }
 
+    @Override
     protected Annotation getAnnotation() {
         return core;
     }
 
+    @Override
     protected Quick newInstance(Locatable upstream, Annotation core) {
         return new XmlValueQuick(upstream, ((XmlValue) core));
     }
 
+    @Override
     public Class<XmlValue> annotationType() {
         return XmlValue.class;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/AnyTypeImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/AnyTypeImpl.java
index 3b49695..d352e7c 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/AnyTypeImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/AnyTypeImpl.java
@@ -34,22 +34,27 @@
         this.nav = nav;
     }
 
+    @Override
     public QName getTypeName() {
         return ANYTYPE_NAME;
     }
 
+    @Override
     public T getType() {
         return type;
     }
 
+    @Override
     public Locatable getUpstream() {
         return null;
     }
 
+    @Override
     public boolean isSimpleType() {
         return false;
     }
 
+    @Override
     public Location getLocation() {
         return nav.getClassLocation(nav.asDecl(Object.class));
     }
@@ -60,6 +65,8 @@
      * @deprecated
      *      why are you calling a method whose return value is always known?
      */
+    @Override
+    @Deprecated
     public final boolean canBeReferencedByIDREF() {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ArrayInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ArrayInfoImpl.java
index e231f37..c80e169 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ArrayInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ArrayInfoImpl.java
@@ -55,18 +55,22 @@
         this.typeName = ArrayInfoUtil.calcArrayTypeName(n);
     }
 
+    @Override
     public NonElement<TypeT, ClassDeclT> getItemType() {
         return itemType;
     }
 
+    @Override
     public QName getTypeName() {
         return typeName;
     }
 
+    @Override
     public boolean isSimpleType() {
         return false;
     }
 
+    @Override
     public TypeT getType() {
         return arrayType;
     }
@@ -77,13 +81,17 @@
      * @deprecated
      *      why are you calling a method whose return value is always known?
      */
+    @Override
+    @Deprecated
     public final boolean canBeReferencedByIDREF() {
         return false;
     }
 
+    @Override
     public Location getLocation() {
         return this;
     }
+    @Override
     public String toString() {
         return nav().getTypeName(arrayType);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/AttributePropertyInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/AttributePropertyInfoImpl.java
index c637ab9..0a3943a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/AttributePropertyInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/AttributePropertyInfoImpl.java
@@ -73,14 +73,17 @@
         return new QName(uri.intern(),local.intern());
     }
 
+    @Override
     public boolean isRequired() {
         return isRequired;
     }
 
+    @Override
     public final QName getXmlName() {
         return xmlName;
     }
 
+    @Override
     public final PropertyKind kind() {
         return PropertyKind.ATTRIBUTE;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/BuiltinLeafInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/BuiltinLeafInfoImpl.java
index dc7509d..275e92b 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/BuiltinLeafInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/BuiltinLeafInfoImpl.java
@@ -47,6 +47,8 @@
     /**
      * @deprecated always return false at this level.
      */
+    @Override
+    @Deprecated
     public final boolean isElement() {
         return false;
     }
@@ -54,6 +56,8 @@
     /**
      * @deprecated always return null at this level.
      */
+    @Override
+    @Deprecated
     public final QName getElementName() {
         return null;
     }
@@ -61,6 +65,8 @@
     /**
      * @deprecated always return null at this level.
      */
+    @Override
+    @Deprecated
     public final Element<TypeT,ClassDeclT> asElement() {
         return null;
     }
@@ -72,11 +78,11 @@
      */
     public static <TypeT,ClassDeclT>
     Map<TypeT,BuiltinLeafInfoImpl<TypeT,ClassDeclT>> createLeaves( Navigator<TypeT,ClassDeclT,?,?> nav ) {
-        Map<TypeT,BuiltinLeafInfoImpl<TypeT,ClassDeclT>> leaves = new HashMap<TypeT,BuiltinLeafInfoImpl<TypeT,ClassDeclT>>();
+        Map<TypeT,BuiltinLeafInfoImpl<TypeT,ClassDeclT>> leaves = new HashMap<>();
 
         for( RuntimeBuiltinLeafInfoImpl<?> leaf : RuntimeBuiltinLeafInfoImpl.builtinBeanInfos ) {
             TypeT t = nav.ref(leaf.getClazz());
-            leaves.put( t, new BuiltinLeafInfoImpl<TypeT,ClassDeclT>(t,leaf.getTypeNames()) );
+            leaves.put( t, new BuiltinLeafInfoImpl<>(t,leaf.getTypeNames()) );
         }
 
         return leaves;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ClassInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ClassInfoImpl.java
index a963fe4..be51b0e 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ClassInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ClassInfoImpl.java
@@ -147,6 +147,7 @@
         }
     }        
 
+    @Override
     public ClassInfoImpl<T,C,F,M> getBaseClass() {
         if (!baseClassComputed) {
             // compute the base class
@@ -172,6 +173,7 @@
      *
      * The substitution hierarchy is the same as the inheritance hierarchy.
      */
+    @Override
     public final Element<T,C> getSubstitutionHead() {
         ClassInfoImpl<T,C,F,M> c = getBaseClass();
         while(c!=null && !c.isElement())
@@ -179,6 +181,7 @@
         return c;
     }
 
+    @Override
     public final C getClazz() {
         return clazz;
     }
@@ -190,10 +193,13 @@
      * @deprecated
      *      you shouldn't be invoking this method on {@link ClassInfoImpl}.
      */
+    @Override
+    @Deprecated
     public ClassInfoImpl<T,C,F,M> getScope() {
         return null;
     }
 
+    @Override
     public final T getType() {
         return nav().use(clazz);
     }
@@ -202,6 +208,7 @@
      * A {@link ClassInfo} can be referenced by {@link XmlIDREF} if
      * it has an ID property.
      */
+    @Override
     public boolean canBeReferencedByIDREF() {
         for (PropertyInfo<T,C> p : getProperties()) {
             if(p.id()== ID.ID)
@@ -214,6 +221,7 @@
             return false;
     }
 
+    @Override
     public final String getName() {
         return nav().getClassName(clazz);
     }
@@ -222,6 +230,7 @@
         return reader().getClassAnnotation(a,clazz,this);
     }
 
+    @Override
     public Element<T,C> asElement() {
         if(isElement())
             return this;
@@ -229,13 +238,14 @@
             return null;
     }
 
+    @Override
     public List<? extends PropertyInfo<T,C>> getProperties() {
         if(properties!=null)    return properties;
 
         // check the access type first
         XmlAccessType at = getAccessType();
 
-        properties = new FinalArrayList<PropertyInfoImpl<T,C,F,M>>();
+        properties = new FinalArrayList<>();
 
         findFieldProperties(clazz,at);
 
@@ -342,6 +352,7 @@
         }
     }
 
+    @Override
     public final boolean hasValueProperty() {
         ClassInfoImpl<T, C, F, M> bc = getBaseClass();
         if(bc!=null && bc.hasValueProperty())
@@ -354,6 +365,7 @@
         return false;
         }
 
+    @Override
     public PropertyInfo<T,C> getProperty(String name) {
         for( PropertyInfo<T,C> p: getProperties() ) {
             if(p.getName().equals(name))
@@ -430,6 +442,7 @@
                 }
         }
 
+        @Override
         public int compare(PropertyInfoImpl o1, PropertyInfoImpl o2) {
             int lhs = checkedGet(o1);
             int rhs = checkedGet(o2);
@@ -454,7 +467,7 @@
             int ii = i;
             if(ii<used.length) {
                 if(used[ii]!=null && used[ii]!=p) {
-                    if(collidedNames==null) collidedNames = new HashSet<String>();
+                    if(collidedNames==null) collidedNames = new HashSet<>();
 
                     if(collidedNames.add(p.getName()))
                         // report the error only on the first time
@@ -475,10 +488,12 @@
                 if(used[i]==null) {
                     String unusedName = propOrder[i];
                     String nearest = EditDistance.findNearest(unusedName, new AbstractList<String>() {
+                        @Override
                         public String get(int index) {
                             return properties.get(index).getName();
                         }
 
+                        @Override
                         public int size() {
                             return properties.size();
                         }
@@ -492,6 +507,7 @@
         }
     }
 
+    @Override
     public boolean hasProperties() {
         return !properties.isEmpty();
     }
@@ -508,7 +524,7 @@
     }
 
     private static <T> List<T> makeSet( T... args ) {
-        List<T> l = new FinalArrayList<T>();
+        List<T> l = new FinalArrayList<>();
         for( T arg : args )
             if(arg!=null)   l.add(arg);
         return l;
@@ -841,23 +857,23 @@
     }
 
     protected ReferencePropertyInfoImpl<T,C,F,M> createReferenceProperty(PropertySeed<T,C,F,M> seed) {
-        return new ReferencePropertyInfoImpl<T,C,F,M>(this,seed);
+        return new ReferencePropertyInfoImpl<>(this,seed);
     }
 
     protected AttributePropertyInfoImpl<T,C,F,M> createAttributeProperty(PropertySeed<T,C,F,M> seed) {
-        return new AttributePropertyInfoImpl<T,C,F,M>(this,seed);
+        return new AttributePropertyInfoImpl<>(this,seed);
     }
 
     protected ValuePropertyInfoImpl<T,C,F,M> createValueProperty(PropertySeed<T,C,F,M> seed) {
-        return new ValuePropertyInfoImpl<T,C,F,M>(this,seed);
+        return new ValuePropertyInfoImpl<>(this,seed);
     }
 
     protected ElementPropertyInfoImpl<T,C,F,M> createElementProperty(PropertySeed<T,C,F,M> seed) {
-        return new ElementPropertyInfoImpl<T,C,F,M>(this,seed);
+        return new ElementPropertyInfoImpl<>(this,seed);
     }
 
     protected MapPropertyInfoImpl<T,C,F,M> createMapProperty(PropertySeed<T,C,F,M> seed) {
-        return new MapPropertyInfoImpl<T,C,F,M>(this,seed);
+        return new MapPropertyInfoImpl<>(this,seed);
     }
 
 
@@ -867,8 +883,8 @@
     private void findGetterSetterProperties(XmlAccessType at) {
         // in the first step we accumulate getters and setters
         // into this map keyed by the property name.
-        Map<String,M> getters = new LinkedHashMap<String,M>();
-        Map<String,M> setters = new LinkedHashMap<String,M>();
+        Map<String,M> getters = new LinkedHashMap<>();
+        Map<String,M> setters = new LinkedHashMap<>();
 
         C c = clazz;
         do {
@@ -880,7 +896,7 @@
 
 
         // compute the intersection
-        Set<String> complete = new TreeSet<String>(getters.keySet());
+        Set<String> complete = new TreeSet<>(getters.keySet());
         complete.retainAll(setters.keySet());
 
         resurrect(getters, complete);
@@ -891,8 +907,8 @@
             M getter = getters.get(name);
             M setter = setters.get(name);
 
-            Annotation[] ga = getter!=null ? reader().getAllMethodAnnotations(getter,new MethodLocatable<M>(this,getter,nav())) : EMPTY_ANNOTATIONS;
-            Annotation[] sa = setter!=null ? reader().getAllMethodAnnotations(setter,new MethodLocatable<M>(this,setter,nav())) : EMPTY_ANNOTATIONS;
+            Annotation[] ga = getter!=null ? reader().getAllMethodAnnotations(getter,new MethodLocatable<>(this,getter,nav())) : EMPTY_ANNOTATIONS;
+            Annotation[] sa = setter!=null ? reader().getAllMethodAnnotations(setter,new MethodLocatable<>(this,setter,nav())) : EMPTY_ANNOTATIONS;
 
             boolean hasAnnotation = hasJAXBAnnotation(ga) || hasJAXBAnnotation(sa);
             boolean isOverriding = false;
@@ -915,8 +931,8 @@
                             nav().getTypeName(nav().getReturnType(getter)),
                             nav().getTypeName(nav().getMethodParameters(setter)[0])
                         ),
-                        new MethodLocatable<M>( this, getter, nav()),
-                        new MethodLocatable<M>( this, setter, nav())));
+                        new MethodLocatable<>( this, getter, nav()),
+                        new MethodLocatable<>( this, setter, nav())));
                     continue;
                 }
 
@@ -960,7 +976,7 @@
             collectGetterSetters(sc,getters,setters);
 
         Collection<? extends M> methods = nav().getDeclaredMethods(c);
-        Map<String,List<M>> allSetters = new LinkedHashMap<String,List<M>>();
+        Map<String,List<M>> allSetters = new LinkedHashMap<>();
         for( M method : methods ) {
             boolean used = false;   // if this method is added to getters or setters
 
@@ -987,7 +1003,7 @@
             if(propName!=null && arity==1) {
                     List<M> propSetters = allSetters.get(propName);
                     if(null == propSetters){
-                        propSetters = new ArrayList<M>();
+                        propSetters = new ArrayList<>();
                         allSetters.put(propName, propSetters);
                     }
                     propSetters.add(method);
@@ -1122,44 +1138,52 @@
      * Derived class can override this method to create a sub-class.
      */
     protected PropertySeed<T,C,F,M> createFieldSeed(F f) {
-        return new FieldPropertySeed<T,C,F,M>(this, f);
+        return new FieldPropertySeed<>(this, f);
     }
 
     /**
      * Creates a new {@link GetterSetterPropertySeed} object.
      */
     protected PropertySeed<T,C,F,M> createAccessorSeed(M getter, M setter) {
-        return new GetterSetterPropertySeed<T,C,F,M>(this, getter,setter);
+        return new GetterSetterPropertySeed<>(this, getter,setter);
     }
 
+    @Override
     public final boolean isElement() {
         return elementName!=null;
     }
 
+    @Override
     public boolean isAbstract() {
         return nav().isAbstract(clazz);
     }
 
+    @Override
     public boolean isOrdered() {
         return propOrder!=null;
     }
 
+    @Override
     public final boolean isFinal() {
         return nav().isFinal(clazz);
     }
 
+    @Override
     public final boolean hasSubClasses() {
         return hasSubClasses;
     }
 
+    @Override
     public final boolean hasAttributeWildcard() {
         return declaresAttributeWildcard() || inheritsAttributeWildcard();
     }
 
+    @Override
     public final boolean inheritsAttributeWildcard() {
         return getInheritedAttributeWildcard()!=null;
     }
 
+    @Override
     public final boolean declaresAttributeWildcard() {
         return attributeWildcard!=null;
     }
@@ -1174,14 +1198,17 @@
         return null;
     }
 
+    @Override
     public final QName getElementName() {
         return elementName;
     }
 
+    @Override
     public final QName getTypeName() {
         return typeName;
     }
 
+    @Override
     public final boolean isSimpleType() {
         List<? extends PropertyInfo> props = getProperties();
         if(props.size()!=1)     return false;
@@ -1196,7 +1223,7 @@
         getProperties();    // make sure properties!=null
 
         // property name collision cehck
-        Map<String,PropertyInfoImpl> names = new HashMap<String,PropertyInfoImpl>();
+        Map<String,PropertyInfoImpl> names = new HashMap<>();
         for( PropertyInfoImpl<T,C,F,M> p : properties ) {
             p.link();
             PropertyInfoImpl old = names.put(p.getName(),p);
@@ -1209,6 +1236,7 @@
         super.link();
     }
 
+    @Override
     public Location getLocation() {
         return nav().getClassLocation(clazz);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ElementInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ElementInfoImpl.java
index 4f32bfd..19dfe6f 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ElementInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ElementInfoImpl.java
@@ -93,37 +93,46 @@
         //
         // TypeRef impl
         //
+        @Override
         public NonElement<T,C> getTarget() {
             return contentType;
         }
+        @Override
         public QName getTagName() {
             return tagName;
         }
 
+        @Override
         public List<? extends TypeRef<T,C>> getTypes() {
             return Collections.singletonList(this);
         }
 
+        @Override
         public List<? extends NonElement<T,C>> ref() {
             return Collections.singletonList(contentType);
         }
 
+        @Override
         public QName getXmlName() {
             return tagName;
         }
 
+        @Override
         public boolean isCollectionRequired() {
             return false;
         }
 
+        @Override
         public boolean isCollectionNillable() {
             return true;
         }
 
+        @Override
         public boolean isNillable() {
             return true;
         }
 
+        @Override
         public String getDefaultValue() {
             String v = anno.defaultValue();
             if(v.equals("\u0000"))
@@ -132,18 +141,22 @@
                 return v;
         }
 
+        @Override
         public ElementInfoImpl<T,C,F,M> parent() {
             return ElementInfoImpl.this;
         }
 
+        @Override
         public String getName() {
             return "value";
         }
 
+        @Override
         public String displayName() {
             return "JAXBElement#value";
         }
 
+        @Override
         public boolean isCollection() {
             return isCollection;
         }
@@ -151,38 +164,47 @@
         /**
          * For {@link ElementInfo}s, a collection always means a list of values.
          */
+        @Override
         public boolean isValueList() {
             return isCollection;
         }
 
+        @Override
         public boolean isRequired() {
             return true;
         }
 
+        @Override
         public PropertyKind kind() {
             return PropertyKind.ELEMENT;
         }
 
+        @Override
         public Adapter<T,C> getAdapter() {
             return adapter;
         }
 
+        @Override
         public ID id() {
             return id;
         }
 
+        @Override
         public MimeType getExpectedMimeType() {
             return expectedMimeType;
         }
 
+        @Override
         public QName getSchemaType() {
             return schemaType;
         }
 
+        @Override
         public boolean inlineBinaryData() {
             return inlineBinary;
         }
 
+        @Override
         public PropertyInfo<T,C> getSource() {
             return this;
         }
@@ -192,10 +214,12 @@
         // AnnotationSource impl
         //
         //
+        @Override
         public <A extends Annotation> A readAnnotation(Class<A> annotationType) {
             return reader().getMethodAnnotation(annotationType,method,ElementInfoImpl.this);
         }
 
+        @Override
         public boolean hasAnnotation(Class<? extends Annotation> annotationType) {
             return reader().hasMethodAnnotation(annotationType,method);
         }
@@ -229,12 +253,12 @@
         if(methodParams.length>0) {
             XmlJavaTypeAdapter adapter = reader().getMethodAnnotation(XmlJavaTypeAdapter.class,m,this);
             if(adapter!=null)
-                a = new Adapter<T,C>(adapter,reader(),nav());
+                a = new Adapter<>(adapter,reader(),nav());
             else {
                 XmlAttachmentRef xsa = reader().getMethodAnnotation(XmlAttachmentRef.class,m,this);
                 if(xsa!=null) {
                     TODO.prototype("in Annotation Processing swaRefAdapter isn't avaialble, so this returns null");
-                    a = new Adapter<T,C>(owner.nav.asDecl(SwaRefAdapter.class),owner.nav);
+                    a = new Adapter<>(owner.nav.asDecl(SwaRefAdapter.class),owner.nav);
                 }
             }
         }
@@ -306,14 +330,17 @@
         return new PropertyImpl();
     }
 
+    @Override
     public ElementPropertyInfo<T,C> getProperty() {
         return property;
     }
 
+    @Override
     public NonElement<T,C> getContentType() {
         return contentType;
     }
 
+    @Override
     public T getContentInMemoryType() {
         if(adapter==null) {
             return tOfJAXBElementT;
@@ -322,10 +349,12 @@
         }
     }
 
+    @Override
     public QName getElementName() {
         return tagName;
     }
 
+    @Override
     public T getType() {
         return elementType;
     }
@@ -336,6 +365,8 @@
      * @deprecated
      *      why are you calling a method whose return value is always known?
      */
+    @Override
+    @Deprecated
     public final boolean canBeReferencedByIDREF() {
         return false;
     }
@@ -352,14 +383,17 @@
         }
     }
 
+    @Override
     public ClassInfo<T, C> getScope() {
         return scope;
     }
 
+    @Override
     public ElementInfo<T,C> getSubstitutionHead() {
         return substitutionHead;
     }
 
+    @Override
     public Collection<? extends ElementInfoImpl<T,C,F,M>> getSubstitutionMembers() {
         if(substitutionMembers==null)
             return Collections.emptyList();
@@ -370,7 +404,8 @@
     /**
      * Called after all the {@link TypeInfo}s are collected into the {@link #owner}.
      */
-    /*package*/ void link() {
+    /*package*/@Override
+ void link() {
         // substitution head
         if(anno.substitutionHeadName().length()!=0) {
             QName name = new QName(
@@ -390,10 +425,11 @@
 
     private void addSubstitutionMember(ElementInfoImpl<T,C,F,M> child) {
         if(substitutionMembers==null)
-            substitutionMembers = new FinalArrayList<ElementInfoImpl<T,C,F,M>>();
+            substitutionMembers = new FinalArrayList<>();
         substitutionMembers.add(child);
     }
 
+    @Override
     public Location getLocation() {
         return nav().getMethodLocation(method);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ElementPropertyInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ElementPropertyInfoImpl.java
index 9b5e9af..1f5de9a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ElementPropertyInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ElementPropertyInfoImpl.java
@@ -39,10 +39,12 @@
     private List<TypeRefImpl<TypeT,ClassDeclT>> types;
 
     private final List<TypeInfo<TypeT,ClassDeclT>> ref = new AbstractList<TypeInfo<TypeT,ClassDeclT>>() {
+        @Override
         public TypeInfo<TypeT,ClassDeclT> get(int index) {
             return getTypes().get(index).getTarget();
         }
 
+        @Override
         public int size() {
             return getTypes().size();
         }
@@ -68,9 +70,10 @@
 
     }
 
+    @Override
     public List<? extends TypeRefImpl<TypeT,ClassDeclT>> getTypes() {
         if(types==null) {
-            types = new FinalArrayList<TypeRefImpl<TypeT,ClassDeclT>>();
+            types = new FinalArrayList<>();
             XmlElement[] ann=null;
 
             XmlElement xe = seed.readAnnotation(XmlElement.class);
@@ -128,27 +131,32 @@
      * Used by {@link PropertyInfoImpl} to create new instances of {@link TypeRef}
      */
     protected TypeRefImpl<TypeT,ClassDeclT> createTypeRef(QName name,TypeT type,boolean isNillable,String defaultValue) {
-        return new TypeRefImpl<TypeT,ClassDeclT>(this,name,type,isNillable,defaultValue);
+        return new TypeRefImpl<>(this,name,type,isNillable,defaultValue);
     }
 
+    @Override
     public boolean isValueList() {
         return isValueList;
     }
 
+    @Override
     public boolean isRequired() {
         if(isRequired==null)
             getTypes(); // compute the value
         return isRequired;
     }
 
+    @Override
     public List<? extends TypeInfo<TypeT,ClassDeclT>> ref() {
         return ref;
     }
 
+    @Override
     public final PropertyKind kind() {
         return PropertyKind.ELEMENT;
     }
 
+    @Override
     protected void link() {
         super.link();
         for (TypeRefImpl<TypeT, ClassDeclT> ref : getTypes() ) {
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/EnumConstantImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/EnumConstantImpl.java
index 1b85784..4def2ba 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/EnumConstantImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/EnumConstantImpl.java
@@ -33,14 +33,17 @@
         this.next = next;
     }
 
+    @Override
     public EnumLeafInfo<T,C> getEnclosingClass() {
         return owner;
     }
 
+    @Override
     public final String getLexicalValue() {
         return lexical;
     }
 
+    @Override
     public final String getName() {
         return name;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/EnumLeafInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/EnumLeafInfoImpl.java
index f5748c9..7a620a6 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/EnumLeafInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/EnumLeafInfoImpl.java
@@ -125,10 +125,11 @@
     }
 
     protected EnumConstantImpl<T,C,F,M> createEnumConstant(String name, String literal, F constant, EnumConstantImpl<T,C,F,M> last) {
-        return new EnumConstantImpl<T,C,F,M>(this, name, literal, last);
+        return new EnumConstantImpl<>(this, name, literal, last);
     }
 
 
+    @Override
     public T getType() {
         return type;
     }
@@ -147,30 +148,38 @@
      * @deprecated
      *      why are you calling a method whose return value is always known?
      */
+    @Override
+    @Deprecated
     public final boolean canBeReferencedByIDREF() {
         return false;
     }
 
+    @Override
     public QName getTypeName() {
         return typeName;
     }
 
+    @Override
     public C getClazz() {
         return clazz;
     }
 
+    @Override
     public NonElement<T,C> getBaseType() {
         return baseType;
     }
 
+    @Override
     public boolean isSimpleType() {
         return true;
     }
 
+    @Override
     public Location getLocation() {
         return nav().getClassLocation(clazz);
     }
 
+    @Override
     public Iterable<? extends EnumConstantImpl<T,C,F,M>> getConstants() {
         if(firstConstant==null)
             calcConstants();
@@ -189,18 +198,23 @@
      *
      * @deprecated if you are invoking this method directly, there's something wrong.
      */
+    @Override
+    @Deprecated
     public Element<T, C> getSubstitutionHead() {
         return null;
     }
 
+    @Override
     public QName getElementName() {
         return elementName;
     }
 
+    @Override
     public boolean isElement() {
         return elementName!=null;
     }
 
+    @Override
     public Element<T,C> asElement() {
         if(isElement())
             return this;
@@ -215,23 +229,29 @@
      * @deprecated
      *      you shouldn't be invoking this method on {@link ClassInfoImpl}.
      */
+    @Override
+    @Deprecated
     public ClassInfo<T,C> getScope() {
         return null;
     }
 
+    @Override
     public Iterator<EnumConstantImpl<T,C,F,M>> iterator() {
         return new Iterator<EnumConstantImpl<T,C,F,M>>() {
             private EnumConstantImpl<T,C,F,M> next = firstConstant;
+            @Override
             public boolean hasNext() {
                 return next!=null;
             }
 
+            @Override
             public EnumConstantImpl<T,C,F,M> next() {
                 EnumConstantImpl<T,C,F,M> r = next;
                 next = next.next;
                 return r;
             }
 
+            @Override
             public void remove() {
                 throw new UnsupportedOperationException();
             }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/FieldPropertySeed.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/FieldPropertySeed.java
index e8ce447..b86dd3c 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/FieldPropertySeed.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/FieldPropertySeed.java
@@ -30,20 +30,24 @@
         this.field = field;
     }
 
+    @Override
     public <A extends Annotation> A readAnnotation(Class<A> a) {
         return parent.reader().getFieldAnnotation(a, field,this);
     }
 
+    @Override
     public boolean hasAnnotation(Class<? extends Annotation> annotationType) {
         return parent.reader().hasFieldAnnotation(annotationType,field);
     }
 
+    @Override
     public String getName() {
         // according to the spec team, the BeanIntrospector.decapitalize does not apply
         // to the fields. Don't call Introspector.decapitalize
         return parent.nav().getFieldName(field);
     }
 
+    @Override
     public TypeT getRawType() {
         return parent.nav().getFieldType(field);
     }
@@ -51,10 +55,12 @@
     /**
      * Use the enclosing class as the upsream {@link Location}.
      */
+    @Override
     public Locatable getUpstream() {
         return parent;
     }
 
+    @Override
     public Location getLocation() {
         return parent.nav().getFieldLocation(field);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/GetterSetterPropertySeed.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/GetterSetterPropertySeed.java
index 449a232..a52a8ae 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/GetterSetterPropertySeed.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/GetterSetterPropertySeed.java
@@ -39,6 +39,7 @@
             throw new IllegalArgumentException();
     }
 
+    @Override
     public TypeT getRawType() {
         if(getter!=null)
             return parent.nav().getReturnType(getter);
@@ -46,14 +47,17 @@
             return parent.nav().getMethodParameters(setter)[0];
     }
 
+    @Override
     public <A extends Annotation> A readAnnotation(Class<A> annotation) {
         return parent.reader().getMethodAnnotation(annotation, getter,setter,this);
     }
 
+    @Override
     public boolean hasAnnotation(Class<? extends Annotation> annotationType) {
         return parent.reader().hasMethodAnnotation(annotationType,getName(),getter,setter,this);
     }
 
+    @Override
     public String getName() {
         if(getter!=null)
             return getName(getter);
@@ -79,10 +83,12 @@
     /**
      * Use the enclosing class as the upsream {@link Location}.
      */
+    @Override
     public Locatable getUpstream() {
         return parent;
     }
 
+    @Override
     public Location getLocation() {
         if(getter!=null)
             return parent.nav().getMethodLocation(getter);
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/LeafInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/LeafInfoImpl.java
index 8fe2583..bd52d9b 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/LeafInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/LeafInfoImpl.java
@@ -36,6 +36,7 @@
     /**
      * A reference to the representation of the type.
      */
+    @Override
     public TypeT getType() {
         return type;
     }
@@ -46,18 +47,23 @@
      * @deprecated
      *      why are you calling a method whose return value is always known?
      */
+    @Override
+    @Deprecated
     public final boolean canBeReferencedByIDREF() {
         return false;
     }
 
+    @Override
     public QName getTypeName() {
         return typeName;
     }
 
+    @Override
     public Locatable getUpstream() {
         return null;
     }
 
+    @Override
     public Location getLocation() {
         // this isn't very accurate, but it's not too bad
         // doing it correctly need leaves to hold navigator.
@@ -65,10 +71,12 @@
         return this;
     }
 
+    @Override
     public boolean isSimpleType() {
         return true;
     }
 
+    @Override
     public String toString() {
         return type.toString();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/MapPropertyInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/MapPropertyInfoImpl.java
index a789958..5940c7d 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/MapPropertyInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/MapPropertyInfoImpl.java
@@ -55,28 +55,34 @@
         }
     }
 
+    @Override
     public Collection<? extends TypeInfo<T,C>> ref() {
         return Arrays.asList(getKeyType(),getValueType());
     }
 
+    @Override
     public final PropertyKind kind() {
         return PropertyKind.MAP;
     }
 
+    @Override
     public QName getXmlName() {
         return xmlName;
     }
 
+    @Override
     public boolean isCollectionNillable() {
         return nil;
     }
 
+    @Override
     public NonElement<T,C> getKeyType() {
         if(keyTypeInfo==null)
             keyTypeInfo = getTarget(keyType);
         return keyTypeInfo;
     }
 
+    @Override
     public NonElement<T,C> getValueType() {
         if(valueTypeInfo==null)
             valueTypeInfo = getTarget(valueType);
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ModelBuilder.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ModelBuilder.java
index 047c7f1..29c10f3 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ModelBuilder.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ModelBuilder.java
@@ -58,7 +58,7 @@
     /**
      * Used to detect collisions among global type names.
      */
-    private final Map<QName,TypeInfo> typeNames = new HashMap<QName,TypeInfo>();
+    private final Map<QName,TypeInfo> typeNames = new HashMap<>();
 
     /**
      * JAXB doesn't want to use namespaces unless we are told to, but WS-I BP
@@ -80,7 +80,7 @@
      * Packages whose registries are already added.
      */
     /*package*/ final Map<String,RegistryInfoImpl<T,C,F,M>> registries
-            = new HashMap<String,RegistryInfoImpl<T,C,F,M>>();
+            = new HashMap<>();
 
     private final Map<C,C> subclassReplacements;
 
@@ -97,6 +97,7 @@
     public boolean hasSwaRef;
 
     private final ErrorHandler proxyErrorHandler = new ErrorHandler() {
+        @Override
         public void error(IllegalAnnotationException e) {
             reportError(e);
         }
@@ -169,7 +170,7 @@
     }
 
     protected TypeInfoSetImpl<T,C,F,M> createTypeInfoSet() {
-        return new TypeInfoSetImpl<T,C,F,M>(nav,reader,BuiltinLeafInfoImpl.createLeaves(nav));
+        return new TypeInfoSetImpl<>(nav,reader,BuiltinLeafInfoImpl.createLeaves(nav));
     }
 
     /**
@@ -209,7 +210,7 @@
             if(reader.hasClassAnnotation(clazz,XmlTransient.class) || isReplaced) {
                 // handle it as if the base class was specified
                 r = getClassInfo( nav.getSuperClass(clazz), searchForSuperClass,
-                        new ClassLocatable<C>(upstream,clazz,nav) );
+                        new ClassLocatable<>(upstream,clazz,nav) );
             } else {
                 ClassInfoImpl<T,C,F,M> ci = createClassInfo(clazz,upstream);
                 typeInfoSet.add(ci);
@@ -349,20 +350,20 @@
 
 
     protected EnumLeafInfoImpl<T,C,F,M> createEnumLeafInfo(C clazz,Locatable upstream) {
-        return new EnumLeafInfoImpl<T,C,F,M>(this,upstream,clazz,nav.use(clazz));
+        return new EnumLeafInfoImpl<>(this,upstream,clazz,nav.use(clazz));
     }
 
     protected ClassInfoImpl<T,C,F,M> createClassInfo(C clazz, Locatable upstream ) {
-        return new ClassInfoImpl<T,C,F,M>(this,upstream,clazz);
+        return new ClassInfoImpl<>(this,upstream,clazz);
     }
 
     protected ElementInfoImpl<T,C,F,M> createElementInfo(
         RegistryInfoImpl<T,C,F,M> registryInfo, M m) throws IllegalAnnotationException {
-        return new ElementInfoImpl<T,C,F,M>(this,registryInfo,m);
+        return new ElementInfoImpl<>(this,registryInfo,m);
     }
 
     protected ArrayInfoImpl<T,C,F,M> createArrayInfo(Locatable upstream, T arrayType) {
-        return new ArrayInfoImpl<T, C, F, M>(this,upstream,arrayType);
+        return new ArrayInfoImpl<>(this,upstream,arrayType);
     }
 
 
@@ -371,7 +372,7 @@
      * in it.
      */
     public RegistryInfo<T,C> addRegistry(C registryClass, Locatable upstream ) {
-        return new RegistryInfoImpl<T,C,F,M>(this,upstream,registryClass);
+        return new RegistryInfoImpl<>(this,upstream,registryClass);
     }
 
     /**
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/PropertyInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/PropertyInfoImpl.java
index b9226a0..da84bc4 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/PropertyInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/PropertyInfoImpl.java
@@ -84,7 +84,7 @@
         XmlJavaTypeAdapter xjta = getApplicableAdapter(t);
         if(xjta!=null) {
             isCollection = false;
-            adapter = new Adapter<T,C>(xjta,reader(),nav());
+            adapter = new Adapter<>(xjta,reader(),nav());
         } else {
             // check if the adapter is applicable to the individual item in the property
 
@@ -97,7 +97,7 @@
                 XmlAttachmentRef xsa = seed.readAnnotation(XmlAttachmentRef.class);
                 if(xsa!=null) {
                     parent.builder.hasSwaRef = true;
-                    adapter = new Adapter<T,C>(nav().asDecl(SwaRefAdapter.class),nav());
+                    adapter = new Adapter<>(nav().asDecl(SwaRefAdapter.class),nav());
                 } else {
                     adapter = null;
 
@@ -114,7 +114,7 @@
                     }
                 }
             } else {
-                adapter = new Adapter<T,C>(xjta,reader(),nav());
+                adapter = new Adapter<>(xjta,reader(),nav());
             }
         }
 
@@ -124,6 +124,7 @@
     }
 
 
+    @Override
     public ClassInfoImpl<T,C,F,M> parent() {
         return parent;
     }
@@ -157,6 +158,7 @@
         }
     }
 
+    @Override
     public final String getName() {
         return seed.getName();
     }
@@ -212,15 +214,18 @@
      * This is the default implementation of the getAdapter method
      * defined on many of the {@link PropertyInfo}-derived classes.
      */
+    @Override
     public Adapter<T,C> getAdapter() {
         return adapter;
     }
 
 
+    @Override
     public final String displayName() {
         return nav().getClassName(parent.getClazz())+'#'+getName();
     }
 
+    @Override
     public final ID id() {
         return id;
     }
@@ -241,18 +246,22 @@
         }
     }
 
+    @Override
     public final MimeType getExpectedMimeType() {
         return expectedMimeType;
     }
 
+    @Override
     public final boolean inlineBinaryData() {
         return inlineBinary;
     }
 
+    @Override
     public final QName getSchemaType() {
         return schemaType;
     }
 
+    @Override
     public final boolean isCollection() {
         return isCollection;
     }
@@ -278,10 +287,12 @@
      * A {@link PropertyInfoImpl} is always referenced by its enclosing class,
      * so return that as the upstream.
      */
+    @Override
     public Locatable getUpstream() {
         return parent;
     }
 
+    @Override
     public Location getLocation() {
         return seed.getLocation();
     }
@@ -345,14 +356,17 @@
         return new QName(uri.intern(),local.intern());
     }
 
+    @Override
     public int compareTo(PropertyInfoImpl that) {
         return this.getName().compareTo(that.getName());
     }
 
+    @Override
     public final <A extends Annotation> A readAnnotation(Class<A> annotationType) {
         return seed.readAnnotation(annotationType);
     }
 
+    @Override
     public final boolean hasAnnotation(Class<? extends Annotation> annotationType) {
         return seed.hasAnnotation(annotationType);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ReferencePropertyInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ReferencePropertyInfoImpl.java
index cb67278..5d51759 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ReferencePropertyInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ReferencePropertyInfoImpl.java
@@ -36,7 +36,7 @@
      * @see #getElements()
      */
     private Set<Element<T,C>> types;
-    private Set<ReferencePropertyInfoImpl<T,C,F,M>> subTypes = new LinkedHashSet<ReferencePropertyInfoImpl<T,C,F,M>>();
+    private Set<ReferencePropertyInfoImpl<T,C,F,M>> subTypes = new LinkedHashSet<>();
 
     private final boolean isMixed;
 
@@ -66,14 +66,17 @@
         }
     }
 
+    @Override
     public Set<? extends Element<T,C>> ref() {
         return getElements();
     }
 
+    @Override
     public PropertyKind kind() {
         return PropertyKind.REFERENCE;
     }
 
+    @Override
     public Set<? extends Element<T,C>> getElements() {
         if(types==null)
             calcTypes(false);
@@ -89,7 +92,7 @@
      */
     private void calcTypes(boolean last) {
         XmlElementRef[] ann;
-        types = new LinkedHashSet<Element<T,C>>();
+        types = new LinkedHashSet<>();
         XmlElementRefs refs = seed.readAnnotation(XmlElementRefs.class);
         XmlElementRef ref = seed.readAnnotation(XmlElementRef.class);
 
@@ -229,6 +232,7 @@
         types = Collections.unmodifiableSet(types);
     }
 
+    @Override
     public boolean isRequired() {
         if(isRequired==null)
             calcTypes(false);
@@ -345,19 +349,23 @@
 
     }
 
+    @Override
     public final void addType(PropertyInfoImpl<T,C,F,M> info) {
         //noinspection unchecked
         subTypes.add((ReferencePropertyInfoImpl)info);
     }
 
+    @Override
     public final boolean isMixed() {
         return isMixed;
     }
 
+    @Override
     public final WildcardMode getWildcard() {
         return wildcard;
     }
 
+    @Override
     public final C getDOMHandler() {
         return domHandler;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RegistryInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RegistryInfoImpl.java
index 5f5ddba..460825e 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RegistryInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RegistryInfoImpl.java
@@ -40,7 +40,7 @@
     /**
      * Types that are referenced from this registry.
      */
-    private final Set<TypeInfo<T,C>> references = new LinkedHashSet<TypeInfo<T,C>>();
+    private final Set<TypeInfo<T,C>> references = new LinkedHashSet<>();
 
     /**
      * Picks up references in this registry to other types.
@@ -71,7 +71,7 @@
                     // this is a factory method. visit this class
                     references.add(
                         builder.getTypeInfo(nav.getReturnType(m),
-                            new MethodLocatable<M>(this,m,nav)));
+                            new MethodLocatable<>(this,m,nav)));
                 }
 
                 continue;
@@ -92,14 +92,17 @@
         }
     }
 
+    @Override
     public Locatable getUpstream() {
         return upstream;
     }
 
+    @Override
     public Location getLocation() {
         return nav.getClassLocation(registryClass);
     }
 
+    @Override
     public Set<TypeInfo<T,C>> getReferences() {
         return references;
     }
@@ -111,6 +114,7 @@
         return nav.getPackageName(registryClass);
     }
 
+    @Override
     public C getClazz() {
         return registryClass;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeAnyTypeImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeAnyTypeImpl.java
index 84a6ff2..459bf97 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeAnyTypeImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeAnyTypeImpl.java
@@ -23,6 +23,7 @@
         super(Utils.REFLECTION_NAVIGATOR);
     }
 
+    @Override
     public <V> Transducer<V> getTransducer() {
         return null;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeArrayInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeArrayInfoImpl.java
index f7516cc..3410cd1 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeArrayInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeArrayInfoImpl.java
@@ -27,14 +27,17 @@
         super(builder, upstream, arrayType);
     }
 
+    @Override
     public Class getType() {
         return (Class)super.getType();
     }
 
+    @Override
     public RuntimeNonElement getItemType() {
         return (RuntimeNonElement)super.getItemType();
     }
 
+    @Override
     public <V> Transducer<V> getTransducer() {
         return null;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeAttributePropertyInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeAttributePropertyInfoImpl.java
index 848a244..9e3e9d4 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeAttributePropertyInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeAttributePropertyInfoImpl.java
@@ -29,22 +29,27 @@
         super(classInfo, seed);
     }
 
+    @Override
     public boolean elementOnlyContent() {
         return true;
     }
 
+    @Override
     public RuntimeNonElement getTarget() {
         return (RuntimeNonElement) super.getTarget();
     }
 
+    @Override
     public List<? extends RuntimeNonElement> ref() {
         return (List<? extends RuntimeNonElement>)super.ref();
     }
 
+    @Override
     public RuntimePropertyInfo getSource() {
         return this;
     }
 
+    @Override
     public void link() {
         getTransducer();
         super.link();
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeBuiltinLeafInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeBuiltinLeafInfoImpl.java
index e613d75..6f30472 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeBuiltinLeafInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeBuiltinLeafInfoImpl.java
@@ -82,22 +82,27 @@
         LEAVES.put(type,this);
     }
 
+    @Override
     public final Class getClazz() {
         return (Class)getType();
     }
 
 
+    @Override
     public final Transducer getTransducer() {
         return this;
     }
 
+    @Override
     public boolean useNamespace() {
         return false;
     }
 
+    @Override
     public void declareNamespace(T o, XMLSerializer w) throws AccessorException {
     }
 
+    @Override
     public QName getTypeName(T instance) {
         return null;
     }
@@ -110,12 +115,15 @@
             super(type,typeNames);
         }
 
+        @Override
         public abstract String print(T o) throws AccessorException;
 
+        @Override
         public void writeText(XMLSerializer w, T o, String fieldName) throws IOException, SAXException, XMLStreamException, AccessorException {
             w.text(print(o),fieldName);
         }
 
+        @Override
         public void writeLeafElement(XMLSerializer w, Name tagName, T o, String fieldName) throws IOException, SAXException, XMLStreamException, AccessorException {
             w.leafElement(tagName,print(o),fieldName);
         }
@@ -129,12 +137,15 @@
             super(type,typeNames);
         }
 
+        @Override
         public abstract Pcdata print(T o) throws AccessorException;
 
+        @Override
         public final void writeText(XMLSerializer w, T o, String fieldName) throws IOException, SAXException, XMLStreamException, AccessorException {
             w.text(print(o),fieldName);
         }
 
+        @Override
         public final void writeLeafElement(XMLSerializer w, Name tagName, T o, String fieldName) throws IOException, SAXException, XMLStreamException, AccessorException {
             w.leafElement(tagName,print(o),fieldName);
         }
@@ -201,7 +212,7 @@
 
         STRING = new StringImplImpl(String.class, qnames);
 
-        ArrayList<RuntimeBuiltinLeafInfoImpl<?>> secondaryList = new ArrayList<RuntimeBuiltinLeafInfoImpl<?>>();
+        ArrayList<RuntimeBuiltinLeafInfoImpl<?>> secondaryList = new ArrayList<>();
             /*
                 There are cases where more than one Java classes map to the same XML type.
                 But when we see the same XML type in an incoming document, we only pick
@@ -221,37 +232,45 @@
             */
         secondaryList.add(
             new StringImpl<Character>(Character.class, createXS("unsignedShort")) {
+                @Override
                 public Character parse(CharSequence text) {
                     // TODO.checkSpec("default mapping for char is not defined yet");
                     return (char) DatatypeConverterImpl._parseInt(text);
                 }
+                @Override
                 public String print(Character v) {
                     return Integer.toString(v);
                 }
             });
         secondaryList.add(
             new StringImpl<Calendar>(Calendar.class, DatatypeConstants.DATETIME) {
+                @Override
                 public Calendar parse(CharSequence text) {
                     return DatatypeConverterImpl._parseDateTime(text.toString());
                 }
+                @Override
                 public String print(Calendar v) {
                     return DatatypeConverterImpl._printDateTime(v);
                 }
             });
         secondaryList.add(
             new StringImpl<GregorianCalendar>(GregorianCalendar.class, DatatypeConstants.DATETIME) {
+                @Override
                 public GregorianCalendar parse(CharSequence text) {
                     return DatatypeConverterImpl._parseDateTime(text.toString());
                 }
+                @Override
                 public String print(GregorianCalendar v) {
                     return DatatypeConverterImpl._printDateTime(v);
                 }
             });
         secondaryList.add(
             new StringImpl<Date>(Date.class, DatatypeConstants.DATETIME) {
+                @Override
                 public Date parse(CharSequence text) {
                     return DatatypeConverterImpl._parseDateTime(text.toString()).getTime();
                 }
+                @Override
                 public String print(Date v) {
                     XMLSerializer xs = XMLSerializer.getInstance();
                     QName type = xs.getSchemaType();
@@ -267,15 +286,18 @@
             });
         secondaryList.add(
             new StringImpl<File>(File.class, createXS("string")) {
+                @Override
                 public File parse(CharSequence text) {
                     return new File(WhiteSpaceProcessor.trim(text).toString());
                 }
+                @Override
                 public String print(File v) {
                     return v.getPath();
                 }
             });
         secondaryList.add(
             new StringImpl<URL>(URL.class, createXS("anyURI")) {
+                @Override
                 public URL parse(CharSequence text) throws SAXException {
                     TODO.checkSpec("JSR222 Issue #42");
                     try {
@@ -285,6 +307,7 @@
                         return null;
                     }
                 }
+                @Override
                 public String print(URL v) {
                     return v.toExternalForm();
                 }
@@ -292,6 +315,7 @@
         if (MAP_ANYURI_TO_URI_VALUE == null) {
             secondaryList.add(
                 new StringImpl<URI>(URI.class, createXS("string")) {
+                    @Override
                     public URI parse(CharSequence text) throws SAXException {
                         try {
                             return new URI(text.toString());
@@ -301,6 +325,7 @@
                         }
                     }
 
+                    @Override
                     public String print(URI v) {
                         return v.toString();
                     }
@@ -308,6 +333,7 @@
         }
         secondaryList.add(
             new StringImpl<Class>(Class.class, createXS("string")) {
+                @Override
                 public Class parse(CharSequence text) throws SAXException {
                     TODO.checkSpec("JSR222 Issue #42");
                     try {
@@ -325,6 +351,7 @@
                         return null;
                     }
                 }
+                @Override
                 public String print(Class v) {
                     return v.getName();
                 }
@@ -336,6 +363,7 @@
             */
         secondaryList.add(
             new PcdataImpl<Image>(Image.class, createXS("base64Binary")) {
+                @Override
                 public Image parse(CharSequence text) throws SAXException  {
                     try {
                         InputStream is;
@@ -382,6 +410,7 @@
                     }
                 }
 
+                @Override
                 public Base64Data print(Image v) {
                     ByteArrayOutputStreamEx imageData = new ByteArrayOutputStreamEx();
                     XMLSerializer xs = XMLSerializer.getInstance();
@@ -425,6 +454,7 @@
             });
         secondaryList.add(
             new PcdataImpl<DataHandler>(DataHandler.class, createXS("base64Binary")) {
+                @Override
                 public DataHandler parse(CharSequence text) {
                     if(text instanceof Base64Data)
                         return ((Base64Data)text).getDataHandler();
@@ -433,6 +463,7 @@
                             UnmarshallingContext.getInstance().getXMIMEContentType()));
                 }
 
+                @Override
                 public Base64Data print(DataHandler v) {
                     Base64Data bd = new Base64Data();
                     bd.set(v);
@@ -441,6 +472,7 @@
             });
         secondaryList.add(
             new PcdataImpl<Source>(Source.class, createXS("base64Binary")) {
+                @Override
                 public Source parse(CharSequence text) throws SAXException  {
                     try {
                         if(text instanceof Base64Data)
@@ -454,6 +486,7 @@
                     }
                 }
 
+                @Override
                 public Base64Data print(Source v) {
                     XMLSerializer xs = XMLSerializer.getInstance();
                     Base64Data bd = new Base64Data();
@@ -522,6 +555,7 @@
                     DatatypeConstants.GYEARMONTH,
                     DatatypeConstants.GMONTHDAY
                 ) {
+                @Override
                 public String print(XMLGregorianCalendar cal) {
                     XMLSerializer xs = XMLSerializer.getInstance();
 
@@ -543,6 +577,7 @@
                     return cal.toXMLFormat();
                 }
 
+                @Override
                 public XMLGregorianCalendar parse(CharSequence lexical) throws SAXException {
                     try {
                         return DatatypeConverterImpl.getDatatypeFactory()
@@ -630,7 +665,7 @@
                 }
             });
 
-        ArrayList<RuntimeBuiltinLeafInfoImpl<?>> primaryList = new ArrayList<RuntimeBuiltinLeafInfoImpl<?>>();
+        ArrayList<RuntimeBuiltinLeafInfoImpl<?>> primaryList = new ArrayList<>();
 
         /*
             primary bindings
@@ -639,10 +674,12 @@
         primaryList.add(new StringImpl<Boolean>(Boolean.class,
                 createXS("boolean")
                 ) {
+                @Override
                 public Boolean parse(CharSequence text) {
                     return DatatypeConverterImpl._parseBoolean(text);
                 }
 
+                @Override
                 public String print(Boolean v) {
                     return v.toString();
                 }
@@ -651,10 +688,12 @@
                 createXS("base64Binary"),
                 createXS("hexBinary")
                 ) {
+                @Override
                 public byte[] parse(CharSequence text) {
                     return decodeBase64(text);
                 }
 
+                @Override
                 public Base64Data print(byte[] v) {
                     XMLSerializer w = XMLSerializer.getInstance();
                     Base64Data bd = new Base64Data();
@@ -666,10 +705,12 @@
         primaryList.add(new StringImpl<Byte>(Byte.class,
                 createXS("byte")
                 ) {
+                @Override
                 public Byte parse(CharSequence text) {
                     return DatatypeConverterImpl._parseByte(text);
                 }
 
+                @Override
                 public String print(Byte v) {
                     return DatatypeConverterImpl._printByte(v);
                 }
@@ -678,10 +719,12 @@
                 createXS("short"),
                 createXS("unsignedByte")
                 ) {
+                @Override
                 public Short parse(CharSequence text) {
                     return DatatypeConverterImpl._parseShort(text);
                 }
 
+                @Override
                 public String print(Short v) {
                     return DatatypeConverterImpl._printShort(v);
                 }
@@ -690,10 +733,12 @@
                 createXS("int"),
                 createXS("unsignedShort")
                 ) {
+                @Override
                 public Integer parse(CharSequence text) {
                     return DatatypeConverterImpl._parseInt(text);
                 }
 
+                @Override
                 public String print(Integer v) {
                     return DatatypeConverterImpl._printInt(v);
                 }
@@ -703,10 +748,12 @@
                 createXS("long"),
                 createXS("unsignedInt")
                 ) {
+                @Override
                 public Long parse(CharSequence text) {
                     return DatatypeConverterImpl._parseLong(text);
                 }
 
+                @Override
                 public String print(Long v) {
                     return DatatypeConverterImpl._printLong(v);
                 }
@@ -715,10 +762,12 @@
             new StringImpl<Float>(Float.class,
                 createXS("float")
                 ) {
+                @Override
                 public Float parse(CharSequence text) {
                     return DatatypeConverterImpl._parseFloat(text.toString());
                 }
 
+                @Override
                 public String print(Float v) {
                     return DatatypeConverterImpl._printFloat(v);
                 }
@@ -727,10 +776,12 @@
             new StringImpl<Double>(Double.class,
                 createXS("double")
                 ) {
+                @Override
                 public Double parse(CharSequence text) {
                     return DatatypeConverterImpl._parseDouble(text);
                 }
 
+                @Override
                 public String print(Double v) {
                     return DatatypeConverterImpl._printDouble(v);
                 }
@@ -744,10 +795,12 @@
                 createXS("nonNegativeInteger"),
                 createXS("unsignedLong")
                 ) {
+                @Override
                 public BigInteger parse(CharSequence text) {
                     return DatatypeConverterImpl._parseInteger(text);
                 }
 
+                @Override
                 public String print(BigInteger v) {
                     return DatatypeConverterImpl._printInteger(v);
                 }
@@ -756,10 +809,12 @@
                 new StringImpl<BigDecimal>(BigDecimal.class,
                         createXS("decimal")
                 ) {
+                    @Override
                     public BigDecimal parse(CharSequence text) {
                         return DatatypeConverterImpl._parseDecimal(text.toString());
                     }
 
+                    @Override
                     public String print(BigDecimal v) {
                         return DatatypeConverterImpl._printDecimal(v);
                     }
@@ -769,6 +824,7 @@
             new StringImpl<QName>(QName.class,
                 createXS("QName")
                 ) {
+                @Override
                 public QName parse(CharSequence text) throws SAXException {
                     try {
                         return DatatypeConverterImpl._parseQName(text.toString(),UnmarshallingContext.getInstance());
@@ -778,6 +834,7 @@
                     }
                 }
 
+                @Override
                 public String print(QName v) {
                     return DatatypeConverterImpl._printQName(v,XMLSerializer.getInstance().getNamespaceContext());
                 }
@@ -795,6 +852,7 @@
         if (MAP_ANYURI_TO_URI_VALUE != null) {
             primaryList.add(
                 new StringImpl<URI>(URI.class, createXS("anyURI")) {
+                    @Override
                     public URI parse(CharSequence text) throws SAXException {
                         try {
                             return new URI(text.toString());
@@ -804,6 +862,7 @@
                         }
                     }
 
+                    @Override
                     public String print(URI v) {
                         return v.toString();
                     }
@@ -811,10 +870,12 @@
         }
         primaryList.add(
                 new StringImpl<Duration>(Duration.class, createXS("duration")) {
+                    @Override
                     public String print(Duration duration) {
                         return duration.toString();
                     }
 
+                    @Override
                     public Duration parse(CharSequence lexical) {
                         TODO.checkSpec("JSR222 Issue #42");
                         return DatatypeConverterImpl.getDatatypeFactory().newDuration(lexical.toString());
@@ -826,16 +887,18 @@
                 // 'void' binding isn't defined by the spec, but when the JAX-RPC processes user-defined
                 // methods like "int actionFoo()", they need this pseudo-void property.
 
+                @Override
                 public String print(Void value) {
                     return "";
                 }
 
+                @Override
                 public Void parse(CharSequence lexical) {
                     return null;
                 }
             });
 
-        List<RuntimeBuiltinLeafInfoImpl<?>> l = new ArrayList<RuntimeBuiltinLeafInfoImpl<?>>(secondaryList.size()+primaryList.size()+1);
+        List<RuntimeBuiltinLeafInfoImpl<?>> l = new ArrayList<>(secondaryList.size()+primaryList.size()+1);
         l.addAll(secondaryList);
 
         // UUID may fail to load if we are running on JDK 1.4. Handle gracefully
@@ -979,6 +1042,7 @@
             super(UUID.class, RuntimeBuiltinLeafInfoImpl.createXS("string"));
         }
 
+        @Override
         public UUID parse(CharSequence text) throws SAXException {
             TODO.checkSpec("JSR222 Issue #42");
             try {
@@ -989,6 +1053,7 @@
             }
         }
 
+        @Override
         public String print(UUID v) {
             return v.toString();
         }
@@ -1000,10 +1065,12 @@
             super(type, typeNames);
         }
 
+        @Override
         public String parse(CharSequence text) {
             return text.toString();
         }
 
+        @Override
         public String print(String s) {
             return s;
         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeClassInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeClassInfoImpl.java
index 64356bd..f224cea 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeClassInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeClassInfoImpl.java
@@ -115,10 +115,12 @@
     }
 
 
+    @Override
     public Method getFactoryMethod(){
         return super.getFactoryMethod();
     }
     
+    @Override
     public final RuntimeClassInfoImpl getBaseClass() {
         return (RuntimeClassInfoImpl)super.getBaseClass();
     }
@@ -160,6 +162,7 @@
     }
 
 
+    @Override
     public void link() {
         getTransducer();    // populate the transducer
         super.link();
@@ -167,6 +170,7 @@
 
     private Accessor<?,Map<QName,String>> attributeWildcardAccessor;
 
+    @Override
     public <B> Accessor<B,Map<QName,String>> getAttributeWildcard() {
         for( RuntimeClassInfoImpl c=this; c!=null; c=c.getBaseClass() ) {
             if(c.attributeWildcard!=null) {
@@ -181,6 +185,7 @@
     private boolean computedTransducer = false;
     private Transducer xducer = null;
 
+    @Override
     public Transducer getTransducer() {
         if(!computedTransducer) {
             computedTransducer = true;
@@ -261,9 +266,10 @@
         if(reader().hasFieldAnnotation(XmlLocation.class,f))
             // TODO: check for XmlLocation signature
             // TODO: check a collision with the super class
-            xmlLocationAccessor = new Accessor.FieldReflection<Object,Locator>(f);
+            xmlLocationAccessor = new Accessor.FieldReflection<>(f);
     }
 
+    @Override
     public Accessor<?,Locator> getLocatorField() {
         return xmlLocationAccessor;
     }
@@ -281,26 +287,32 @@
             this.acc = acc;
         }
 
+        @Override
         public String getName() {
             return core.getName();
         }
 
+        @Override
         public <A extends Annotation> A readAnnotation(Class<A> annotationType) {
             return core.readAnnotation(annotationType);
         }
 
+        @Override
         public boolean hasAnnotation(Class<? extends Annotation> annotationType) {
             return core.hasAnnotation(annotationType);
         }
 
+        @Override
         public Type getRawType() {
             return core.getRawType();
         }
 
+        @Override
         public Location getLocation() {
             return core.getLocation();
         }
 
+        @Override
         public Locatable getUpstream() {
             return core.getUpstream();
         }
@@ -326,10 +338,12 @@
             this.ownerClass = ownerClass;
         }
 
+        @Override
         public boolean useNamespace() {
             return xacc.useNamespace();
         }
 
+        @Override
         public void declareNamespace(BeanT bean, XMLSerializer w) throws AccessorException {
             try {
                 xacc.declareNamespace(bean,w);
@@ -338,7 +352,8 @@
             }
         }
 
-        public @NotNull CharSequence print(BeanT o) throws AccessorException {
+        public @NotNull@Override
+ CharSequence print(BeanT o) throws AccessorException {
             try {
                 CharSequence value = xacc.print(o);
                 if(value==null)
@@ -349,6 +364,7 @@
             }
         }
 
+        @Override
         public BeanT parse(CharSequence lexical) throws AccessorException, SAXException {
             UnmarshallingContext ctxt = UnmarshallingContext.getInstance();
             BeanT inst;
@@ -363,18 +379,21 @@
             return inst;
         }
 
+        @Override
         public void writeText(XMLSerializer w, BeanT o, String fieldName) throws IOException, SAXException, XMLStreamException, AccessorException {
             if(!xacc.hasValue(o))
                 throw new AccessorException(Messages.THERE_MUST_BE_VALUE_IN_XMLVALUE.format(o));
             xacc.writeText(w,o,fieldName);
         }
 
+        @Override
         public void writeLeafElement(XMLSerializer w, Name tagName, BeanT o, String fieldName) throws IOException, SAXException, XMLStreamException, AccessorException {
             if(!xacc.hasValue(o))
                 throw new AccessorException(Messages.THERE_MUST_BE_VALUE_IN_XMLVALUE.format(o));
             xacc.writeLeafElement(w,tagName,o,fieldName);
         }
 
+        @Override
         public QName getTypeName(BeanT instance) {
             return null;
         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeElementInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeElementInfoImpl.java
index f035393..f27789c 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeElementInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeElementInfoImpl.java
@@ -48,6 +48,7 @@
     }
 
     class RuntimePropertyImpl extends PropertyImpl implements RuntimeElementPropertyInfo, RuntimeTypeRef {
+        @Override
         public Accessor getAccessor() {
             if(adapterType==null)
                 return Accessor.JAXB_ELEMENT_VALUE;
@@ -56,35 +57,43 @@
                         (Class)getAdapter().defaultType,(Class)adapterType);
         }
 
+        @Override
         public Type getRawType() {
             return Collection.class;
         }
 
+        @Override
         public Type getIndividualType() {
              return getContentType().getType();
         }
 
 
+        @Override
         public boolean elementOnlyContent() {
             return false;   // this method doesn't make sense here
         }
 
+        @Override
         public List<? extends RuntimeTypeRef> getTypes() {
             return Collections.singletonList(this);
         }
 
+        @Override
         public List<? extends RuntimeNonElement> ref() {
             return (List<? extends RuntimeNonElement>)super.ref();
         }
 
+        @Override
         public RuntimeNonElement getTarget() {
             return (RuntimeNonElement)super.getTarget();
         }
 
+        @Override
         public RuntimePropertyInfo getSource() {
             return this;
         }
 
+        @Override
         public Transducer getTransducer() {
             return RuntimeModelBuilder.createTransducer(this);
         }
@@ -95,19 +104,23 @@
      */
     private final Class<? extends XmlAdapter> adapterType;
 
+    @Override
     public RuntimeElementPropertyInfo getProperty() {
         return (RuntimeElementPropertyInfo)super.getProperty();
     }
 
+    @Override
     public Class<? extends JAXBElement> getType() {
         //noinspection unchecked
         return (Class<? extends JAXBElement>) Utils.REFLECTION_NAVIGATOR.erasure(super.getType());
     }
 
+    @Override
     public RuntimeClassInfo getScope() {
         return (RuntimeClassInfo)super.getScope();
     }
 
+    @Override
     public RuntimeNonElement getContentType() {
         return (RuntimeNonElement)super.getContentType();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeElementPropertyInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeElementPropertyInfoImpl.java
index 838ed3f..c195163 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeElementPropertyInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeElementPropertyInfoImpl.java
@@ -38,14 +38,17 @@
         this.acc = rawAcc;
     }
 
+    @Override
     public Accessor getAccessor() {
         return acc;
     }
 
+    @Override
     public boolean elementOnlyContent() {
         return true;
     }
 
+    @Override
     public List<? extends RuntimeTypeInfo> ref() {
         return (List<? extends RuntimeTypeInfo>)super.ref();
     }
@@ -55,6 +58,7 @@
         return new RuntimeTypeRefImpl(this,name,type,isNillable,defaultValue);
     }
 
+    @Override
     public List<RuntimeTypeRefImpl> getTypes() {
         return (List<RuntimeTypeRefImpl>)super.getTypes();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeEnumLeafInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeEnumLeafInfoImpl.java
index 4b28547..6877a91 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeEnumLeafInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeEnumLeafInfoImpl.java
@@ -37,6 +37,7 @@
 final class RuntimeEnumLeafInfoImpl<T extends Enum<T>,B> extends EnumLeafInfoImpl<Type,Class,Field,Method>
     implements RuntimeEnumLeafInfo, Transducer<T> {
 
+    @Override
     public Transducer<T> getTransducer() {
         return this;
     }
@@ -47,12 +48,12 @@
      */
     private final Transducer<B> baseXducer;
 
-    private final Map<B,T> parseMap = new HashMap<B,T>();
+    private final Map<B,T> parseMap = new HashMap<>();
     private final Map<T,B> printMap;
 
     RuntimeEnumLeafInfoImpl(RuntimeModelBuilder builder, Locatable upstream, Class<T> enumType) {
         super(builder,upstream,enumType,enumType);
-        this.printMap = new EnumMap<T,B>(enumType);
+        this.printMap = new EnumMap<>(enumType);
 
         baseXducer = ((RuntimeNonElement)baseType).getTransducer();
     }
@@ -80,7 +81,7 @@
         } catch (Exception e) {
             builder.reportError(new IllegalAnnotationException(
                 Messages.INVALID_XML_ENUM_VALUE.format(literal,baseType.getType().toString()), e,
-                    new FieldLocatable<Field>(this,constant,nav()) ));
+                    new FieldLocatable<>(this,constant,nav()) ));
         }
 
         parseMap.put(b,t);
@@ -89,6 +90,7 @@
         return new RuntimeEnumConstantImpl(this, name, literal, last);
     }
 
+    @Override
     public QName[] getTypeNames() {
         return new QName[]{getTypeName()};
     }
@@ -98,18 +100,22 @@
         return clazz;
     }
 
+    @Override
     public boolean useNamespace() {
         return baseXducer.useNamespace();
     }
 
+    @Override
     public void declareNamespace(T t, XMLSerializer w) throws AccessorException {
         baseXducer.declareNamespace(printMap.get(t),w);
     }
 
+    @Override
     public CharSequence print(T t) throws AccessorException {
         return baseXducer.print(printMap.get(t));
     }
 
+    @Override
     public T parse(CharSequence lexical) throws AccessorException, SAXException {
         // TODO: error handling
 
@@ -122,14 +128,17 @@
         return parseMap.get(b);
     }
 
+    @Override
     public void writeText(XMLSerializer w, T t, String fieldName) throws IOException, SAXException, XMLStreamException, AccessorException {
         baseXducer.writeText(w,printMap.get(t),fieldName);
     }
 
+    @Override
     public void writeLeafElement(XMLSerializer w, Name tagName, T o, String fieldName) throws IOException, SAXException, XMLStreamException, AccessorException {
         baseXducer.writeLeafElement(w,tagName,printMap.get(o),fieldName);
     }
 
+    @Override
     public QName getTypeName(T instance) {
         return null;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeMapPropertyInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeMapPropertyInfoImpl.java
index 2280260..0e3230d 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeMapPropertyInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeMapPropertyInfoImpl.java
@@ -31,22 +31,27 @@
         this.acc = ((RuntimeClassInfoImpl.RuntimePropertySeed)seed).getAccessor();
     }
 
+    @Override
     public Accessor getAccessor() {
         return acc;
     }
 
+    @Override
     public boolean elementOnlyContent() {
         return true;
     }
 
+    @Override
     public RuntimeNonElement getKeyType() {
         return (RuntimeNonElement)super.getKeyType();
     }
 
+    @Override
     public RuntimeNonElement getValueType() {
         return (RuntimeNonElement)super.getValueType();
     }
 
+    @Override
     public List<? extends RuntimeTypeInfo> ref() {
         return (List<? extends RuntimeTypeInfo>)super.ref();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeReferencePropertyInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeReferencePropertyInfoImpl.java
index 43025df..0387c35 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeReferencePropertyInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeReferencePropertyInfoImpl.java
@@ -37,18 +37,22 @@
         this.acc = rawAcc;
     }
 
+    @Override
     public Set<? extends RuntimeElement> getElements() {
         return (Set<? extends RuntimeElement>)super.getElements();
     }
 
+    @Override
     public Set<? extends RuntimeElement> ref() {
         return (Set<? extends RuntimeElement>)super.ref();
     }
 
+    @Override
     public Accessor getAccessor() {
         return acc;
     }
 
+    @Override
     public boolean elementOnlyContent() {
         return !isMixed();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeTypeInfoSetImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeTypeInfoSetImpl.java
index b5263cb..fbea60f 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeTypeInfoSetImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeTypeInfoSetImpl.java
@@ -36,42 +36,52 @@
         return RuntimeAnyTypeImpl.theInstance;
     }
 
+    @Override
     public RuntimeNonElement getTypeInfo( Type type ) {
         return (RuntimeNonElement)super.getTypeInfo(type);
     }
 
+    @Override
     public RuntimeNonElement getAnyTypeInfo() {
         return (RuntimeNonElement)super.getAnyTypeInfo();
     }
 
+    @Override
     public RuntimeNonElement getClassInfo(Class clazz) {
         return (RuntimeNonElement)super.getClassInfo(clazz);
     }
 
+    @Override
     public Map<Class,RuntimeClassInfoImpl> beans() {
         return (Map<Class,RuntimeClassInfoImpl>)super.beans();
     }
 
+    @Override
     public Map<Type,RuntimeBuiltinLeafInfoImpl<?>> builtins() {
         return (Map<Type,RuntimeBuiltinLeafInfoImpl<?>>)super.builtins();
     }
 
+    @Override
     public Map<Class,RuntimeEnumLeafInfoImpl<?,?>> enums() {
         return (Map<Class,RuntimeEnumLeafInfoImpl<?,?>>)super.enums();
     }
 
+    @Override
     public Map<Class,RuntimeArrayInfoImpl> arrays() {
         return (Map<Class,RuntimeArrayInfoImpl>)super.arrays();
     }
 
+    @Override
     public RuntimeElementInfoImpl getElementInfo(Class scope,QName name) {
         return (RuntimeElementInfoImpl)super.getElementInfo(scope,name);
     }
 
+    @Override
     public Map<QName,RuntimeElementInfoImpl> getElementMappings(Class scope) {
         return (Map<QName,RuntimeElementInfoImpl>)super.getElementMappings(scope);
     }
 
+    @Override
     public Iterable<RuntimeElementInfoImpl> getAllElements() {
         return (Iterable<RuntimeElementInfoImpl>)super.getAllElements();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeTypeRefImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeTypeRefImpl.java
index 26c75d1..bdbf384 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeTypeRefImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeTypeRefImpl.java
@@ -27,14 +27,17 @@
         super(elementPropertyInfo, elementName, type, isNillable, defaultValue);
     }
 
+    @Override
     public RuntimeNonElement getTarget() {
         return (RuntimeNonElement)super.getTarget();
     }
 
+    @Override
     public Transducer getTransducer() {
         return RuntimeModelBuilder.createTransducer(this);
     }
 
+    @Override
     public RuntimePropertyInfo getSource() {
         return (RuntimePropertyInfo)owner;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeValuePropertyInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeValuePropertyInfoImpl.java
index d7972c9..d27e3e8 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeValuePropertyInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/RuntimeValuePropertyInfoImpl.java
@@ -29,22 +29,27 @@
         super(classInfo, seed);
     }
 
+    @Override
     public boolean elementOnlyContent() {
         return false;
     }
 
+    @Override
     public RuntimePropertyInfo getSource() {
         return (RuntimePropertyInfo)super.getSource();
     }
 
+    @Override
     public RuntimeNonElement getTarget() {
         return (RuntimeNonElement)super.getTarget();
     }
 
+    @Override
     public List<? extends RuntimeNonElement> ref() {
         return (List<? extends RuntimeNonElement>)super.ref();
     }
 
+    @Override
     public void link() {
         getTransducer();
         super.link();
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/SingleTypePropertyInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/SingleTypePropertyInfoImpl.java
index 7290556..d4627d2 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/SingleTypePropertyInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/SingleTypePropertyInfoImpl.java
@@ -53,6 +53,7 @@
             this.acc = null;
     }
 
+    @Override
     public List<? extends NonElement<T,C>> ref() {
         return Collections.singletonList(getTarget());
     }
@@ -69,6 +70,7 @@
         return this;
     }
 
+    @Override
     public void link() {
         super.link();
 
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/TypeInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/TypeInfoImpl.java
index 056d0ca..c99e360 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/TypeInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/TypeInfoImpl.java
@@ -57,6 +57,7 @@
         this.upstream = upstream;
     }
 
+    @Override
     public Locatable getUpstream() {
         return upstream;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/TypeInfoSetImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/TypeInfoSetImpl.java
index 9899e69..2edae3b 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/TypeInfoSetImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/TypeInfoSetImpl.java
@@ -49,15 +49,15 @@
      * All the leaves.
      */
     private final Map<T,BuiltinLeafInfo<T,C>> builtins =
-            new LinkedHashMap<T,BuiltinLeafInfo<T,C>>();
+            new LinkedHashMap<>();
 
     /** All {@link EnumLeafInfoImpl}s. */
     private final Map<C,EnumLeafInfoImpl<T,C,F,M>> enums =
-            new LinkedHashMap<C,EnumLeafInfoImpl<T,C,F,M>>();
+            new LinkedHashMap<>();
 
     /** All {@link ArrayInfoImpl}s. */
     private final Map<T,ArrayInfoImpl<T,C,F,M>> arrays =
-            new LinkedHashMap<T,ArrayInfoImpl<T,C,F,M>>();
+            new LinkedHashMap<>();
 
     /**
      * All the user-defined classes.
@@ -79,12 +79,13 @@
      * The element mapping.
      */
     private final Map<C,Map<QName,ElementInfoImpl<T,C,F,M>>> elementMappings =
-        new LinkedHashMap<C,Map<QName,ElementInfoImpl<T,C,F,M>>>();
+        new LinkedHashMap<>();
     
     private final Iterable<? extends ElementInfoImpl<T,C,F,M>> allElements =
         new Iterable<ElementInfoImpl<T,C,F,M>>() {
+            @Override
             public Iterator<ElementInfoImpl<T,C,F,M>> iterator() {
-                return new FlattenIterator<ElementInfoImpl<T,C,F,M>>(elementMappings.values());
+                return new FlattenIterator<>(elementMappings.values());
             }
         };
 
@@ -113,18 +114,19 @@
         this.anyType = createAnyType();
 
         // register primitive types.
-        for (Map.Entry<Class, Class> e : RuntimeUtil.primitiveToBox.entrySet()) {
+        for (Map.Entry<Class<?>, Class<?>> e : RuntimeUtil.primitiveToBox.entrySet()) {
             this.builtins.put( nav.getPrimitive(e.getKey()), leaves.get(nav.ref(e.getValue())) );
         }
 
         // make sure at lease we got a map for global ones.
-        elementMappings.put(null,new LinkedHashMap<QName,ElementInfoImpl<T,C,F,M>>());
+        elementMappings.put(null,new LinkedHashMap<>());
     }
 
     protected NonElement<T,C> createAnyType() {
-        return new AnyTypeImpl<T,C>(nav);
+        return new AnyTypeImpl<>(nav);
     }
 
+    @Override
     public Navigator<T,C,F,M> getNavigator() {
         return nav;
     }
@@ -154,6 +156,7 @@
      *      null if the specified type cannot be bound by JAXB, or
      *      not known to this set.
      */
+    @Override
     public NonElement<T,C> getTypeInfo( T type ) {
         type = nav.erasure(type);   // replace type variables by their bounds
 
@@ -169,6 +172,7 @@
         return getClassInfo(d);
     }
 
+    @Override
     public NonElement<T,C> getAnyTypeInfo() {
         return anyType;
     }
@@ -176,6 +180,7 @@
     /**
      * This method is used to add a root reference to a model.
      */
+    @Override
     public NonElement<T,C> getTypeInfo(Ref<T,C> ref) {
         // TODO: handle XmlValueList
         assert !ref.valueList;
@@ -189,18 +194,22 @@
     /**
      * Returns all the {@link ClassInfo}s known to this set.
      */
+    @Override
     public Map<C,? extends ClassInfoImpl<T,C,F,M>> beans() {
         return beansView;
     }
 
+    @Override
     public Map<T, ? extends BuiltinLeafInfo<T,C>> builtins() {
         return builtins;
     }
 
+    @Override
     public Map<C, ? extends EnumLeafInfoImpl<T,C,F,M>> enums() {
         return enums;
     }
 
+    @Override
     public Map<? extends T, ? extends ArrayInfoImpl<T,C,F,M>> arrays() {
         return arrays;
     }
@@ -216,6 +225,7 @@
      *      null if the specified type is not bound by JAXB or otherwise
      *      unknown to this set.
      */
+    @Override
     public NonElement<T,C> getClassInfo( C type ) {
         LeafInfo<T,C> l = builtins.get(nav.use(type));
         if(l!=null)     return l;
@@ -229,6 +239,7 @@
         return beans.get(type);
     }
 
+    @Override
     public ElementInfoImpl<T,C,F,M> getElementInfo( C scope, QName name ) {
         while(scope!=null) {
             Map<QName,ElementInfoImpl<T,C,F,M>> m = elementMappings.get(scope);
@@ -252,7 +263,7 @@
 
         Map<QName,ElementInfoImpl<T,C,F,M>> m = elementMappings.get(scope);
         if(m==null)
-            elementMappings.put(scope,m=new LinkedHashMap<QName,ElementInfoImpl<T,C,F,M>>());
+            elementMappings.put(scope,m=new LinkedHashMap<>());
 
         ElementInfoImpl<T,C,F,M> existing = m.put(ei.getElementName(),ei);
 
@@ -265,17 +276,20 @@
         }
     }
 
+    @Override
     public Map<QName,? extends ElementInfoImpl<T,C,F,M>> getElementMappings( C scope ) {
         return elementMappings.get(scope);
     }
 
+    @Override
     public Iterable<? extends ElementInfoImpl<T,C,F,M>> getAllElements() {
         return allElements;
     }
 
+    @Override
     public Map<String,String> getXmlNs(String namespaceUri) {
         if(xmlNsCache==null) {
-            xmlNsCache = new HashMap<String,Map<String,String>>();
+            xmlNsCache = new HashMap<>();
 
             for (ClassInfoImpl<T, C, F, M> ci : beans().values()) {
                 XmlSchema xs = reader.getPackageAnnotation( XmlSchema.class, ci.getClazz(), null );
@@ -285,7 +299,7 @@
                 String uri = xs.namespace();
                 Map<String,String> m = xmlNsCache.get(uri);
                 if(m==null)
-                    xmlNsCache.put(uri,m=new HashMap<String, String>());
+                    xmlNsCache.put(uri,m=new HashMap<>());
 
                 for( XmlNs xns : xs.xmlns() ) {
                     m.put(xns.prefix(),xns.namespaceURI());
@@ -298,8 +312,9 @@
         else            return Collections.emptyMap();
     }
 
+    @Override
     public Map<String,String> getSchemaLocations() {
-        Map<String, String> r = new HashMap<String,String>();
+        Map<String, String> r = new HashMap<>();
         for (ClassInfoImpl<T, C, F, M> ci : beans().values()) {
             XmlSchema xs = reader.getPackageAnnotation( XmlSchema.class, ci.getClazz(), null );
             if(xs==null)
@@ -314,6 +329,7 @@
         return r;
     }
 
+    @Override
     public final XmlNsForm getElementFormDefault(String nsUri) {
         for (ClassInfoImpl<T, C, F, M> ci : beans().values()) {
             XmlSchema xs = reader.getPackageAnnotation( XmlSchema.class, ci.getClazz(), null );
@@ -330,6 +346,7 @@
         return XmlNsForm.UNSET;
     }
 
+    @Override
     public final XmlNsForm getAttributeFormDefault(String nsUri) {
         for (ClassInfoImpl<T,C,F,M> ci : beans().values()) {
             XmlSchema xs = reader.getPackageAnnotation( XmlSchema.class, ci.getClazz(), null );
@@ -353,6 +370,7 @@
      *
      * TODO: not sure if this actually works. We don't really know what are T,C.
      */
+    @Override
     public void dump( Result out ) throws JAXBException {
         JAXBContext context = JAXBContext.newInstance(this.getClass());
         Marshaller m = context.createMarshaller();
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/TypeRefImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/TypeRefImpl.java
index 086ccd3..1749cb1 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/TypeRefImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/TypeRefImpl.java
@@ -38,20 +38,24 @@
         assert type!=null;
     }
 
+    @Override
     public NonElement<TypeT,ClassDeclT> getTarget() {
         if(ref==null)
             calcRef();
         return ref;
     }
 
+    @Override
     public QName getTagName() {
         return elementName;
     }
 
+    @Override
     public boolean isNillable() {
         return isNillable;
     }
 
+    @Override
     public String getDefaultValue() {
         return defaultValue;
     }
@@ -67,6 +71,7 @@
         assert ref!=null;
     }
 
+    @Override
     public PropertyInfo<TypeT,ClassDeclT> getSource() {
         return owner;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ValuePropertyInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ValuePropertyInfoImpl.java
index b97386b..52b6012 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ValuePropertyInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/impl/ValuePropertyInfoImpl.java
@@ -27,6 +27,7 @@
         super(parent,seed);
     }
 
+    @Override
     public PropertyKind kind() {
         return PropertyKind.VALUE;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeArrayInfo.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeArrayInfo.java
index a34ee53..147bd1e 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeArrayInfo.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeArrayInfo.java
@@ -25,10 +25,12 @@
      * The same as {@link TypeInfo#getType()} but at the runtime, an array
      * is guaranteed to have a {@link Class} representation, not just any {@link Type}.
      */
+    @Override
     Class getType();
 
     /**
      * {@inheritDoc}
      */
+    @Override
     RuntimeNonElement getItemType();
 }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeAttributePropertyInfo.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeAttributePropertyInfo.java
index 865e3c5..dfbcf93 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeAttributePropertyInfo.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeAttributePropertyInfo.java
@@ -19,5 +19,6 @@
  */
 public interface RuntimeAttributePropertyInfo extends AttributePropertyInfo<Type,Class>, RuntimePropertyInfo, RuntimeNonElementRef {
     // refinement
+    @Override
     RuntimeNonElement getTarget();
 }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeClassInfo.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeClassInfo.java
index 241b4a0..abc178f 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeClassInfo.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeClassInfo.java
@@ -26,10 +26,13 @@
  * @author Kohsuke Kawaguchi (kk@kohsuke.org)
  */
 public interface RuntimeClassInfo extends ClassInfo<Type,Class>, RuntimeNonElement {
+    @Override
     RuntimeClassInfo getBaseClass();
 
     // refined to return RuntimePropertyInfo
+    @Override
     List<? extends RuntimePropertyInfo> getProperties();
+    @Override
     RuntimePropertyInfo getProperty(String name);
 
     Method getFactoryMethod();
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeElementInfo.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeElementInfo.java
index 23cd411..55735cb 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeElementInfo.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeElementInfo.java
@@ -19,17 +19,21 @@
  * @author Kohsuke Kawaguchi
  */
 public interface RuntimeElementInfo extends ElementInfo<Type,Class>, RuntimeElement {
+    @Override
     RuntimeClassInfo getScope();
 
+    @Override
     RuntimeElementPropertyInfo getProperty();
 
     /**
      * Returns the custom {@link JAXBElement} class tailored this element.
      */
+    @Override
     Class<? extends JAXBElement> getType();
 
     /**
      * {@inheritDoc}
      */
+    @Override
     RuntimeNonElement getContentType();
 }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeElementPropertyInfo.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeElementPropertyInfo.java
index 5b15602..3c9b30f 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeElementPropertyInfo.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeElementPropertyInfo.java
@@ -21,7 +21,9 @@
  */
 public interface RuntimeElementPropertyInfo extends ElementPropertyInfo<Type,Class>, RuntimePropertyInfo {
     /** {@inheritDoc} */
+    @Override
     Collection<? extends RuntimeTypeInfo> ref();
 
+    @Override
     List<? extends RuntimeTypeRef> getTypes();
 }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeLeafInfo.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeLeafInfo.java
index 7e1ca3f..d1d9b25 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeLeafInfo.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeLeafInfo.java
@@ -26,6 +26,7 @@
      * @return
      *      always non-null.
      */
+    @Override
     <V> Transducer<V> getTransducer();
 
     /**
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeMapPropertyInfo.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeMapPropertyInfo.java
index 8fb7dab..89c399e 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeMapPropertyInfo.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeMapPropertyInfo.java
@@ -18,6 +18,8 @@
  * @author Kohsuke Kawaguchi
  */
 public interface RuntimeMapPropertyInfo extends RuntimePropertyInfo, MapPropertyInfo<Type,Class> {
+    @Override
     RuntimeNonElement getKeyType();
+    @Override
     RuntimeNonElement getValueType();
 }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeNonElementRef.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeNonElementRef.java
index 0b90bc7..095ec8a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeNonElementRef.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeNonElementRef.java
@@ -28,7 +28,9 @@
  */
 public interface RuntimeNonElementRef extends NonElementRef<Type,Class> {
     // refinements
+    @Override
     RuntimeNonElement getTarget();
+    @Override
     RuntimePropertyInfo getSource();
 
     /**
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimePropertyInfo.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimePropertyInfo.java
index 094f035..8b0731a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimePropertyInfo.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimePropertyInfo.java
@@ -25,6 +25,7 @@
 public interface RuntimePropertyInfo extends PropertyInfo<Type,Class> {
 
     /** {@inheritDoc} */
+    @Override
     Collection<? extends RuntimeTypeInfo> ref();
 
 
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeReferencePropertyInfo.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeReferencePropertyInfo.java
index 416df38..f0dfa4d 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeReferencePropertyInfo.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeReferencePropertyInfo.java
@@ -19,5 +19,6 @@
  * @author Kohsuke Kawaguchi
  */
 public interface RuntimeReferencePropertyInfo extends ReferencePropertyInfo<Type,Class>, RuntimePropertyInfo {
+    @Override
     Set<? extends RuntimeElement> getElements();
 }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeTypeInfoSet.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeTypeInfoSet.java
index 87a5704..33c3f43 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeTypeInfoSet.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeTypeInfoSet.java
@@ -24,14 +24,24 @@
  * @author Kohsuke Kawaguchi
  */
 public interface RuntimeTypeInfoSet extends TypeInfoSet<Type,Class,Field,Method>{
+    @Override
     Map<Class,? extends RuntimeArrayInfo> arrays();
+    @Override
     Map<Class,? extends RuntimeClassInfo> beans();
+    @Override
     Map<Type,? extends RuntimeBuiltinLeafInfo> builtins();
+    @Override
     Map<Class,? extends RuntimeEnumLeafInfo> enums();
+    @Override
     RuntimeNonElement getTypeInfo( Type type );
+    @Override
     RuntimeNonElement getAnyTypeInfo();
+    @Override
     RuntimeNonElement getClassInfo( Class type );
+    @Override
     RuntimeElementInfo getElementInfo( Class scope, QName name );
+    @Override
     Map<QName,? extends RuntimeElementInfo> getElementMappings( Class scope );
+    @Override
     Iterable<? extends RuntimeElementInfo> getAllElements();
 }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeTypeRef.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeTypeRef.java
index c7d2ac0..715e4f1 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeTypeRef.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeTypeRef.java
@@ -18,6 +18,8 @@
  * @author Kohsuke Kawaguchi
  */
 public interface RuntimeTypeRef extends TypeRef<Type,Class>, RuntimeNonElementRef {
+    @Override
     RuntimeNonElement getTarget();
+    @Override
     RuntimePropertyInfo getSource();
 }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeValuePropertyInfo.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeValuePropertyInfo.java
index 1e9f9ab..60fd64c 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeValuePropertyInfo.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/model/runtime/RuntimeValuePropertyInfo.java
@@ -18,5 +18,6 @@
  * @author Kohsuke Kawaguchi
  */
 public interface RuntimeValuePropertyInfo extends ValuePropertyInfo<Type,Class>,RuntimePropertyInfo,RuntimeNonElementRef {
+    @Override
     RuntimeNonElement getTarget();
 }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/AnyTypeBeanInfo.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/AnyTypeBeanInfo.java
index 74b3e8e..bbda9b5 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/AnyTypeBeanInfo.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/AnyTypeBeanInfo.java
@@ -39,19 +39,23 @@
         super(grammar, anyTypeInfo, Object.class, new QName(WellKnownNamespace.XML_SCHEMA,"anyType"), false, true, false);
     }
 
+    @Override
     public String getElementNamespaceURI(Object element) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public String getElementLocalName(Object element) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public Object createInstance(UnmarshallingContext context) {
         throw new UnsupportedOperationException();
         // return JAXBContextImpl.createDom().createElementNS("","noname");
     }
 
+    @Override
     public boolean reset(Object element, UnmarshallingContext context) {
         return false;
 //        NodeList nl = element.getChildNodes();
@@ -63,10 +67,12 @@
 //        return true;
     }
 
+    @Override
     public String getId(Object element, XMLSerializer target) {
         return null;
     }
 
+    @Override
     public void serializeBody(Object element, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         NodeList childNodes = ((Element)element).getChildNodes();
         int len = childNodes.getLength();
@@ -84,6 +90,7 @@
         }
     }
 
+    @Override
     public void serializeAttributes(Object element, XMLSerializer target) throws SAXException {
         NamedNodeMap al = ((Element)element).getAttributes();
         int len = al.getLength();
@@ -104,6 +111,7 @@
         }
     }
 
+    @Override
     public void serializeRoot(Object element, XMLSerializer target) throws SAXException {
         target.reportError(
                 new ValidationEventImpl(
@@ -113,6 +121,7 @@
                         null));
     }
 
+    @Override
     public void serializeURIs(Object element, XMLSerializer target) {
         NamedNodeMap al = ((Element)element).getAttributes();
         int len = al.getLength();
@@ -138,10 +147,12 @@
         }
     }
 
+    @Override
     public Transducer<Object> getTransducer() {
         return null;
     }
 
+    @Override
     public Loader getLoader(JAXBContextImpl context, boolean typeSubstitutionCapable) {
         if(typeSubstitutionCapable)
             return substLoader;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ArrayBeanInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ArrayBeanInfoImpl.java
index 15851fc..d368e37 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ArrayBeanInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ArrayBeanInfoImpl.java
@@ -85,6 +85,7 @@
             return Collections.singleton(new QName("","item"));
         }
 
+        @Override
         public void receive(UnmarshallingContext.State state, Object o) {
             ((List)state.getTarget()).add(o);
         }
@@ -98,6 +99,7 @@
         return array;
     }
 
+    @Override
     public void serializeBody(Object array, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         int len = Array.getLength(array);
         for( int i=0; i<len; i++ )  {
@@ -113,31 +115,38 @@
         }
     }
 
+    @Override
     public final String getElementNamespaceURI(Object array) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public final String getElementLocalName(Object array) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public final Object createInstance(UnmarshallingContext context) {
         // we first create a List and then later convert it to an array
         return new ArrayList();
     }
 
+    @Override
     public final boolean reset(Object array, UnmarshallingContext context) {
         return false;
     }
 
+    @Override
     public final String getId(Object array, XMLSerializer target) {
         return null;
     }
 
+    @Override
     public final void serializeAttributes(Object array, XMLSerializer target) {
         // noop
     }
 
+    @Override
     public final void serializeRoot(Object array, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         target.reportError(
                 new ValidationEventImpl(
@@ -147,14 +156,17 @@
                         null));
     }
 
+    @Override
     public final void serializeURIs(Object array, XMLSerializer target) {
         // noop
     }
 
+    @Override
     public final Transducer getTransducer() {
         return null;
     }
 
+    @Override
     public final Loader getLoader(JAXBContextImpl context, boolean typeSubstitutionCapable) {
         if(loader==null)
             loader = new ArrayLoader(context);
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/AssociationMap.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/AssociationMap.java
index 73f9646..66715ad 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/AssociationMap.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/AssociationMap.java
@@ -47,9 +47,9 @@
         }
     }
     
-    private final Map<XmlNode,Entry<XmlNode>> byElement = new IdentityHashMap<XmlNode,Entry<XmlNode>>();
-    private final Map<Object,Entry<XmlNode>> byPeer = new IdentityHashMap<Object,Entry<XmlNode>>();
-    private final Set<XmlNode> usedNodes = new HashSet<XmlNode>();
+    private final Map<XmlNode,Entry<XmlNode>> byElement = new IdentityHashMap<>();
+    private final Map<Object,Entry<XmlNode>> byPeer = new IdentityHashMap<>();
+    private final Set<XmlNode> usedNodes = new HashSet<>();
 
     /** Records the new {@code element <->inner} peer association. */
     public void addInner( XmlNode element, Object inner ) {
@@ -59,7 +59,7 @@
                 byPeer.remove(e.inner);
             e.inner = inner;
         } else {
-        	e = new Entry<XmlNode>();
+        	e = new Entry<>();
             e.element = element;
             e.inner = inner;
         }
@@ -83,7 +83,7 @@
                 byPeer.remove(e.outer);
             e.outer = outer;
         } else {
-            e = new Entry<XmlNode>();
+            e = new Entry<>();
             e.element = element;
             e.outer = outer;
         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BinderImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BinderImpl.java
index cde6269..6c24dda 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BinderImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BinderImpl.java
@@ -58,7 +58,7 @@
      * A {@link Binder} always works with the same
      * association map.
      */
-    private final AssociationMap<XmlNode> assoc = new AssociationMap<XmlNode>();
+    private final AssociationMap<XmlNode> assoc = new AssociationMap<>();
     
     BinderImpl(JAXBContextImpl _context,InfosetScanner<XmlNode> scanner) {
         this.context = _context;
@@ -77,6 +77,7 @@
         return marshaller;
     }
 
+    @Override
     public void marshal(Object jaxbObject, XmlNode xmlNode) throws JAXBException {
         if ((xmlNode == null) || (jaxbObject == null))
             throw new IllegalArgumentException();
@@ -89,24 +90,29 @@
     }
 
 
+    @Override
     public Object updateJAXB(XmlNode xmlNode) throws JAXBException {
         return associativeUnmarshal(xmlNode,true,null);
     }
 
+    @Override
     public Object unmarshal( XmlNode xmlNode ) throws JAXBException {
         return associativeUnmarshal(xmlNode,false,null);
     }
 
+    @Override
     public <T> JAXBElement<T> unmarshal(XmlNode xmlNode, Class<T> expectedType) throws JAXBException {
         if(expectedType==null)  throw new IllegalArgumentException();
         return (JAXBElement)associativeUnmarshal(xmlNode,true,expectedType);
     }
 
+    @Override
     public void setSchema(Schema schema) {
         getMarshaller().setSchema(schema);
         getUnmarshaller().setSchema(schema);
     }
 
+    @Override
     public Schema getSchema() {
         return getUnmarshaller().getSchema();
     }
@@ -131,6 +137,7 @@
         return handler.getContext().getResult();
     }
 
+    @Override
     public XmlNode getXMLNode(Object jaxbObject) {
         if(jaxbObject==null)
             throw new IllegalArgumentException();
@@ -139,6 +146,7 @@
         return e.element();
     }
 
+    @Override
     public Object getJAXBNode(XmlNode xmlNode) {
         if(xmlNode==null)
             throw new IllegalArgumentException();
@@ -148,10 +156,12 @@
         return e.inner();
     }
 
+    @Override
     public XmlNode updateXML(Object jaxbObject) throws JAXBException {
         return updateXML(jaxbObject,getXMLNode(jaxbObject));
     }
 
+    @Override
     public XmlNode updateXML(Object jaxbObject, XmlNode xmlNode) throws JAXBException {
         if(jaxbObject==null || xmlNode==null)   throw new IllegalArgumentException();
 
@@ -178,15 +188,18 @@
         return (XmlNode)newNode;
     }
 
+    @Override
     public void setEventHandler(ValidationEventHandler handler) throws JAXBException {
         getUnmarshaller().setEventHandler(handler);
         getMarshaller().setEventHandler(handler);
     }
 
+    @Override
     public ValidationEventHandler getEventHandler() {
         return getUnmarshaller().getEventHandler();
     }
 
+    @Override
     public Object getProperty(String name) throws PropertyException {
         if (name == null)
             throw new IllegalArgumentException(Messages.NULL_PROPERTY_NAME.format());
@@ -217,6 +230,7 @@
         throw pe;
     }
 
+    @Override
     public void setProperty(String name, Object value) throws PropertyException {
         if (name == null)
             throw new IllegalArgumentException(Messages.NULL_PROPERTY_NAME.format());
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BridgeAdapter.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BridgeAdapter.java
index 63d45ee..e392541 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BridgeAdapter.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BridgeAdapter.java
@@ -45,22 +45,27 @@
         this.adapter = adapter;
     }
 
+    @Override
     public void marshal(Marshaller m, InMemory inMemory, XMLStreamWriter output) throws JAXBException {
         core.marshal(m,adaptM(m,inMemory),output);
     }
 
+    @Override
     public void marshal(Marshaller m, InMemory inMemory, OutputStream output, NamespaceContext nsc) throws JAXBException {
         core.marshal(m,adaptM(m,inMemory),output,nsc);
     }
 
+    @Override
     public void marshal(Marshaller m, InMemory inMemory, Node output) throws JAXBException {
         core.marshal(m,adaptM(m,inMemory),output);
     }
 
+    @Override
     public void marshal(Marshaller context, InMemory inMemory, ContentHandler contentHandler) throws JAXBException {
         core.marshal(context,adaptM(context,inMemory),contentHandler);
     }
 
+    @Override
     public void marshal(Marshaller context, InMemory inMemory, Result result) throws JAXBException {
         core.marshal(context,adaptM(context,inMemory),result);
     }
@@ -86,22 +91,27 @@
     }
 
 
-    public @NotNull InMemory unmarshal(Unmarshaller u, XMLStreamReader in) throws JAXBException {
+    public @NotNull@Override
+ InMemory unmarshal(Unmarshaller u, XMLStreamReader in) throws JAXBException {
         return adaptU(u, core.unmarshal(u,in));
     }
 
-    public @NotNull InMemory unmarshal(Unmarshaller u, Source in) throws JAXBException {
+    public @NotNull@Override
+ InMemory unmarshal(Unmarshaller u, Source in) throws JAXBException {
         return adaptU(u, core.unmarshal(u,in));
     }
 
-    public @NotNull InMemory unmarshal(Unmarshaller u, InputStream in) throws JAXBException {
+    public @NotNull@Override
+ InMemory unmarshal(Unmarshaller u, InputStream in) throws JAXBException {
         return adaptU(u, core.unmarshal(u,in));
     }
 
-    public @NotNull InMemory unmarshal(Unmarshaller u, Node n) throws JAXBException {
+    public @NotNull@Override
+ InMemory unmarshal(Unmarshaller u, Node n) throws JAXBException {
         return adaptU(u, core.unmarshal(u,n));
     }
 
+    @Override
     public TypeReference getTypeReference() {
         return core.getTypeReference();
     }
@@ -119,6 +129,7 @@
         }
     }
 
+    @Override
     void marshal(InMemory o, XMLSerializer out) throws IOException, SAXException, XMLStreamException {
         try {
             core.marshal(_adaptM( XMLSerializer.getInstance(), o ), out );
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BridgeContextImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BridgeContextImpl.java
index f385ca1..57d2aa3 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BridgeContextImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BridgeContextImpl.java
@@ -32,6 +32,7 @@
         marshaller = context.createMarshaller();
     }
 
+    @Override
     public void setErrorHandler(ValidationEventHandler handler) {
         try {
             unmarshaller.setEventHandler(handler);
@@ -42,18 +43,22 @@
         }
     }
 
+    @Override
     public void setAttachmentMarshaller(AttachmentMarshaller m) {
         marshaller.setAttachmentMarshaller(m);
     }
 
+    @Override
     public void setAttachmentUnmarshaller(AttachmentUnmarshaller u) {
         unmarshaller.setAttachmentUnmarshaller(u);
     }
 
+    @Override
     public AttachmentMarshaller getAttachmentMarshaller() {
         return marshaller.getAttachmentMarshaller();
     }
 
+    @Override
     public AttachmentUnmarshaller getAttachmentUnmarshaller() {
         return unmarshaller.getAttachmentUnmarshaller();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BridgeImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BridgeImpl.java
index 9b9489e..88edc26 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BridgeImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/BridgeImpl.java
@@ -57,11 +57,13 @@
         this.typeRef = typeRef;
     }
 
+    @Override
     public void marshal(Marshaller _m, T t, XMLStreamWriter output) throws JAXBException {
         MarshallerImpl m = (MarshallerImpl)_m;
         m.write(tagName,bi,t, XMLStreamWriterOutput.create(output,context, m.getEscapeHandler()),new StAXPostInitAction(output,m.serializer));
     }
 
+    @Override
     public void marshal(Marshaller _m, T t, OutputStream output, NamespaceContext nsContext) throws JAXBException {
         MarshallerImpl m = (MarshallerImpl)_m;
 
@@ -72,45 +74,54 @@
         m.write(tagName,bi,t,m.createWriter(output),pia);
     }
 
+    @Override
     public void marshal(Marshaller _m, T t, Node output) throws JAXBException {
         MarshallerImpl m = (MarshallerImpl)_m;
         m.write(tagName,bi,t,new SAXOutput(new SAX2DOMEx(output)),new DomPostInitAction(output,m.serializer));
     }
 
+    @Override
     public void marshal(Marshaller _m, T t, ContentHandler contentHandler) throws JAXBException {
         MarshallerImpl m = (MarshallerImpl)_m;
         m.write(tagName,bi,t,new SAXOutput(contentHandler),null);
     }
 
+    @Override
     public void marshal(Marshaller _m, T t, Result result) throws JAXBException {
         MarshallerImpl m = (MarshallerImpl)_m;
         m.write(tagName,bi,t, m.createXmlOutput(result),m.createPostInitAction(result));
     }
 
-    public @NotNull T unmarshal(Unmarshaller _u, XMLStreamReader in) throws JAXBException {
+    public @NotNull@Override
+ T unmarshal(Unmarshaller _u, XMLStreamReader in) throws JAXBException {
         UnmarshallerImpl u = (UnmarshallerImpl)_u;
         return ((JAXBElement<T>)u.unmarshal0(in,bi)).getValue();
     }
 
-    public @NotNull T unmarshal(Unmarshaller _u, Source in) throws JAXBException {
+    public @NotNull@Override
+ T unmarshal(Unmarshaller _u, Source in) throws JAXBException {
         UnmarshallerImpl u = (UnmarshallerImpl)_u;
         return ((JAXBElement<T>)u.unmarshal0(in,bi)).getValue();
     }
 
-    public @NotNull T unmarshal(Unmarshaller _u, InputStream in) throws JAXBException {
+    public @NotNull@Override
+ T unmarshal(Unmarshaller _u, InputStream in) throws JAXBException {
         UnmarshallerImpl u = (UnmarshallerImpl)_u;
         return ((JAXBElement<T>)u.unmarshal0(in,bi)).getValue();
     }
 
-    public @NotNull T unmarshal(Unmarshaller _u, Node n) throws JAXBException {
+    public @NotNull@Override
+ T unmarshal(Unmarshaller _u, Node n) throws JAXBException {
         UnmarshallerImpl u = (UnmarshallerImpl)_u;
         return ((JAXBElement<T>)u.unmarshal0(n,bi)).getValue();
     }
 
+    @Override
     public TypeReference getTypeReference() {
         return typeRef;
     }
 
+    @Override
     public void marshal(T value, XMLSerializer out) throws IOException, SAXException, XMLStreamException {
         out.startElement(tagName,null);
         if(value==null) {
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ClassBeanInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ClassBeanInfoImpl.java
index a4fc17b..33b4377 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ClassBeanInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ClassBeanInfoImpl.java
@@ -204,8 +204,8 @@
         }
 
         // create a list of attribute/URI handlers
-        List<AttributeProperty> attProps = new FinalArrayList<AttributeProperty>();
-        List<Property> uriProps = new FinalArrayList<Property>();
+        List<AttributeProperty> attProps = new FinalArrayList<>();
+        List<Property> uriProps = new FinalArrayList<>();
         for (ClassBeanInfoImpl bi = this; bi != null; bi = bi.superClazz) {
             for (int i = 0; i < bi.properties.length; i++) {
                 Property p = bi.properties[i];
@@ -237,14 +237,17 @@
         super.wrapUp();
     }
 
+    @Override
     public String getElementNamespaceURI(BeanT bean) {
         return tagName.nsUri;
     }
 
+    @Override
     public String getElementLocalName(BeanT bean) {
         return tagName.localName;
     }
 
+    @Override
     public BeanT createInstance(UnmarshallingContext context) throws IllegalAccessException, InvocationTargetException, InstantiationException, SAXException {
         
         BeanT bean = null;        
@@ -269,6 +272,7 @@
         return bean;
     }
 
+    @Override
     public boolean reset(BeanT bean, UnmarshallingContext context) throws SAXException {
         try {
             if(superClazz!=null)
@@ -282,6 +286,7 @@
         }
     }
 
+    @Override
     public String getId(BeanT bean, XMLSerializer target) throws SAXException {
         if(idProperty!=null) {
             try {
@@ -293,6 +298,7 @@
         return null;
     }
 
+    @Override
     public void serializeRoot(BeanT bean, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         if(tagName==null) {
             Class beanClass = bean.getClass();
@@ -313,6 +319,7 @@
         }
     }
 
+    @Override
     public void serializeBody(BeanT bean, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         if (superClazz != null) {
             superClazz.serializeBody(bean, target);
@@ -338,6 +345,7 @@
         }
     }
 
+    @Override
     public void serializeAttributes(BeanT bean, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         for( AttributeProperty<BeanT> p : attributeProperties )
             try {
@@ -366,6 +374,7 @@
         }
     }
 
+    @Override
     public void serializeURIs(BeanT bean, XMLSerializer target) throws SAXException {
         try {
             if (retainPropertyInfo) {
@@ -389,6 +398,7 @@
         }
     }
 
+    @Override
     public Loader getLoader(JAXBContextImpl context, boolean typeSubstitutionCapable) {
         if(loader==null) {
             // these variables have to be set before they are initialized,
@@ -410,6 +420,7 @@
             return loader;
     }
 
+    @Override
     public Transducer<BeanT> getTransducer() {
         return xducer;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/CompositeStructureBeanInfo.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/CompositeStructureBeanInfo.java
index 0d1a268..3651c0f 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/CompositeStructureBeanInfo.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/CompositeStructureBeanInfo.java
@@ -29,31 +29,38 @@
         super(context,null, CompositeStructure.class,false,true,false);
     }
 
+    @Override
     public String getElementNamespaceURI(CompositeStructure o) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public String getElementLocalName(CompositeStructure o) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public CompositeStructure createInstance(UnmarshallingContext context) throws IllegalAccessException, InvocationTargetException, InstantiationException, SAXException {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public boolean reset(CompositeStructure o, UnmarshallingContext context) throws SAXException {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public String getId(CompositeStructure o, XMLSerializer target) throws SAXException {
         return null;
     }
 
+    @Override
     public Loader getLoader(JAXBContextImpl context, boolean typeSubstitutionCapable) {
         // no unmarshaller support for this.
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public void serializeRoot(CompositeStructure o, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         target.reportError(
                 new ValidationEventImpl(
@@ -63,14 +70,17 @@
                         null));
     }
 
+    @Override
     public void serializeURIs(CompositeStructure o, XMLSerializer target) throws SAXException {
         // noop
     }
 
+    @Override
     public void serializeAttributes(CompositeStructure o, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         // noop
     }
 
+    @Override
     public void serializeBody(CompositeStructure o, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         int len = o.bridges.length;
         for( int i=0; i<len; i++ ) {
@@ -80,6 +90,7 @@
         }
     }
 
+    @Override
     public Transducer<CompositeStructure> getTransducer() {
         return null;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ContentHandlerAdaptor.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ContentHandlerAdaptor.java
index 8c5dbc9..15267bf 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ContentHandlerAdaptor.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ContentHandlerAdaptor.java
@@ -29,7 +29,7 @@
 final class ContentHandlerAdaptor extends DefaultHandler {
 
     /** Stores newly declared prefix-URI mapping. */
-    private final FinalArrayList<String> prefixMap = new FinalArrayList<String>();
+    private final FinalArrayList<String> prefixMap = new FinalArrayList<>();
 
     /** Events will be sent to this object. */
     private final XMLSerializer serializer;
@@ -41,10 +41,12 @@
         this.serializer = _serializer;
     }
     
+    @Override
     public void startDocument() {
         prefixMap.clear();
     }
 
+    @Override
     public void startPrefixMapping(String prefix, String uri) {
         prefixMap.add(prefix);
         prefixMap.add(uri);
@@ -59,6 +61,7 @@
         return false;
     }
 
+    @Override
     public void startElement(String namespaceURI, String localName, String qName, Attributes atts)
         throws SAXException {
         try {
@@ -118,6 +121,7 @@
         return prefix;
     }
 
+    @Override
     public void endElement(String namespaceURI, String localName, String qName) throws SAXException {
         try {
             flushText();
@@ -136,6 +140,7 @@
         }
     }
 
+    @Override
     public void characters(char[] ch, int start, int length) {
         text.append(ch,start,length);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/Coordinator.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/Coordinator.java
index 1dabb3b..872cc3a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/Coordinator.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/Coordinator.java
@@ -48,7 +48,7 @@
 public abstract class Coordinator implements ErrorHandler, ValidationEventHandler {
     
     private final HashMap<Class<? extends XmlAdapter>,XmlAdapter> adapters =
-            new HashMap<Class<? extends XmlAdapter>,XmlAdapter>();
+            new HashMap<>();
 
 
     public final XmlAdapter putAdapter(Class<? extends XmlAdapter> c, XmlAdapter a) {
@@ -118,14 +118,17 @@
      */
     protected abstract ValidationEventLocator getLocation();
 
+    @Override
     public final void error(SAXParseException exception) throws SAXException {
         propagateEvent( ValidationEvent.ERROR, exception );
     }
 
+    @Override
     public final void warning(SAXParseException exception) throws SAXException {
         propagateEvent( ValidationEvent.WARNING, exception );
     }
 
+    @Override
     public final void fatalError(SAXParseException exception) throws SAXException {
         propagateEvent( ValidationEvent.FATAL_ERROR, exception );
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/DomPostInitAction.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/DomPostInitAction.java
index 1bca686..4bfdee8 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/DomPostInitAction.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/DomPostInitAction.java
@@ -37,8 +37,9 @@
     }
 
     // declare the currently in-scope namespace bindings
+    @Override
     public void run() {
-        Set<String> declaredPrefixes = new HashSet<String>();
+        Set<String> declaredPrefixes = new HashSet<>();
         for( Node n=node; n!=null && n.getNodeType()==Node.ELEMENT_NODE; n=n.getParentNode() ) {
             NamedNodeMap atts = n.getAttributes();
             if(atts==null)      continue; // broken DOM. but be graceful.
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ElementBeanInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ElementBeanInfoImpl.java
index 6c8d6aa..debbff0 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ElementBeanInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ElementBeanInfoImpl.java
@@ -91,10 +91,12 @@
         constructor = null;
 
         this.property = new Property<JAXBElement>() {
+            @Override
             public void reset(JAXBElement o) {
                 throw new UnsupportedOperationException();
             }
 
+            @Override
             public void serializeBody(JAXBElement e, XMLSerializer target, Object outerPeer) throws SAXException, IOException, XMLStreamException {
                 Class scope = e.getScope();
                 if(e.isGlobalScope())   scope = null;
@@ -127,43 +129,54 @@
                 }
             }
 
+            @Override
             public void serializeURIs(JAXBElement o, XMLSerializer target) {
             }
 
+            @Override
             public boolean hasSerializeURIAction() {
                 return false;
             }
 
+            @Override
             public String getIdValue(JAXBElement o) {
                 return null;
             }
 
+            @Override
             public PropertyKind getKind() {
                 return PropertyKind.ELEMENT;
             }
 
+            @Override
             public void buildChildElementUnmarshallers(UnmarshallerChain chain, QNameMap<ChildLoader> handlers) {
             }
 
+            @Override
             public Accessor getElementPropertyAccessor(String nsUri, String localName) {
                 throw new UnsupportedOperationException();
             }
 
+            @Override
             public void wrapUp() {
             }
 
+            @Override
             public RuntimePropertyInfo getInfo() {
                 return property.getInfo();
             }
 
+            @Override
             public boolean isHiddenByOverride() {
                 return false;
             }
             
+            @Override
             public void setHiddenByOverride(boolean hidden) {
                 throw new UnsupportedOperationException("Not supported on jaxbelements.");
             }
 
+            @Override
             public String getFieldName() {
                 return null;
             }
@@ -216,6 +229,7 @@
             core.startElement(state,ea);
         }
 
+        @Override
         public Object intercept(UnmarshallingContext.State state, Object o) throws SAXException {
             JAXBElement e = (JAXBElement)state.getTarget();
             state.setTarget(state.getBackup());
@@ -237,19 +251,22 @@
         }
     }
 
+    @Override
     public String getElementNamespaceURI(JAXBElement e) {
         return e.getName().getNamespaceURI();
     }
 
+    @Override
     public String getElementLocalName(JAXBElement e) {
         return e.getName().getLocalPart();
     }
 
+    @Override
     public Loader getLoader(JAXBContextImpl context, boolean typeSubstitutionCapable) {
         if(loader==null) {
             // this has to be done lazily to avoid cyclic reference issue
             UnmarshallerChain c = new UnmarshallerChain(context);
-            QNameMap<ChildLoader> result = new QNameMap<ChildLoader>();
+            QNameMap<ChildLoader> result = new QNameMap<>();
             property.buildChildElementUnmarshallers(c,result);
             if(result.size()==1)
                 // for ElementBeanInfoImpl created from RuntimeElementInfo
@@ -261,6 +278,7 @@
         return loader;
     }
 
+    @Override
     public final JAXBElement createInstance(UnmarshallingContext context) throws IllegalAccessException, InvocationTargetException, InstantiationException {
         return createInstanceFromValue(null);
     }
@@ -272,11 +290,13 @@
             return constructor.newInstance(o);
     }
 
+    @Override
     public boolean reset(JAXBElement e, UnmarshallingContext context) {
         e.setValue(null);
         return true;
     }
 
+    @Override
     public String getId(JAXBElement e, XMLSerializer target) {
         // TODO: is this OK? Should we be returning the ID value of the type property?
         /*
@@ -290,6 +310,7 @@
             return null;
     }
 
+    @Override
     public void serializeBody(JAXBElement element, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         try {
             property.serializeBody(element,target,null);
@@ -298,18 +319,22 @@
         }
     }
 
+    @Override
     public void serializeRoot(JAXBElement e, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         serializeBody(e,target);
     }
 
+    @Override
     public void serializeAttributes(JAXBElement e, XMLSerializer target) {
         // noop
     }
 
+    @Override
     public void serializeURIs(JAXBElement e, XMLSerializer target) {
         // noop
     }
 
+    @Override
     public final Transducer<JAXBElement> getTransducer() {
         return null;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/IllegalAnnotationsException.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/IllegalAnnotationsException.java
index a51de66..b1069f8 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/IllegalAnnotationsException.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/IllegalAnnotationsException.java
@@ -37,9 +37,10 @@
     public IllegalAnnotationsException(List<IllegalAnnotationException> errors) {
         super(errors.size()+" counts of IllegalAnnotationExceptions");
         assert !errors.isEmpty() : "there must be at least one error";
-        this.errors = Collections.unmodifiableList(new ArrayList<IllegalAnnotationException>(errors));
+        this.errors = Collections.unmodifiableList(new ArrayList<>(errors));
     }
 
+    @Override
     public String toString() {
         StringBuilder sb = new StringBuilder(super.toString());
         sb.append('\n');
@@ -62,7 +63,8 @@
     }
 
     public static class Builder implements ErrorHandler {
-        private final List<IllegalAnnotationException> list = new ArrayList<IllegalAnnotationException>();
+        private final List<IllegalAnnotationException> list = new ArrayList<>();
+        @Override
         public void error(IllegalAnnotationException e) {
             list.add(e);
         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/InternalBridge.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/InternalBridge.java
index 680483c..67f1de1 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/InternalBridge.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/InternalBridge.java
@@ -25,6 +25,7 @@
         super(context);
     }
 
+    @Override
     public JAXBContextImpl getContext() {
         return context;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/JAXBContextImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/JAXBContextImpl.java
index b63cadf..4c12553 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/JAXBContextImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/JAXBContextImpl.java
@@ -79,7 +79,7 @@
     /**
      * All the bridge classes.
      */
-    private final Map<TypeReference, Bridge> bridges = new LinkedHashMap<TypeReference,Bridge>();
+    private final Map<TypeReference, Bridge> bridges = new LinkedHashMap<>();
 
     /**
      * Shared instance of {@link DocumentBuilder}.
@@ -87,13 +87,13 @@
      */
     private static DocumentBuilder db;
 
-    private final QNameMap<JaxBeanInfo> rootMap = new QNameMap<JaxBeanInfo>();
-    private final HashMap<QName,JaxBeanInfo> typeMap = new HashMap<QName,JaxBeanInfo>();
+    private final QNameMap<JaxBeanInfo> rootMap = new QNameMap<>();
+    private final HashMap<QName,JaxBeanInfo> typeMap = new HashMap<>();
 
     /**
      * Map from JAXB-bound {@link Class} to its {@link JaxBeanInfo}.
      */
-    private final Map<Class,JaxBeanInfo> beanInfoMap = new LinkedHashMap<Class,JaxBeanInfo>();
+    private final Map<Class,JaxBeanInfo> beanInfoMap = new LinkedHashMap<>();
 
     /**
      * All created {@link JaxBeanInfo}s.
@@ -104,21 +104,23 @@
      * This map is only used while the {@link JAXBContextImpl} is built and set to null
      * to avoid keeping references too long.
      */
-    protected Map<RuntimeTypeInfo,JaxBeanInfo> beanInfos = new LinkedHashMap<RuntimeTypeInfo, JaxBeanInfo>();
+    protected Map<RuntimeTypeInfo,JaxBeanInfo> beanInfos = new LinkedHashMap<>();
 
-    private final Map<Class/*scope*/,Map<QName,ElementBeanInfoImpl>> elements = new LinkedHashMap<Class, Map<QName, ElementBeanInfoImpl>>();
+    private final Map<Class/*scope*/,Map<QName,ElementBeanInfoImpl>> elements = new LinkedHashMap<>();
 
     /**
      * Pool of {@link Marshaller}s.
      */
     public final Pool<Marshaller> marshallerPool = new Pool.Impl<Marshaller>() {
-        protected @NotNull Marshaller create() {
+        protected @NotNull@Override
+ Marshaller create() {
             return createMarshaller();
         }
     };
 
     public final Pool<Unmarshaller> unmarshallerPool = new Pool.Impl<Unmarshaller>() {
-        protected @NotNull Unmarshaller create() {
+        protected @NotNull@Override
+ Unmarshaller create() {
             return createUnmarshaller();
         }
     };
@@ -251,7 +253,7 @@
         RuntimeTypeInfoSet typeSet = getTypeInfoSet();
 
         // at least prepare the empty table so that we don't have to check for null later
-        elements.put(null,new LinkedHashMap<QName, ElementBeanInfoImpl>());
+        elements.put(null,new LinkedHashMap<>());
 
         // recognize leaf bean infos
         for( RuntimeBuiltinLeafInfo leaf : RuntimeBuiltinLeafInfoImpl.builtinBeanInfos ) {
@@ -282,7 +284,7 @@
             if(xs != null) {
                 if(xs.xmlns() != null && xs.xmlns().length > 0) {
                     if(xmlNsSet == null)
-                        xmlNsSet = new HashSet<XmlNs>();
+                        xmlNsSet = new HashSet<>();
                     xmlNsSet.addAll(Arrays.asList(xs.xmlns()));
                 }
             }
@@ -304,7 +306,7 @@
             Class scopeClazz = scope==null?null:scope.getClazz();
             Map<QName,ElementBeanInfoImpl> m = elements.get(scopeClazz);
             if(m==null) {
-                m = new LinkedHashMap<QName, ElementBeanInfoImpl>();
+                m = new LinkedHashMap<>();
                 elements.put(scopeClazz,m);
             }
             m.put(n.getElementName(),bi);
@@ -322,7 +324,7 @@
             bi.link(this);
 
         // register primitives for boxed types just to make GrammarInfo fool-proof
-        for( Map.Entry<Class,Class> e : RuntimeUtil.primitiveToBox.entrySet() )
+        for( Map.Entry<Class<?>,Class<?>> e : RuntimeUtil.primitiveToBox.entrySet() )
             beanInfoMap.put( e.getKey(), beanInfoMap.get(e.getValue()) );
 
         // build bridges
@@ -337,10 +339,10 @@
             Class erasedType = (Class) nav.erasure(tr.type);
 
             if(xjta!=null) {
-                a = new Adapter<Type,Class>(xjta.value(),nav);
+                a = new Adapter<>(xjta.value(),nav);
             }
             if(tr.get(XmlAttachmentRef.class)!=null) {
-                a = new Adapter<Type,Class>(SwaRefAdapter.class,nav);
+                a = new Adapter<>(SwaRefAdapter.class,nav);
                 hasSwaRef = true;
             }
 
@@ -375,10 +377,12 @@
     /**
      * True if this JAXBContext has {@link XmlAttachmentRef}.
      */
+    @Override
     public boolean hasSwaRef() {
         return hasSwaRef;
     }
 
+    @Override
     public RuntimeTypeInfoSet getRuntimeTypeInfoSet() {
         try {
             return getTypeInfoSet();
@@ -410,7 +414,7 @@
                 // CompositeStructure doesn't have TypeInfo, so skip it.
                 // We'll add JaxBeanInfo for this later automatically
                 continue;
-            builder.getTypeInfo(new Ref<Type,Class>(c));
+            builder.getTypeInfo(new Ref<>(c));
         }
 
         this.hasSwaRef |= builder.hasSwaRef;
@@ -419,7 +423,7 @@
         errorHandler.check();
         assert r!=null : "if no error was reported, the link must be a success";
 
-        typeInfoSetCache = new WeakReference<RuntimeTypeInfoSet>(r);
+        typeInfoSetCache = new WeakReference<>(r);
 
         return r;
     }
@@ -629,7 +633,7 @@
      * For diagnostic use.
      */
     public Set<QName> getValidRootNames() {
-        Set<QName> r = new TreeSet<QName>(QNAME_COMPARATOR);
+        Set<QName> r = new TreeSet<>(QNAME_COMPARATOR);
         for (QNameMap.Entry e : rootMap.entrySet()) {
             r.add(e.createQName());
         }
@@ -708,10 +712,12 @@
         }
     }
 
+    @Override
     public MarshallerImpl createMarshaller() {
         return new MarshallerImpl(this,null);
     }
 
+    @Override
     public UnmarshallerImpl createUnmarshaller() {
         return new UnmarshallerImpl(this,null);
     }
@@ -719,10 +725,12 @@
     @Override
     public JAXBIntrospector createJAXBIntrospector() {
         return new JAXBIntrospector() {
+            @Override
             public boolean isElement(Object object) {
                 return getElementName(object)!=null;
             }
 
+            @Override
             public QName getElementName(Object jaxbElement) {
                 try {
                     return JAXBContextImpl.this.getElementName(jaxbElement);
@@ -740,7 +748,7 @@
         XmlJavaTypeAdapter xjta = tr.get(XmlJavaTypeAdapter.class);
         XmlList xl = tr.get(XmlList.class);
 
-        Ref<Type,Class> ref = new Ref<Type,Class>(annotationReader, tis.getNavigator(), tr.type, xjta, xl );
+        Ref<Type,Class> ref = new Ref<>(annotationReader, tis.getNavigator(), tr.type, xjta, xl );
 
         return tis.getTypeInfo(ref);
     }
@@ -762,18 +770,22 @@
         final SAXParseException[] w = new SAXParseException[1];
 
         createSchemaGenerator().write(outputResolver, new ErrorListener() {
+            @Override
             public void error(SAXParseException exception) {
                 e[0] = exception;
             }
 
+            @Override
             public void fatalError(SAXParseException exception) {
                 e[0] = exception;
             }
 
+            @Override
             public void warning(SAXParseException exception) {
                 w[0] = exception;
             }
 
+            @Override
             public void info(SAXParseException exception) {}
         });
 
@@ -799,12 +811,12 @@
         }
 
         XmlSchemaGenerator<Type,Class,Field,Method> xsdgen =
-                new XmlSchemaGenerator<Type,Class,Field,Method>(tis.getNavigator(),tis);
+                new XmlSchemaGenerator<>(tis.getNavigator(),tis);
 
         // JAX-RPC uses Bridge objects that collide with
         // @XmlRootElement.
         // we will avoid collision here
-        Set<QName> rootTagNames = new HashSet<QName>();
+        Set<QName> rootTagNames = new HashSet<>();
         for (RuntimeElementInfo ei : tis.getAllElements()) {
             rootTagNames.add(ei.getElementName());
         }
@@ -830,6 +842,7 @@
         return xsdgen;
     }
 
+    @Override
     public QName getTypeName(TypeReference tr) {
         try {
             NonElement<Type,Class> xt = getXmlType(getTypeInfoSet(),tr);
@@ -851,9 +864,10 @@
 
     @Override
     public Binder<Node> createBinder() {
-        return new BinderImpl<Node>(this,new DOMScanner());
+        return new BinderImpl<>(this,new DOMScanner());
     }
 
+    @Override
     public QName getElementName(Object o) throws JAXBException {
         JaxBeanInfo bi = getBeanInfo(o,true);
         if(!bi.isElement())
@@ -861,6 +875,7 @@
         return new QName(bi.getElementNamespaceURI(o),bi.getElementLocalName(o));
     }
 
+    @Override
     public QName getElementName(Class o) throws JAXBException {
         JaxBeanInfo bi = getBeanInfo(o,true);
         if(!bi.isElement())
@@ -868,14 +883,17 @@
         return new QName(bi.getElementNamespaceURI(o),bi.getElementLocalName(o));
     }
 
+    @Override
     public Bridge createBridge(TypeReference ref) {
         return bridges.get(ref);
     }
 
-    public @NotNull BridgeContext createBridgeContext() {
+    public @NotNull@Override
+ BridgeContext createBridgeContext() {
         return new BridgeContextImpl(this);
     }
 
+    @Override
     public RawAccessor getElementPropertyAccessor(Class wrapperBean, String nsUri, String localName) throws JAXBException {
         JaxBeanInfo bi = getBeanInfo(wrapperBean,true);
         if(!(bi instanceof ClassBeanInfoImpl))
@@ -891,10 +909,12 @@
                         // this isn't desirable for JAX-WS, which essentially uses this method
                         // just as a reflection library. So use the "unadapted" version to
                         // achieve the desired semantics
+                    @Override
                         public Object get(Object bean) throws AccessorException {
                             return acc.getUnadapted(bean);
                         }
 
+                    @Override
                         public void set(Object bean, Object value) throws AccessorException {
                             acc.setUnadapted(bean,value);
                         }
@@ -904,10 +924,12 @@
         throw new JAXBException(new QName(nsUri,localName)+" is not a valid property on "+wrapperBean);
     }
 
+    @Override
     public List<String> getKnownNamespaceURIs() {
         return Arrays.asList(nameList.namespaceURIs);
     }
 
+    @Override
     public String getBuildId() {
         Package pkg = getClass().getPackage();
         if(pkg==null)   return null;
@@ -919,7 +941,7 @@
         StringBuilder buf = new StringBuilder(Which.which(getClass()) + " Build-Id: " + getBuildId());
         buf.append("\nClasses known to this context:\n");
 
-        Set<String> names = new TreeSet<String>();  // sort them so that it's easy to read
+        Set<String> names = new TreeSet<>();  // sort them so that it's easy to read
 
         for (Class key : beanInfoMap.keySet())
             names.add(key.getName());
@@ -972,6 +994,7 @@
     }
 
     private static final Comparator<QName> QNAME_COMPARATOR = new Comparator<QName>() {
+        @Override
         public int compare(QName lhs, QName rhs) {
             int r = lhs.getLocalPart().compareTo(rhs.getLocalPart());
             if(r!=0)    return r;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/LeafBeanInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/LeafBeanInfoImpl.java
index 384013a..40f2a57 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/LeafBeanInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/LeafBeanInfoImpl.java
@@ -70,26 +70,32 @@
         return super.getTypeName(instance);
     }
 
+    @Override
     public final String getElementNamespaceURI(BeanT t) {
         return tagName.nsUri;
     }
 
+    @Override
     public final String getElementLocalName(BeanT t) {
         return tagName.localName;
     }
 
+    @Override
     public BeanT createInstance(UnmarshallingContext context) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public final boolean reset(BeanT bean, UnmarshallingContext context) {
         return false;
     }
 
+    @Override
     public final String getId(BeanT bean, XMLSerializer target) {
         return null;
     }
 
+    @Override
     public final void serializeBody(BeanT bean, XMLSerializer w) throws SAXException, IOException, XMLStreamException {
         // most of the times leaves are printed as leaf element/attribute property,
         // so this code is only used for example when you have multiple XmlElement on a property
@@ -101,10 +107,12 @@
         }
     }
 
+    @Override
     public final void serializeAttributes(BeanT bean, XMLSerializer target) {
         // noop
     }
 
+    @Override
     public final void serializeRoot(BeanT bean, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         if(tagName==null) {
             target.reportError(
@@ -121,6 +129,7 @@
         }
     }
 
+    @Override
     public final void serializeURIs(BeanT bean, XMLSerializer target) throws SAXException {
         // TODO: maybe we should create another LeafBeanInfoImpl class for
         // context-dependent xducers?
@@ -133,6 +142,7 @@
         }
     }
 
+    @Override
     public final Loader getLoader(JAXBContextImpl context, boolean typeSubstitutionCapable) {
         if(typeSubstitutionCapable)
             return loaderWithSubst;
@@ -140,6 +150,7 @@
             return loader;
     }
 
+    @Override
     public Transducer<BeanT> getTransducer() {
         return xducer;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/MarshallerImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/MarshallerImpl.java
index b137cb0..75c6e6b 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/MarshallerImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/MarshallerImpl.java
@@ -192,6 +192,7 @@
         return null;
     }
 
+    @Override
     public void marshal(Object target,Result result) throws JAXBException {
         write(target, createXmlOutput(result), createPostInitAction(result));
     }
@@ -564,6 +565,7 @@
     /**
      * Default error handling behavior fot {@link Marshaller}.
      */
+    @Override
     public boolean handleEvent(ValidationEvent event) {
         // draconian by default
         return false;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/Name.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/Name.java
index 7a706ca..dd23b2a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/Name.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/Name.java
@@ -60,6 +60,7 @@
         this.isAttribute = isAttribute;
     }
 
+    @Override
     public String toString() {
         return '{'+nsUri+'}'+localName;
     }
@@ -75,6 +76,7 @@
         return localName.equals(this.localName) && nsUri.equals(this.nsUri);
     }
 
+    @Override
     public int compareTo(Name that) {
         int r = this.nsUri.compareTo(that.nsUri);
         if(r!=0)    return r;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/NameBuilder.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/NameBuilder.java
index dd38b77..b06ff9a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/NameBuilder.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/NameBuilder.java
@@ -30,11 +30,11 @@
  */
 @SuppressWarnings({"StringEquality"})
 public final class NameBuilder {
-    private Map<String,Integer> uriIndexMap = new HashMap<String, Integer>();
-    private Set<String> nonDefaultableNsUris = new HashSet<String>();
-    private Map<String,Integer> localNameIndexMap = new HashMap<String, Integer>();
-    private QNameMap<Integer> elementQNameIndexMap = new QNameMap<Integer>();
-    private QNameMap<Integer> attributeQNameIndexMap = new QNameMap<Integer>();
+    private Map<String,Integer> uriIndexMap = new HashMap<>();
+    private Set<String> nonDefaultableNsUris = new HashSet<>();
+    private Map<String,Integer> localNameIndexMap = new HashMap<>();
+    private QNameMap<Integer> elementQNameIndexMap = new QNameMap<>();
+    private QNameMap<Integer> attributeQNameIndexMap = new QNameMap<>();
 
     public Name createElementName(QName name) {
         return createElementName(name.getNamespaceURI(),name.getLocalPart());
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/StAXPostInitAction.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/StAXPostInitAction.java
index 96e075d..6f94a51 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/StAXPostInitAction.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/StAXPostInitAction.java
@@ -52,6 +52,7 @@
         this.serializer = serializer;
     }
 
+    @Override
     public void run() {
         NamespaceContext ns = nsc;
         if(xsw!=null)   ns = xsw.getNamespaceContext();
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/SwaRefAdapter.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/SwaRefAdapter.java
index abe0365..e9cd5f8 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/SwaRefAdapter.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/SwaRefAdapter.java
@@ -40,12 +40,14 @@
     public SwaRefAdapter() {
     }
 
+    @Override
     public DataHandler unmarshal(String cid) {
         AttachmentUnmarshaller au = UnmarshallingContext.getInstance().parent.getAttachmentUnmarshaller();
         // TODO: error check
         return au.getAttachmentAsDataHandler(cid);
     }
 
+    @Override
     public String marshal(DataHandler data) {
         if(data==null)      return null;
         AttachmentMarshaller am = XMLSerializer.getInstance().attachmentMarshaller;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ValueListBeanInfoImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ValueListBeanInfoImpl.java
index 1d7cb0a..8229aa9 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ValueListBeanInfoImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/ValueListBeanInfoImpl.java
@@ -45,7 +45,7 @@
     private final Loader loader = new Loader(true) {
         @Override
         public void text(UnmarshallingContext.State state, CharSequence text) throws SAXException {
-            List<Object> r = new FinalArrayList<Object>();
+            List<Object> r = new FinalArrayList<>();
 
             int idx = 0;
             int len = text.length();
@@ -85,6 +85,7 @@
         return array;
     }
 
+    @Override
     public void serializeBody(Object array, XMLSerializer target) throws SAXException, IOException, XMLStreamException {
         int len = Array.getLength(array);
         for( int i=0; i<len; i++ )  {
@@ -97,6 +98,7 @@
         }
     }
 
+    @Override
     public final void serializeURIs(Object array, XMLSerializer target) throws SAXException {
         if(xducer.useNamespace()) {
             int len = Array.getLength(array);
@@ -111,30 +113,37 @@
         }
     }
 
+    @Override
     public final String getElementNamespaceURI(Object array) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public final String getElementLocalName(Object array) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public final Object createInstance(UnmarshallingContext context) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
     public final boolean reset(Object array, UnmarshallingContext context) {
         return false;
     }
 
+    @Override
     public final String getId(Object array, XMLSerializer target) {
         return null;
     }
 
+    @Override
     public final void serializeAttributes(Object array, XMLSerializer target) {
         // noop
     }
 
+    @Override
     public final void serializeRoot(Object array, XMLSerializer target) throws SAXException {
         target.reportError(
                 new ValidationEventImpl(
@@ -144,10 +153,12 @@
                         null));
     }
 
+    @Override
     public final Transducer getTransducer() {
         return null;
     }
 
+    @Override
     public final Loader getLoader(JAXBContextImpl context, boolean typeSubstitutionCapable) {
         // type substitution impossible
         return loader;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/XMLSerializer.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/XMLSerializer.java
index 6a06a67..41dd77a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/XMLSerializer.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/XMLSerializer.java
@@ -109,7 +109,7 @@
     private NamespaceContextImpl.Element nse;
 
     // Introduced based on Jersey requirements - to be able to retrieve marshalled name
-    ThreadLocal<Property> currentProperty = new ThreadLocal<Property>();
+    ThreadLocal<Property> currentProperty = new ThreadLocal<>();
     
     /**
      * Set to true if a text is already written,
@@ -126,16 +126,16 @@
     private final MarshallerImpl marshaller;
 
     /** Objects referenced through IDREF. */
-    private final Set<Object> idReferencedObjects = new HashSet<Object>();
+    private final Set<Object> idReferencedObjects = new HashSet<>();
 
     /** Objects with ID. */
-    private final Set<Object> objectsWithId = new HashSet<Object>();
+    private final Set<Object> objectsWithId = new HashSet<>();
 
     /**
      * Used to detect cycles in the object.
      * Also used to learn what's being marshalled.
      */
-    private final CollisionCheckStack<Object> cycleDetectionStack = new CollisionCheckStack<Object>();
+    private final CollisionCheckStack<Object> cycleDetectionStack = new CollisionCheckStack<>();
 
     /** Optional attributes to go with root element. */
     private String schemaLocation;
@@ -176,6 +176,7 @@
      *      {@link Base64Data} is no longer cached, so that
      *      XMLStreamWriterEx impl can retain the data, like JAX-WS does.
      */
+    @Deprecated
     public Base64Data getCachedBase64DataInstance() {
         return new Base64Data();
     }
@@ -482,6 +483,7 @@
         // allow the object to nominate its replacement
         if(obj instanceof CycleRecoverable) {
             obj = ((CycleRecoverable)obj).onCycleDetected(new CycleRecoverable.Context(){
+                @Override
                 public Marshaller getMarshaller() {
                     return marshaller;
                 }
@@ -993,6 +995,7 @@
                     e));
     }
 
+    @Override
     public boolean handleEvent(ValidationEvent event) {
         try {
             return marshaller.getEventHandler().handleEvent(event);
@@ -1024,6 +1027,7 @@
         return new ValidationEventLocatorExImpl(cycleDetectionStack.peek(),fieldName);
     }
 
+    @Override
     protected ValidationEventLocator getLocation() {
         return getCurrentLocation(null);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/C14nXmlOutput.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/C14nXmlOutput.java
index 4e8ddd3..2061b11 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/C14nXmlOutput.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/C14nXmlOutput.java
@@ -53,7 +53,7 @@
      *
      * As long as this map is empty, there's no need for sorting.
      */
-    private final FinalArrayList<DynamicAttribute> otherAttributes = new FinalArrayList<DynamicAttribute>();
+    private final FinalArrayList<DynamicAttribute> otherAttributes = new FinalArrayList<>();
 
     /**
      * True if {@link JAXBRIContext} is created with c14n support on,
@@ -86,6 +86,7 @@
                 prefix, name.localName, value );
         }
 
+        @Override
         public int compareTo(StaticAttribute that) {
             return this.name.compareTo(that.name);
         }
@@ -108,6 +109,7 @@
             else            return nsContext.getNamespaceURI(prefix);
         }
 
+        @Override
         public int compareTo(DynamicAttribute that) {
             int r = this.getURI().compareTo(that.getURI());
             if(r!=0)    return r;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/FastInfosetStreamWriterOutput.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/FastInfosetStreamWriterOutput.java
index b3ede81..d10a411 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/FastInfosetStreamWriterOutput.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/FastInfosetStreamWriterOutput.java
@@ -192,12 +192,13 @@
      */
     final static class AppData implements VocabularyApplicationData {
         final Map<JAXBContext, TablesPerJAXBContext> contexts =
-                new WeakHashMap<JAXBContext, TablesPerJAXBContext>();
+                new WeakHashMap<>();
         final Collection<TablesPerJAXBContext> collectionOfContexts = contexts.values();
 
         /**
          * Clear all the tables.
          */
+        @Override
         public void clear() {
             for(TablesPerJAXBContext c : collectionOfContexts)
                 c.requireClearTables();
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/ForkXmlOutput.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/ForkXmlOutput.java
index 2381f39..296cb3f 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/ForkXmlOutput.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/ForkXmlOutput.java
@@ -60,31 +60,37 @@
         rhs.endTag(name);
     }
 
+    @Override
     public void beginStartTag(int prefix, String localName) throws IOException, XMLStreamException {
         lhs.beginStartTag(prefix,localName);
         rhs.beginStartTag(prefix,localName);
     }
 
+    @Override
     public void attribute(int prefix, String localName, String value) throws IOException, XMLStreamException {
         lhs.attribute(prefix,localName,value);
         rhs.attribute(prefix,localName,value);
     }
 
+    @Override
     public void endStartTag() throws IOException, SAXException {
         lhs.endStartTag();
         rhs.endStartTag();
     }
 
+    @Override
     public void endTag(int prefix, String localName) throws IOException, SAXException, XMLStreamException {
         lhs.endTag(prefix,localName);
         rhs.endTag(prefix,localName);
     }
 
+    @Override
     public void text(String value, boolean needsSeparatingWhitespace) throws IOException, SAXException, XMLStreamException {
         lhs.text(value,needsSeparatingWhitespace);
         rhs.text(value,needsSeparatingWhitespace);
     }
 
+    @Override
     public void text(Pcdata value, boolean needsSeparatingWhitespace) throws IOException, SAXException, XMLStreamException {
         lhs.text(value,needsSeparatingWhitespace);
         rhs.text(value,needsSeparatingWhitespace);
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/MTOMXmlOutput.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/MTOMXmlOutput.java
index 8ad7287..d884c8b 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/MTOMXmlOutput.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/MTOMXmlOutput.java
@@ -39,52 +39,63 @@
         this.next = next;
     }
 
+    @Override
     public void startDocument(XMLSerializer serializer, boolean fragment, int[] nsUriIndex2prefixIndex, NamespaceContextImpl nsContext) throws IOException, SAXException, XMLStreamException {
         super.startDocument(serializer,fragment,nsUriIndex2prefixIndex, nsContext);
         next.startDocument(serializer, fragment, nsUriIndex2prefixIndex, nsContext);
     }
 
+    @Override
     public void endDocument(boolean fragment) throws IOException, SAXException, XMLStreamException {
         next.endDocument(fragment);
         super.endDocument(fragment);
     }
 
+    @Override
     public void beginStartTag(Name name) throws IOException, XMLStreamException {
         next.beginStartTag(name);
         this.nsUri = name.nsUri;
         this.localName = name.localName;
     }
 
+    @Override
     public void beginStartTag(int prefix, String localName) throws IOException, XMLStreamException {
         next.beginStartTag(prefix, localName);
         this.nsUri = nsContext.getNamespaceURI(prefix);
         this.localName = localName;
     }
 
+    @Override
     public void attribute( Name name, String value ) throws IOException, XMLStreamException {
         next.attribute(name, value);
     }
 
+    @Override
     public void attribute( int prefix, String localName, String value ) throws IOException, XMLStreamException {
         next.attribute(prefix, localName, value);
     }
 
+    @Override
     public void endStartTag() throws IOException, SAXException {
         next.endStartTag();
     }
 
+    @Override
     public void endTag(Name name) throws IOException, SAXException, XMLStreamException {
         next.endTag(name);
     }
 
+    @Override
     public void endTag(int prefix, String localName) throws IOException, SAXException, XMLStreamException {
         next.endTag(prefix, localName);
     }
 
+    @Override
     public void text( String value, boolean needsSeparatingWhitespace ) throws IOException, SAXException, XMLStreamException {
         next.text(value,needsSeparatingWhitespace);
     }
 
+    @Override
     public void text( Pcdata value, boolean needsSeparatingWhitespace ) throws IOException, SAXException, XMLStreamException {
         if(value instanceof Base64Data && !serializer.getInlineBinaryFlag()) {
             Base64Data b64d = (Base64Data) value;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/NamespaceContextImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/NamespaceContextImpl.java
index 744854d..6ac4796 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/NamespaceContextImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/NamespaceContextImpl.java
@@ -205,6 +205,7 @@
         }
     }
 
+    @Override
     public int force(@NotNull String uri, @NotNull String prefix) {
         // check for the existing binding
 
@@ -302,6 +303,7 @@
      * @return null
      *      if the prefix is unbound.
      */
+    @Override
     public String getNamespaceURI(String prefix) {
         for( int i=size-1; i>=0; i-- )
             if(prefixes[i].equals(prefix))
@@ -313,6 +315,7 @@
      * Returns the prefix of the specified URI,
      * or null if none exists.
      */
+    @Override
     public String getPrefix( String uri ) {
         if(collectionMode) {
             return declareNamespace(uri,null,false);
@@ -324,6 +327,7 @@
         }
     }
 
+    @Override
     public Iterator<String> getPrefixes(String uri) {
         String prefix = getPrefix(uri);
         if(prefix==null)
@@ -332,6 +336,7 @@
             return Collections.singleton(uri).iterator();
     }
 
+    @Override
     public String declareNamespace(String namespaceUri, String preferedPrefix, boolean requirePrefix) {
         int idx = declareNsUri(namespaceUri,preferedPrefix,requirePrefix);
         return getPrefix(idx);
@@ -529,6 +534,7 @@
      * it is not specified by the user.
      */
     private static final NamespacePrefixMapper defaultNamespacePrefixMapper = new NamespacePrefixMapper() {
+        @Override
         public String getPreferredPrefix(String namespaceUri, String suggestion, boolean requirePrefix) {
             if( namespaceUri.equals(WellKnownNamespace.XML_SCHEMA_INSTANCE) )
                 return "xsi";
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/Pcdata.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/Pcdata.java
index e174d72..952a5a6 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/Pcdata.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/Pcdata.java
@@ -56,5 +56,6 @@
         toString().getChars(0,length(),buf,start);
     }
 
+    @Override
     public abstract String toString();
 }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/SAXOutput.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/SAXOutput.java
index d255b1c..1fb2d16 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/SAXOutput.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/SAXOutput.java
@@ -47,12 +47,14 @@
             out.startDocument();
     }
 
+    @Override
     public void endDocument(boolean fragment) throws SAXException, IOException, XMLStreamException {
         if(!fragment)
             out.endDocument();
         super.endDocument(fragment);
     }
 
+    @Override
     public void beginStartTag(int prefix, String localName) {
         elementNsUri = nsContext.getNamespaceURI(prefix);
         elementLocalName = localName;
@@ -60,6 +62,7 @@
         atts.clear();
     }
 
+    @Override
     public void attribute(int prefix, String localName, String value) {
         String qname;
         String nsUri;
@@ -81,6 +84,7 @@
         atts.addAttribute( nsUri, localName, qname, "CDATA", value );
     }
 
+    @Override
     public void endStartTag() throws SAXException {
         NamespaceContextImpl.Element ns = nsContext.getCurrent();
         if(ns!=null) {
@@ -96,6 +100,7 @@
         out.startElement(elementNsUri,elementLocalName,elementQName,atts);
     }
 
+    @Override
     public void endTag(int prefix, String localName) throws SAXException {
         out.endElement(
             nsContext.getNamespaceURI(prefix),
@@ -126,6 +131,7 @@
         return qname;
     }
 
+    @Override
     public void text(String value, boolean needsSP) throws IOException, SAXException, XMLStreamException {
         int vlen = value.length();
         if(buf.length<=vlen) {
@@ -140,6 +146,7 @@
         out.characters(buf,0,vlen+(needsSP?1:0));
     }
 
+    @Override
     public void text(Pcdata value, boolean needsSP) throws IOException, SAXException, XMLStreamException {
         int vlen = value.length();
         if(buf.length<=vlen) {
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/StAXExStreamWriterOutput.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/StAXExStreamWriterOutput.java
index e2afa8c..0ec27d8 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/StAXExStreamWriterOutput.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/StAXExStreamWriterOutput.java
@@ -29,6 +29,7 @@
         this.out = out;
     }
 
+    @Override
     public void text(Pcdata value, boolean needsSeparatingWhitespace) throws XMLStreamException {
         if(needsSeparatingWhitespace) {
             out.writeCharacters(" ");
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/UTF8XmlOutput.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/UTF8XmlOutput.java
index 060bb0a..31e2fb3 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/UTF8XmlOutput.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/UTF8XmlOutput.java
@@ -121,6 +121,7 @@
         }
     }
 
+    @Override
     public void beginStartTag(int prefix, String localName) throws IOException {
         closeStartTag();
         int base= pushNsDecls();
@@ -227,6 +228,7 @@
         write('\"');
     }
 
+    @Override
     public void attribute(int prefix, String localName, String value) throws IOException {
         write(' ');
         if(prefix==-1) {
@@ -239,6 +241,7 @@
         write('\"');
     }
 
+    @Override
     public void endStartTag() throws IOException {
         closeStartTagPending = true;
     }
@@ -255,6 +258,7 @@
         }
     }
 
+    @Override
     public void endTag(int prefix, String localName) throws IOException {
         if(closeStartTagPending) {
             write(EMPTY_TAG);
@@ -266,6 +270,7 @@
         }
     }
 
+    @Override
     public void text(String value, boolean needSP) throws IOException {
         closeStartTag();
         if(needSP)
@@ -273,6 +278,7 @@
         doText(value,false);
     }
 
+    @Override
     public void text(Pcdata value, boolean needSP) throws IOException {
         closeStartTag();
         if(needSP)
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/XMLEventWriterOutput.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/XMLEventWriterOutput.java
index 9947903..d1be966 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/XMLEventWriterOutput.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/XMLEventWriterOutput.java
@@ -46,6 +46,7 @@
             out.add(ef.createStartDocument());
     }
 
+    @Override
     public void endDocument(boolean fragment) throws IOException, SAXException, XMLStreamException {
         if(!fragment) {
             out.add(ef.createEndDocument());
@@ -54,6 +55,7 @@
         super.endDocument(fragment);
     }
 
+    @Override
     public void beginStartTag(int prefix, String localName) throws IOException, XMLStreamException {
         out.add(
             ef.createStartElement(
@@ -72,6 +74,7 @@
         }
     }
 
+    @Override
     public void attribute(int prefix, String localName, String value) throws IOException, XMLStreamException {
         Attribute att;
         if(prefix==-1)
@@ -85,10 +88,12 @@
         out.add(att);
     }
 
+    @Override
     public void endStartTag() throws IOException, SAXException {
         // noop
     }
 
+    @Override
     public void endTag(int prefix, String localName) throws IOException, SAXException, XMLStreamException {
         out.add(
             ef.createEndElement(
@@ -97,12 +102,14 @@
                 localName));
     }
 
+    @Override
     public void text(String value, boolean needsSeparatingWhitespace) throws IOException, SAXException, XMLStreamException {
         if(needsSeparatingWhitespace)
             out.add(sp);
         out.add(ef.createCharacters(value));
     }
 
+    @Override
     public void text(Pcdata value, boolean needsSeparatingWhitespace) throws IOException, SAXException, XMLStreamException {
         text(value.toString(),needsSeparatingWhitespace);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/XMLStreamWriterOutput.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/XMLStreamWriterOutput.java
index 0e6a961..8f9fee1 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/XMLStreamWriterOutput.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/XMLStreamWriterOutput.java
@@ -93,6 +93,7 @@
         super.endDocument(fragment);
     }
 
+    @Override
     public void beginStartTag(int prefix, String localName) throws IOException, XMLStreamException {
         out.writeStartElement(
             nsContext.getPrefix(prefix),
@@ -110,6 +111,7 @@
         }
     }
 
+    @Override
     public void attribute(int prefix, String localName, String value) throws IOException, XMLStreamException {
         if(prefix==-1)
             out.writeAttribute(localName,value);
@@ -120,20 +122,24 @@
                     localName, value);
     }
 
+    @Override
     public void endStartTag() throws IOException, SAXException {
         // noop
     }
 
+    @Override
     public void endTag(int prefix, String localName) throws IOException, SAXException, XMLStreamException {
         out.writeEndElement();
     }
 
+    @Override
     public void text(String value, boolean needsSeparatingWhitespace) throws IOException, SAXException, XMLStreamException {
         if(needsSeparatingWhitespace)
             out.writeCharacters(" ");
         escapeHandler.escape(value.toCharArray(), 0, value.length(), false, writerWrapper);
     }
 
+    @Override
     public void text(Pcdata value, boolean needsSeparatingWhitespace) throws IOException, SAXException, XMLStreamException {
         if(needsSeparatingWhitespace)
             out.writeCharacters(" ");
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/XmlOutputAbstractImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/XmlOutputAbstractImpl.java
index ca3d27d..35f6c59 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/XmlOutputAbstractImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/output/XmlOutputAbstractImpl.java
@@ -39,6 +39,7 @@
      * @param fragment
      *      true if we are marshalling a fragment.
      */
+    @Override
     public void startDocument(XMLSerializer serializer, boolean fragment, int[] nsUriIndex2prefixIndex, NamespaceContextImpl nsContext) throws IOException, SAXException, XMLStreamException {
         this.nsUriIndex2prefixIndex = nsUriIndex2prefixIndex;
         this.nsContext = nsContext;
@@ -51,6 +52,7 @@
      * @param fragment
      *      false if we are writing the whole document.
      */
+    @Override
     public void endDocument(boolean fragment) throws IOException, SAXException, XMLStreamException {
         serializer = null;
     }
@@ -65,12 +67,15 @@
      * <p>
      * This method is used for writing tags that are indexed.
      */
+    @Override
     public void beginStartTag(Name name) throws IOException, XMLStreamException {
         beginStartTag( nsUriIndex2prefixIndex[name.nsUriIndex], name.localName );
     }
 
+    @Override
     public abstract void beginStartTag(int prefix, String localName) throws IOException, XMLStreamException;
 
+    @Override
     public void attribute( Name name, String value ) throws IOException, XMLStreamException {
         short idx = name.nsUriIndex;
         if(idx==-1)
@@ -83,13 +88,17 @@
      *      -1 if this attribute does not have a prefix
      *      (this handling differs from that of elements.)
      */
+    @Override
     public abstract void attribute( int prefix, String localName, String value ) throws IOException, XMLStreamException;
 
+    @Override
     public abstract void endStartTag() throws IOException, SAXException;
 
+    @Override
     public void endTag(Name name) throws IOException, SAXException, XMLStreamException {
         endTag( nsUriIndex2prefixIndex[name.nsUriIndex], name.localName);
     }
+    @Override
     public abstract void endTag(int prefix, String localName) throws IOException, SAXException, XMLStreamException;
 
 
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayERProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayERProperty.java
index 89486c6..e33e40c 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayERProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayERProperty.java
@@ -108,6 +108,7 @@
         }
     }
 
+    @Override
     public final void serializeBody(BeanT o, XMLSerializer w, Object outerPeer) throws SAXException, AccessorException, IOException, XMLStreamException {
         ListT list = acc.get(o);
 
@@ -147,10 +148,11 @@
     protected abstract void createBodyUnmarshaller(UnmarshallerChain chain, QNameMap<ChildLoader> loaders);
 
 
+    @Override
     public final void buildChildElementUnmarshallers(UnmarshallerChain chain, QNameMap<ChildLoader> loaders) {
         if(wrapperTagName!=null) {
             UnmarshallerChain c = new UnmarshallerChain(chain.context);
-            QNameMap<ChildLoader> m = new QNameMap<ChildLoader>();
+            QNameMap<ChildLoader> m = new QNameMap<>();
             createBodyUnmarshaller(c,m);
             Loader loader = new ItemsLoader(acc, lister, m);
             if(isWrapperNillable || chain.context.allNillable)
@@ -171,6 +173,7 @@
             this.offset = offset;
         }
 
+        @Override
         public void receive(UnmarshallingContext.State state, Object o) throws SAXException {
             state.getContext().getScope(offset).add(acc,lister,o);
         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayElementLeafProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayElementLeafProperty.java
index dc4cb55..1b123e8 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayElementLeafProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayElementLeafProperty.java
@@ -45,6 +45,7 @@
         assert xducer!=null;
     }
 
+    @Override
     public void serializeItem(JaxBeanInfo bi, ItemT item, XMLSerializer w) throws SAXException, AccessorException, IOException, XMLStreamException {
         xducer.declareNamespace(item,w);
         w.endNamespaceDecls(item);
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayElementNodeProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayElementNodeProperty.java
index a29f07d..924fe5d 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayElementNodeProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayElementNodeProperty.java
@@ -30,6 +30,7 @@
         super(p, prop);
     }
 
+    @Override
     public void serializeItem(JaxBeanInfo expected, ItemT item, XMLSerializer w) throws SAXException, IOException, XMLStreamException {
         if(item==null) {
             w.writeXsiNilTrue();
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayElementProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayElementProperty.java
index f03f2c4..2b1f103 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayElementProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayElementProperty.java
@@ -40,11 +40,11 @@
  */
 abstract class ArrayElementProperty<BeanT,ListT,ItemT> extends ArrayERProperty<BeanT,ListT,ItemT> {
 
-    private final Map<Class,TagAndType> typeMap  = new HashMap<Class,TagAndType>();
+    private final Map<Class,TagAndType> typeMap  = new HashMap<>();
     /**
      * Set by the constructor and reset in the {@link #wrapUp()} method.
      */
-    private Map<TypeRef<Type,Class>, JaxBeanInfo> refs = new HashMap<TypeRef<Type, Class>, JaxBeanInfo>();
+    private Map<TypeRef<Type,Class>, JaxBeanInfo> refs = new HashMap<>();
     /**
      * Set by the constructor and reset in the {@link #wrapUp()} method.
      */
@@ -88,6 +88,7 @@
         prop = null;    // avoid keeping model objects live
     }
 
+    @Override
     protected void serializeListBody(BeanT beanT, XMLSerializer w, ListT list) throws IOException, XMLStreamException, SAXException, AccessorException {
         ListIterator<ItemT> itr = lister.iterator(list, w);
 
@@ -152,6 +153,7 @@
     protected abstract void serializeItem(JaxBeanInfo expected, ItemT item, XMLSerializer w) throws SAXException, AccessorException, IOException, XMLStreamException;
 
 
+    @Override
     public void createBodyUnmarshaller(UnmarshallerChain chain, QNameMap<ChildLoader> loaders) {
 
         // all items go to the same lister,
@@ -173,6 +175,7 @@
         }
     }
 
+    @Override
     public final PropertyKind getKind() {
         return PropertyKind.ELEMENT;
     }
@@ -199,6 +202,7 @@
         }
     }
 
+    @Override
     public Accessor getElementPropertyAccessor(String nsUri, String localName) {
         if(wrapperTagName!=null) {
             if(wrapperTagName.equals(nsUri,localName))
@@ -210,7 +214,7 @@
                     // null (just like any user apps), but since we are providing a raw accessor,
                     // which just grabs the value from the field, we wrap it so that it won't return
                     // null.
-                    return new NullSafeAccessor<BeanT,ListT,Object>(acc,lister);
+                    return new NullSafeAccessor<>(acc,lister);
             }
         }
         return null;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayProperty.java
index 253c84d..b7eccc7 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayProperty.java
@@ -39,10 +39,12 @@
         assert acc!=null;
     }
 
+    @Override
     public void reset(BeanT o) throws AccessorException {
         lister.reset(o,acc);
     }
 
+    @Override
     public final String getIdValue(BeanT bean) {
         // mutli-value property can't be ID
         return null;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayReferenceNodeProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayReferenceNodeProperty.java
index 3788297..89e829f 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayReferenceNodeProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ArrayReferenceNodeProperty.java
@@ -37,7 +37,7 @@
     /**
      * Expected element names and what class to unmarshal.
      */
-    private final QNameMap<JaxBeanInfo> expectedElements = new QNameMap<JaxBeanInfo>();
+    private final QNameMap<JaxBeanInfo> expectedElements = new QNameMap<>();
 
     private final boolean isMixed;
 
@@ -63,6 +63,7 @@
         }
     }
 
+    @Override
     protected final void serializeListBody(BeanT o, XMLSerializer w, ListT list) throws IOException, XMLStreamException, SAXException {
         ListIterator<ItemT> itr = lister.iterator(list, w);
 
@@ -89,6 +90,7 @@
         }
     }
 
+    @Override
     public void createBodyUnmarshaller(UnmarshallerChain chain, QNameMap<ChildLoader> loaders) {
         final int offset = chain.allocateOffset();
 
@@ -120,6 +122,7 @@
             this.recv = recv;
         }
 
+        @Override
         public void text(UnmarshallingContext.State state, CharSequence text) throws SAXException {
             if(text.length()!=0) // length 0 text is pointless
                 recv.receive(state,text.toString());
@@ -127,6 +130,7 @@
     }
 
 
+    @Override
     public PropertyKind getKind() {
         return PropertyKind.REFERENCE;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/AttributeProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/AttributeProperty.java
index 334d2d6..c304759 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/AttributeProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/AttributeProperty.java
@@ -71,31 +71,38 @@
             w.attribute(attName,value.toString());
     }
 
+    @Override
     public void serializeURIs(BeanT o, XMLSerializer w) throws AccessorException, SAXException {
         xacc.declareNamespace(o,w);
     }
 
+    @Override
     public boolean hasSerializeURIAction() {
         return xacc.useNamespace();
     }
 
+    @Override
     public void buildChildElementUnmarshallers(UnmarshallerChain chainElem, QNameMap<ChildLoader> handlers) {
         throw new IllegalStateException();
     }
 
    
+    @Override
     public PropertyKind getKind() {
         return PropertyKind.ATTRIBUTE;
     }
 
+    @Override
     public void reset(BeanT o) throws AccessorException {
         acc.set(o,null);
     }
 
+    @Override
     public String getIdValue(BeanT bean) throws AccessorException, SAXException {
         return xacc.print(bean).toString();
     }
 
+    @Override
     public int compareTo(AttributeProperty that) {
         return this.attName.compareTo(that.attName);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ListElementProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ListElementProperty.java
index b235246..1920df7 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ListElementProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ListElementProperty.java
@@ -64,10 +64,12 @@
         xacc = new ListTransducedAccessorImpl(xducer,acc,lister);
     }
 
+    @Override
     public PropertyKind getKind() {
         return PropertyKind.ELEMENT;
     }
 
+    @Override
     public void buildChildElementUnmarshallers(UnmarshallerChain chain, QNameMap<ChildLoader> handlers) {
         Loader l = new LeafPropertyLoader(xacc);
         l = new DefaultValueLoaderDecorator(l, defaultValue);
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/PropertyImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/PropertyImpl.java
index 5245c7c..306a742 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/PropertyImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/PropertyImpl.java
@@ -38,35 +38,44 @@
         }
     }
 
+    @Override
     public RuntimePropertyInfo getInfo() {
         return propertyInfo;
     }
 
+    @Override
     public void serializeBody(BeanT o, XMLSerializer w, Object outerPeer) throws SAXException, AccessorException, IOException, XMLStreamException {
     }
 
+    @Override
     public void serializeURIs(BeanT o, XMLSerializer w) throws SAXException, AccessorException {
     }
 
+    @Override
     public boolean hasSerializeURIAction() {
         return false;
     }
 
+    @Override
     public Accessor getElementPropertyAccessor(String nsUri, String localName) {
         // default implementation. should be overrided
         return null;
     }
 
+    @Override
     public void wrapUp() {/*noop*/}
     
+    @Override
     public boolean isHiddenByOverride() {
         return hiddenByOverride;
     }
 
+    @Override
     public void setHiddenByOverride(boolean hidden) {
         this.hiddenByOverride = hidden;
     }
     
+    @Override
     public String getFieldName() {
         return fieldName;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleElementLeafProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleElementLeafProperty.java
index a193635..bc1a4b6 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleElementLeafProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleElementLeafProperty.java
@@ -60,10 +60,12 @@
         idRef = ref.getSource().id() == ID.IDREF;
     }
 
+    @Override
     public void reset(BeanT o) throws AccessorException {
         acc.set(o, null);
     }
 
+    @Override
     public String getIdValue(BeanT bean) throws AccessorException, SAXException {
         return xacc.print(bean).toString();
     }
@@ -139,6 +141,7 @@
         return acc.isAbstractable(declaredTypeClass); // and is not builtin type
     }
 
+    @Override
     public void buildChildElementUnmarshallers(UnmarshallerChain chain, QNameMap<ChildLoader> handlers) {
         Loader l = new LeafPropertyLoader(xacc);
         if (defaultValue != null)
@@ -154,6 +157,7 @@
     }
 
 
+    @Override
     public PropertyKind getKind() {
         return PropertyKind.ELEMENT;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleElementNodeProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleElementNodeProperty.java
index f0dfb7a..29900e2 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleElementNodeProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleElementNodeProperty.java
@@ -48,7 +48,7 @@
 
     private final QName[] acceptedElements;
 
-    private final Map<Class,TagAndType> typeNames = new HashMap<Class,TagAndType>();
+    private final Map<Class,TagAndType> typeNames = new HashMap<>();
 
     private RuntimeElementPropertyInfo prop;
     
@@ -88,10 +88,12 @@
         prop = null;
     }
 
+    @Override
     public void reset(BeanT bean) throws AccessorException {
         acc.set(bean,null);
     }
 
+    @Override
     public String getIdValue(BeanT beanT) {
         return null;
     }
@@ -133,6 +135,7 @@
         }
     }
 
+    @Override
     public void buildChildElementUnmarshallers(UnmarshallerChain chain, QNameMap<ChildLoader> handlers) {
         JAXBContextImpl context = chain.context;
 
@@ -149,6 +152,7 @@
         }
     }
 
+    @Override
     public PropertyKind getKind() {
         return PropertyKind.ELEMENT;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleMapNodeProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleMapNodeProperty.java
index 4b58041..a8b48af 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleMapNodeProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleMapNodeProperty.java
@@ -79,6 +79,7 @@
         HashMap.class, TreeMap.class, LinkedHashMap.class
     };
 
+    @Override
     public void reset(BeanT bean) throws AccessorException {
         acc.set(bean,null);
     }
@@ -87,14 +88,17 @@
     /**
      * A Map property can never be ID.
      */
+    @Override
     public String getIdValue(BeanT bean) {
         return null;
     }
 
+    @Override
     public PropertyKind getKind() {
         return PropertyKind.MAP;
     }
 
+    @Override
     public void buildChildElementUnmarshallers(UnmarshallerChain chain, QNameMap<ChildLoader> handlers) {
         keyLoader = keyBeanInfo.getLoader(chain.context,true);
         valueLoader = valueBeanInfo.getLoader(chain.context,true);
@@ -111,8 +115,8 @@
      */
     private final Loader itemsLoader = new Loader(false) {
 
-        private ThreadLocal<Stack<BeanT>> target = new ThreadLocal<Stack<BeanT>>();
-        private ThreadLocal<Stack<ValueT>> map = new ThreadLocal<Stack<ValueT>>();
+        private ThreadLocal<Stack<BeanT>> target = new ThreadLocal<>();
+        private ThreadLocal<Stack<ValueT>> map = new ThreadLocal<>();
 
         @Override
         public void startElement(UnmarshallingContext.State state, TagName ea) throws SAXException {
@@ -204,6 +208,7 @@
         public ReceiverImpl(int index) {
             this.index = index;
         }
+        @Override
         public void receive(UnmarshallingContext.State state, Object o) {
             ((Object[])state.getTarget())[index] = o;
         }
@@ -274,9 +279,9 @@
         private static <T> void push(ThreadLocal<Stack<T>> holder, T value) {
             Stack<T> parent = holder.get();
             if (parent == null)
-                holder.set(new Stack<T>(value));
+                holder.set(new Stack<>(value));
             else
-                holder.set(new Stack<T>(parent, value));
+                holder.set(new Stack<>(parent, value));
         }
 
         private static <T> T pop(ThreadLocal<Stack<T>> holder) {
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleReferenceNodeProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleReferenceNodeProperty.java
index 7a18147..2db3912 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleReferenceNodeProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/SingleReferenceNodeProperty.java
@@ -40,7 +40,7 @@
 
     private final Accessor<BeanT,ValueT> acc;
 
-    private final QNameMap<JaxBeanInfo> expectedElements = new QNameMap<JaxBeanInfo>();
+    private final QNameMap<JaxBeanInfo> expectedElements = new QNameMap<>();
 
     private final DomHandler domHandler;
     private final WildcardMode wcMode;
@@ -62,14 +62,17 @@
         }
     }
 
+    @Override
     public void reset(BeanT bean) throws AccessorException {
         acc.set(bean,null);
     }
 
+    @Override
     public String getIdValue(BeanT beanT) {
         return null;
     }
 
+    @Override
     public void serializeBody(BeanT o, XMLSerializer w, Object outerPeer) throws SAXException, AccessorException, IOException, XMLStreamException {
         ValueT v = acc.get(o);
         if(v!=null) {
@@ -88,6 +91,7 @@
         }
     }
 
+    @Override
     public void buildChildElementUnmarshallers(UnmarshallerChain chain, QNameMap<ChildLoader> handlers) {
         for (QNameMap.Entry<JaxBeanInfo> n : expectedElements.entrySet())
             handlers.put(n.nsUri,n.localName, new ChildLoader(n.getValue().getLoader(chain.context,true),acc));
@@ -97,6 +101,7 @@
 
     }
 
+    @Override
     public PropertyKind getKind() {
         return PropertyKind.REFERENCE;
     }
@@ -109,6 +114,7 @@
                 final ElementBeanInfoImpl ebi = (ElementBeanInfoImpl) bi;
                 // a JAXBElement. We need to handle JAXBElement for JAX-WS
                 return new Accessor<BeanT,Object>(ebi.expectedType) {
+                    @Override
                     public Object get(BeanT bean) throws AccessorException {
                         ValueT r = acc.get(bean);
                         if(r instanceof JAXBElement) {
@@ -118,6 +124,7 @@
                             return r;
                     }
 
+                    @Override
                     public void set(BeanT bean, Object value) throws AccessorException {
                         if(value!=null) {
                             try {
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ValueProperty.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ValueProperty.java
index d934e1d..ac129ec 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ValueProperty.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/property/ValueProperty.java
@@ -50,32 +50,39 @@
         acc = prop.getAccessor();   // we only use this for binder, so don't waste memory by optimizing
     }
 
+    @Override
     public final void serializeBody(BeanT o, XMLSerializer w, Object outerPeer) throws SAXException, AccessorException, IOException, XMLStreamException {
         if(xacc.hasValue(o))
             xacc.writeText(w,o,fieldName);
     }
 
+    @Override
     public void serializeURIs(BeanT o, XMLSerializer w) throws SAXException, AccessorException {
         xacc.declareNamespace(o,w);
     }
 
+    @Override
     public boolean hasSerializeURIAction() {
         return xacc.useNamespace();
     }
 
+    @Override
     public void buildChildElementUnmarshallers(UnmarshallerChain chainElem, QNameMap<ChildLoader> handlers) {
         handlers.put(TEXT_HANDLER,
                 new ChildLoader(new ValuePropertyLoader(xacc),null));
     }
 
+    @Override
     public PropertyKind getKind() {
         return PropertyKind.VALUE;
     }
 
+    @Override
     public void reset(BeanT o) throws AccessorException {
         acc.set(o,null);
     }
 
+    @Override
     public String getIdValue(BeanT bean) throws AccessorException, SAXException {
         return xacc.print(bean).toString();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/Accessor.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/Accessor.java
index 1520055..0ae6951 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/Accessor.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/Accessor.java
@@ -123,6 +123,7 @@
         set(bean, (ValueT) value);
     }
 
+    @Override
     public void receive(UnmarshallingContext.State state, Object o) throws SAXException {
         try {
             set((BeanT) state.getTarget(), (ValueT) o);
@@ -169,11 +170,11 @@
      * and performs the type adaption as necessary.
      */
     public final <T> Accessor<BeanT, T> adapt(Class<T> targetType, final Class<? extends XmlAdapter<T, ValueT>> adapter) {
-        return new AdaptedAccessor<BeanT, ValueT, T>(targetType, this, adapter);
+        return new AdaptedAccessor<>(targetType, this, adapter);
     }
 
     public final <T> Accessor<BeanT, T> adapt(Adapter<Type, Class> adapter) {
-        return new AdaptedAccessor<BeanT, ValueT, T>(
+        return new AdaptedAccessor<>(
                 (Class<T>) Utils.REFLECTION_NAVIGATOR.erasure(adapter.defaultType),
                 this,
                 adapter.adapterType);
@@ -221,6 +222,7 @@
             }
         }
 
+        @Override
         public ValueT get(BeanT bean) {
             try {
                 return (ValueT) f.get(bean);
@@ -229,6 +231,7 @@
             }
         }
 
+        @Override
         public void set(BeanT bean, ValueT value) {
             try {
                 if (value == null)
@@ -307,6 +310,7 @@
             }
         }
 
+        @Override
         public ValueT get(BeanT bean) throws AccessorException {
             try {
                 return (ValueT) getter.invoke(bean);
@@ -317,6 +321,7 @@
             }
         }
 
+        @Override
         public void set(BeanT bean, ValueT value) throws AccessorException {
             try {
                 if (value == null)
@@ -394,10 +399,12 @@
     }
 
     private static final Accessor ERROR = new Accessor<Object, Object>(Object.class) {
+        @Override
         public Object get(Object o) {
             return null;
         }
 
+        @Override
         public void set(Object o, Object o1) {
         }
     };
@@ -406,10 +413,12 @@
      * {@link Accessor} for {@link JAXBElement#getValue()}.
      */
     public static final Accessor<JAXBElement, Object> JAXB_ELEMENT_VALUE = new Accessor<JAXBElement, Object>(Object.class) {
+        @Override
         public Object get(JAXBElement jaxbElement) {
             return jaxbElement.getValue();
         }
 
+        @Override
         public void set(JAXBElement jaxbElement, Object o) {
             jaxbElement.setValue(o);
         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/AdaptedAccessor.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/AdaptedAccessor.java
index e3737ba..1df9d55 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/AdaptedAccessor.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/AdaptedAccessor.java
@@ -37,6 +37,7 @@
         return true;
     }
 
+    @Override
     public OnWireValueT get(BeanT bean) throws AccessorException {
         InMemValueT v = core.get(bean);
 
@@ -48,6 +49,7 @@
         }
     }
 
+    @Override
     public void set(BeanT bean, OnWireValueT o) throws AccessorException {
         XmlAdapter<OnWireValueT, InMemValueT> a = getAdapter();
         try {
@@ -57,10 +59,12 @@
         }
     }
 
+    @Override
     public Object getUnadapted(BeanT bean) throws AccessorException {
         return core.getUnadapted(bean);
     }
 
+    @Override
     public void setUnadapted(BeanT bean, Object value) throws AccessorException {
         core.setUnadapted(bean,value);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/AdaptedLister.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/AdaptedLister.java
index f9b7539..020bce2 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/AdaptedLister.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/AdaptedLister.java
@@ -36,14 +36,17 @@
         return Coordinator._getInstance().getAdapter(adapter);
     }
 
+    @Override
     public ListIterator<OnWireItemT> iterator(PropT prop, XMLSerializer context) {
         return new ListIteratorImpl( core.iterator(prop,context), context );
     }
 
+    @Override
     public PackT startPacking(BeanT bean, Accessor<BeanT, PropT> accessor) throws AccessorException {
         return core.startPacking(bean,accessor);
     }
 
+    @Override
     public void addToPack(PackT pack, OnWireItemT item) throws AccessorException {
         InMemItemT r;
         try {
@@ -54,10 +57,12 @@
         core.addToPack(pack,r);
     }
 
+    @Override
     public void endPacking(PackT pack, BeanT bean, Accessor<BeanT,PropT> accessor) throws AccessorException {
         core.endPacking(pack,bean,accessor);
     }
 
+    @Override
     public void reset(BeanT bean, Accessor<BeanT, PropT> accessor) throws AccessorException {
         core.reset(bean,accessor);
     }
@@ -71,10 +76,12 @@
             this.serializer = serializer;
         }
 
+        @Override
         public boolean hasNext() {
             return core.hasNext();
         }
 
+        @Override
         public OnWireItemT next() throws SAXException, JAXBException {
             InMemItemT next = core.next();
             try {
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/DefaultTransducedAccessor.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/DefaultTransducedAccessor.java
index 3a6482e..8b17198 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/DefaultTransducedAccessor.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/DefaultTransducedAccessor.java
@@ -31,12 +31,15 @@
  */
 public abstract class DefaultTransducedAccessor<T> extends TransducedAccessor<T> {
 
+    @Override
     public abstract String print(T o) throws AccessorException, SAXException;
 
+    @Override
     public void writeLeafElement(XMLSerializer w, Name tagName, T o, String fieldName) throws SAXException, AccessorException, IOException, XMLStreamException {
         w.leafElement(tagName,print(o),fieldName);
     }
 
+    @Override
     public void writeText(XMLSerializer w, T o, String fieldName) throws AccessorException, SAXException, IOException, XMLStreamException {
         w.text(print(o),fieldName);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/ListTransducedAccessorImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/ListTransducedAccessorImpl.java
index 7b26732..cdd05cf 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/ListTransducedAccessorImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/ListTransducedAccessorImpl.java
@@ -42,10 +42,12 @@
         this.acc = acc;
     }
 
+    @Override
     public boolean useNamespace() {
         return xducer.useNamespace();
     }
 
+    @Override
     public void declareNamespace(BeanT bean, XMLSerializer w) throws AccessorException, SAXException {
         ListT list = acc.get(bean);
 
@@ -68,6 +70,7 @@
     // TODO: this is inefficient, consider a redesign
     // perhaps we should directly write to XMLSerializer,
     // or maybe add more methods like writeLeafElement.
+    @Override
     public String print(BeanT o) throws AccessorException, SAXException {
         ListT list = acc.get(o);
 
@@ -119,10 +122,12 @@
         lister.endPacking(pack,bean,acc);
     }
 
+    @Override
     public void parse(BeanT bean, CharSequence lexical) throws AccessorException, SAXException {
         processValue(bean,lexical);
     }
 
+    @Override
     public boolean hasValue(BeanT bean) throws AccessorException {
         return acc.get(bean)!=null;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/Lister.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/Lister.java
index 58a0a4f..4745943 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/Lister.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/Lister.java
@@ -137,7 +137,7 @@
                 l = wr.get();
             if(l==null) {
                 l = new ArrayLister(componentType);
-                arrayListerCache.put(componentType,new WeakReference<Lister>(l));
+                arrayListerCache.put(componentType,new WeakReference<>(l));
             }
         }
         assert l!=null;
@@ -159,31 +159,38 @@
             this.itemType = itemType;
         }
 
+        @Override
         public org.glassfish.jaxb.runtime.v2.runtime.reflect.ListIterator<ItemT> iterator(final ItemT[] objects, XMLSerializer context) {
             return new org.glassfish.jaxb.runtime.v2.runtime.reflect.ListIterator<ItemT>() {
                 int idx=0;
+                @Override
                 public boolean hasNext() {
                     return idx<objects.length;
                 }
 
+                @Override
                 public ItemT next() {
                     return objects[idx++];
                 }
             };
         }
 
+        @Override
         public Pack startPacking(BeanT current, Accessor<BeanT, ItemT[]> acc) {
-            return new Pack<ItemT>(itemType);
+            return new Pack<>(itemType);
         }
 
+        @Override
         public void addToPack(Pack<ItemT> objects, ItemT o) {
             objects.add(o);
         }
 
+        @Override
         public void endPacking( Pack<ItemT> pack, BeanT bean, Accessor<BeanT,ItemT[]> acc ) throws AccessorException {
             acc.set(bean,pack.build());
         }
 
+        @Override
         public void reset(BeanT o,Accessor<BeanT,ItemT[]> acc) throws AccessorException {
             acc.set(o,(ItemT[])Array.newInstance(itemType,0));
         }
@@ -234,18 +241,22 @@
             this.implClass = implClass;
         }
 
+        @Override
         public org.glassfish.jaxb.runtime.v2.runtime.reflect.ListIterator iterator(T collection, XMLSerializer context) {
             final Iterator itr = collection.iterator();
             return new org.glassfish.jaxb.runtime.v2.runtime.reflect.ListIterator() {
+                @Override
                 public boolean hasNext() {
                     return itr.hasNext();
                 }
+                @Override
                 public Object next() {
                     return itr.next();
                 }
             };
         }
 
+        @Override
         public T startPacking(BeanT bean, Accessor<BeanT, T> acc) throws AccessorException {
             T collection = acc.get(bean);
             if(collection==null) {
@@ -257,10 +268,12 @@
             return collection;
         }
 
+        @Override
         public void addToPack(T collection, Object o) {
             collection.add(o);
         }
 
+        @Override
         public void endPacking( T collection, BeanT bean, Accessor<BeanT,T> acc ) throws AccessorException {
             // this needs to be done in the endPacking, because
             // sometimes the accessor uses an adapter, and the adapter needs to see
@@ -279,6 +292,7 @@
             }
         }
 
+        @Override
         public void reset(BeanT bean, Accessor<BeanT, T> acc) throws AccessorException {
             T collection = acc.get(bean);
             if(collection == null) {
@@ -303,23 +317,28 @@
             this.itemType = itemType;
         }
 
+        @Override
         public org.glassfish.jaxb.runtime.v2.runtime.reflect.ListIterator<String> iterator(PropT prop, XMLSerializer context) {
             final org.glassfish.jaxb.runtime.v2.runtime.reflect.ListIterator i = core.iterator(prop,context);
 
             return new IDREFSIterator(i, context);
         }
 
+        @Override
         public Pack startPacking(BeanT bean, Accessor<BeanT, PropT> acc) {
             return new Pack(bean,acc);
         }
 
+        @Override
         public void addToPack(Pack pack, String item) {
             pack.add(item);
         }
 
+        @Override
         public void endPacking(Pack pack, BeanT bean, Accessor<BeanT, PropT> acc) {
         }
 
+        @Override
         public void reset(BeanT bean, Accessor<BeanT, PropT> acc) throws AccessorException {
             core.reset(bean,acc);
         }
@@ -329,7 +348,7 @@
          */
         private class Pack implements Patcher {
             private final BeanT bean;
-            private final List<String> idrefs = new ArrayList<String>();
+            private final List<String> idrefs = new ArrayList<>();
             private final UnmarshallingContext context;
             private final Accessor<BeanT,PropT> acc;
             private final LocatorEx location;
@@ -349,6 +368,7 @@
             /**
              * Resolves IDREFS and fill in the actual array.
              */
+            @Override
             public void run() throws SAXException {
                 try {
                     Object pack = core.startPacking(bean,acc);
@@ -398,6 +418,7 @@
             this.context = context;
         }
 
+        @Override
         public boolean hasNext() {
             return i.hasNext();
         }
@@ -409,6 +430,7 @@
             return last;
         }
 
+        @Override
         public String next() throws SAXException, JAXBException {
             last = i.next();
             String id = context.grammar.getBeanInfo(last,true).getId(last,context);
@@ -428,29 +450,36 @@
     }
 
     public static final Lister ERROR = new Lister() {
+        @Override
         public org.glassfish.jaxb.runtime.v2.runtime.reflect.ListIterator iterator(Object o, XMLSerializer context) {
             return EMPTY_ITERATOR;
         }
 
+        @Override
         public Object startPacking(Object o, Accessor accessor) {
             return null;
         }
 
+        @Override
         public void addToPack(Object o, Object o1) {
         }
 
+        @Override
         public void endPacking(Object o, Object o1, Accessor accessor) {
         }
 
+        @Override
         public void reset(Object o, Accessor accessor) {
         }
     };
 
     private static final org.glassfish.jaxb.runtime.v2.runtime.reflect.ListIterator EMPTY_ITERATOR = new ListIterator() {
+        @Override
         public boolean hasNext() {
             return false;
         }
 
+        @Override
         public Object next() {
             throw new IllegalStateException();
         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/NullSafeAccessor.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/NullSafeAccessor.java
index 1c7f1ac..95fb05c 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/NullSafeAccessor.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/NullSafeAccessor.java
@@ -31,6 +31,7 @@
         this.lister = lister;
     }
 
+    @Override
     public V get(B bean) throws AccessorException {
         V v = core.get(bean);
         if(v==null) {
@@ -42,6 +43,7 @@
         return v;
     }
 
+    @Override
     public void set(B bean, V value) throws AccessorException {
         core.set(bean,value);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerBoolean.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerBoolean.java
index cb38400..f1bfceb 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerBoolean.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerBoolean.java
@@ -32,31 +32,38 @@
         Lister.primitiveArrayListers.put(Boolean.TYPE,new PrimitiveArrayListerBoolean());
     }
 
+    @Override
     public ListIterator<Boolean> iterator(final boolean[] objects, XMLSerializer context) {
         return new ListIterator<Boolean>() {
             int idx=0;
+            @Override
             public boolean hasNext() {
                 return idx<objects.length;
             }
 
+            @Override
             public Boolean next() {
                 return objects[idx++];
             }
         };
     }
 
+    @Override
     public BooleanArrayPack startPacking(BeanT current, Accessor<BeanT, boolean[]> acc) {
         return new BooleanArrayPack();
     }
 
+    @Override
     public void addToPack(BooleanArrayPack objects, Boolean o) {
         objects.add(o);
     }
 
+    @Override
     public void endPacking( BooleanArrayPack pack, BeanT bean, Accessor<BeanT,boolean[]> acc ) throws AccessorException {
         acc.set(bean,pack.build());
     }
 
+    @Override
     public void reset(BeanT o,Accessor<BeanT,boolean[]> acc) throws AccessorException {
         acc.set(o,new boolean[0]);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerByte.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerByte.java
index bbcec1b..d4a18ed 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerByte.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerByte.java
@@ -29,31 +29,38 @@
         primitiveArrayListers.put(Byte.TYPE,new PrimitiveArrayListerByte());
     }
 
+    @Override
     public ListIterator<Byte> iterator(final byte[] objects, XMLSerializer context) {
         return new ListIterator<Byte>() {
             int idx=0;
+            @Override
             public boolean hasNext() {
                 return idx<objects.length;
             }
 
+            @Override
             public Byte next() {
                 return objects[idx++];
             }
         };
     }
 
+    @Override
     public ByteArrayPack startPacking(BeanT current, Accessor<BeanT, byte[]> acc) {
         return new ByteArrayPack();
     }
 
+    @Override
     public void addToPack(ByteArrayPack objects, Byte o) {
         objects.add(o);
     }
 
+    @Override
     public void endPacking( ByteArrayPack pack, BeanT bean, Accessor<BeanT,byte[]> acc ) throws AccessorException {
         acc.set(bean,pack.build());
     }
 
+    @Override
     public void reset(BeanT o,Accessor<BeanT,byte[]> acc) throws AccessorException {
         acc.set(o,new byte[0]);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerCharacter.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerCharacter.java
index c26a726..d84ee14 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerCharacter.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerCharacter.java
@@ -32,31 +32,38 @@
         primitiveArrayListers.put(Character.TYPE,new PrimitiveArrayListerCharacter());
     }
 
+    @Override
     public ListIterator<Character> iterator(final char[] objects, XMLSerializer context) {
         return new ListIterator<Character>() {
             int idx=0;
+            @Override
             public boolean hasNext() {
                 return idx<objects.length;
             }
 
+            @Override
             public Character next() {
                 return objects[idx++];
             }
         };
     }
 
+    @Override
     public CharacterArrayPack startPacking(BeanT current, Accessor<BeanT, char[]> acc) {
         return new CharacterArrayPack();
     }
 
+    @Override
     public void addToPack(CharacterArrayPack objects, Character o) {
         objects.add(o);
     }
 
+    @Override
     public void endPacking( CharacterArrayPack pack, BeanT bean, Accessor<BeanT,char[]> acc ) throws AccessorException {
         acc.set(bean,pack.build());
     }
 
+    @Override
     public void reset(BeanT o,Accessor<BeanT,char[]> acc) throws AccessorException {
         acc.set(o,new char[0]);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerDouble.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerDouble.java
index 722e016..e76f99a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerDouble.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerDouble.java
@@ -32,31 +32,38 @@
         Lister.primitiveArrayListers.put(Double.TYPE,new PrimitiveArrayListerDouble());
     }
 
+    @Override
     public ListIterator<Double> iterator(final double[] objects, XMLSerializer context) {
         return new ListIterator<Double>() {
             int idx=0;
+            @Override
             public boolean hasNext() {
                 return idx<objects.length;
             }
 
+            @Override
             public Double next() {
                 return objects[idx++];
             }
         };
     }
 
+    @Override
     public DoubleArrayPack startPacking(BeanT current, Accessor<BeanT, double[]> acc) {
         return new DoubleArrayPack();
     }
 
+    @Override
     public void addToPack(DoubleArrayPack objects, Double o) {
         objects.add(o);
     }
 
+    @Override
     public void endPacking( DoubleArrayPack pack, BeanT bean, Accessor<BeanT,double[]> acc ) throws AccessorException {
         acc.set(bean,pack.build());
     }
 
+    @Override
     public void reset(BeanT o,Accessor<BeanT,double[]> acc) throws AccessorException {
         acc.set(o,new double[0]);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerFloat.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerFloat.java
index 930b14c..2bfc59a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerFloat.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerFloat.java
@@ -32,31 +32,38 @@
         Lister.primitiveArrayListers.put(Float.TYPE,new PrimitiveArrayListerFloat());
     }
 
+    @Override
     public ListIterator<Float> iterator(final float[] objects, XMLSerializer context) {
         return new ListIterator<Float>() {
             int idx=0;
+            @Override
             public boolean hasNext() {
                 return idx<objects.length;
             }
 
+            @Override
             public Float next() {
                 return objects[idx++];
             }
         };
     }
 
+    @Override
     public FloatArrayPack startPacking(BeanT current, Accessor<BeanT, float[]> acc) {
         return new FloatArrayPack();
     }
 
+    @Override
     public void addToPack(FloatArrayPack objects, Float o) {
         objects.add(o);
     }
 
+    @Override
     public void endPacking( FloatArrayPack pack, BeanT bean, Accessor<BeanT,float[]> acc ) throws AccessorException {
         acc.set(bean,pack.build());
     }
 
+    @Override
     public void reset(BeanT o,Accessor<BeanT,float[]> acc) throws AccessorException {
         acc.set(o,new float[0]);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerInteger.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerInteger.java
index 05c88b2..12f6ce8 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerInteger.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerInteger.java
@@ -32,31 +32,38 @@
         primitiveArrayListers.put(Integer.TYPE,new PrimitiveArrayListerInteger());
     }
 
+    @Override
     public ListIterator<Integer> iterator(final int[] objects, XMLSerializer context) {
         return new ListIterator<Integer>() {
             int idx=0;
+            @Override
             public boolean hasNext() {
                 return idx<objects.length;
             }
 
+            @Override
             public Integer next() {
                 return objects[idx++];
             }
         };
     }
 
+    @Override
     public IntegerArrayPack startPacking(BeanT current, Accessor<BeanT, int[]> acc) {
         return new IntegerArrayPack();
     }
 
+    @Override
     public void addToPack(IntegerArrayPack objects, Integer o) {
         objects.add(o);
     }
 
+    @Override
     public void endPacking( IntegerArrayPack pack, BeanT bean, Accessor<BeanT,int[]> acc ) throws AccessorException {
         acc.set(bean,pack.build());
     }
 
+    @Override
     public void reset(BeanT o,Accessor<BeanT,int[]> acc) throws AccessorException {
         acc.set(o,new int[0]);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerLong.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerLong.java
index 0f776c3..92300dc 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerLong.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerLong.java
@@ -32,31 +32,38 @@
         Lister.primitiveArrayListers.put(Long.TYPE,new PrimitiveArrayListerLong());
     }
 
+    @Override
     public ListIterator<Long> iterator(final long[] objects, XMLSerializer context) {
         return new ListIterator<Long>() {
             int idx=0;
+            @Override
             public boolean hasNext() {
                 return idx<objects.length;
             }
 
+            @Override
             public Long next() {
                 return objects[idx++];
             }
         };
     }
 
+    @Override
     public LongArrayPack startPacking(BeanT current, Accessor<BeanT, long[]> acc) {
         return new LongArrayPack();
     }
 
+    @Override
     public void addToPack(LongArrayPack objects, Long o) {
         objects.add(o);
     }
 
+    @Override
     public void endPacking( LongArrayPack pack, BeanT bean, Accessor<BeanT,long[]> acc ) throws AccessorException {
         acc.set(bean,pack.build());
     }
 
+    @Override
     public void reset(BeanT o,Accessor<BeanT,long[]> acc) throws AccessorException {
         acc.set(o,new long[0]);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerShort.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerShort.java
index a746291..e012558 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerShort.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/PrimitiveArrayListerShort.java
@@ -32,31 +32,38 @@
         Lister.primitiveArrayListers.put(Short.TYPE,new PrimitiveArrayListerShort());
     }
 
+    @Override
     public ListIterator<Short> iterator(final short[] objects, XMLSerializer context) {
         return new ListIterator<Short>() {
             int idx=0;
+            @Override
             public boolean hasNext() {
                 return idx<objects.length;
             }
 
+            @Override
             public Short next() {
                 return objects[idx++];
             }
         };
     }
 
+    @Override
     public ShortArrayPack startPacking(BeanT current, Accessor<BeanT, short[]> acc) {
         return new ShortArrayPack();
     }
 
+    @Override
     public void addToPack(ShortArrayPack objects, Short o) {
         objects.add(o);
     }
 
+    @Override
     public void endPacking( ShortArrayPack pack, BeanT bean, Accessor<BeanT,short[]> acc ) throws AccessorException {
         acc.set(bean,pack.build());
     }
 
+    @Override
     public void reset(BeanT o,Accessor<BeanT,short[]> acc) throws AccessorException {
         acc.set(o,new short[0]);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/TransducedAccessor.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/TransducedAccessor.java
index 87fad91..6b2fecb 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/TransducedAccessor.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/TransducedAccessor.java
@@ -197,16 +197,19 @@
             this.acc = acc.optimize(context);
         }
 
+        @Override
         public CharSequence print(BeanT bean) throws AccessorException {
             ValueT o = acc.get(bean);
             if(o==null)     return null;
             return xducer.print(o);
         }
 
+        @Override
         public void parse(BeanT bean, CharSequence lexical) throws AccessorException, SAXException {
             acc.set(bean,xducer.parse(lexical));
         }
 
+        @Override
         public boolean hasValue(BeanT bean) throws AccessorException {
             return acc.getUnadapted(bean)!=null;
         }
@@ -241,6 +244,7 @@
             this.targetType = acc.getValueType();
         }
 
+        @Override
         public String print(BeanT bean) throws AccessorException, SAXException {
             TargetT target = acc.get(bean);
             if(target==null)    return null;
@@ -264,6 +268,7 @@
                 acc.set(bean,t);
         }
 
+        @Override
         public void parse(final BeanT bean, CharSequence lexical) throws AccessorException, SAXException {
             final String idref = WhiteSpaceProcessor.trim(lexical).toString();
             final UnmarshallingContext context = UnmarshallingContext.getInstance();
@@ -291,6 +296,7 @@
                 // try again later
                 final LocatorEx loc = new LocatorEx.Snapshot(context.getLocator());
                 context.addPatcher(new Patcher() {
+                    @Override
                     public void run() throws SAXException {
                         try {
                             TargetT t = (TargetT)callable.call();
@@ -313,6 +319,7 @@
             }
         }
 
+        @Override
         public boolean hasValue(BeanT bean) throws AccessorException {
             return acc.get(bean)!=null;
         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Boolean.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Boolean.java
index 339597a..cf03666 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Boolean.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Boolean.java
@@ -27,10 +27,12 @@
         super(Boolean.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).f_boolean;
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).f_boolean = value==null ? Const.default_value_boolean : (Boolean)value;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Byte.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Byte.java
index d874872..19c33f8 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Byte.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Byte.java
@@ -25,10 +25,12 @@
         super(Byte.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).f_byte;
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).f_byte = value==null ? Const.default_value_byte : (Byte)value;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Character.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Character.java
index 7a97458..8ca10f2 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Character.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Character.java
@@ -27,10 +27,12 @@
         super(Character.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).f_char;
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).f_char = value==null ? Const.default_value_char : (Character)value;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Double.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Double.java
index b15bae6..44f0d92 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Double.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Double.java
@@ -27,10 +27,12 @@
         super(Double.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).f_double;
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).f_double = value==null ? Const.default_value_double : (Double)value;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Float.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Float.java
index 032aea1..4fbb14f 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Float.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Float.java
@@ -27,10 +27,12 @@
         super(Float.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).f_float;
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).f_float = value==null ? Const.default_value_float : (Float)value;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Integer.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Integer.java
index ab76375..b8c854d 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Integer.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Integer.java
@@ -27,10 +27,12 @@
         super(Integer.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).f_int;
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).f_int = value==null ? Const.default_value_int : (Integer)value;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Long.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Long.java
index 9ffe359..b01d5da 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Long.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Long.java
@@ -27,10 +27,12 @@
         super(Long.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).f_long;
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).f_long = value==null ? Const.default_value_long : (Long)value;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Ref.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Ref.java
index 2c2a826..8beac52 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Ref.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Ref.java
@@ -22,10 +22,12 @@
         super(Ref.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).f_ref;
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).f_ref = (Ref)value;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Short.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Short.java
index 423f15c..984069c 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Short.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/FieldAccessor_Short.java
@@ -27,10 +27,12 @@
         super(Short.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).f_short;
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).f_short = value==null ? Const.default_value_short : (Short)value;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/Injector.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/Injector.java
index 9746e45..781678e 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/Injector.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/Injector.java
@@ -96,7 +96,7 @@
         }
         if (injector == null) {
             try {
-                wr = new WeakReference<Injector>(injector = new Injector(cl));
+                wr = new WeakReference<>(injector = new Injector(cl));
                 iw.lock();
                 try {
                     if (!injectors.containsKey(cl)) {
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Boolean.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Boolean.java
index d0bab31..d776aca 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Boolean.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Boolean.java
@@ -27,10 +27,12 @@
         super(Boolean.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).get_boolean();
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).set_boolean( value==null ? Const.default_value_boolean : (Boolean)value );
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Byte.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Byte.java
index f498ee6..309453e 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Byte.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Byte.java
@@ -25,10 +25,12 @@
         super(Byte.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).get_byte();
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).set_byte( value==null ? Const.default_value_byte : (Byte)value );
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Character.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Character.java
index 990ee9c..37e09f1 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Character.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Character.java
@@ -27,10 +27,12 @@
         super(Character.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).get_char();
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).set_char( value==null ? Const.default_value_char : (Character)value );
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Double.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Double.java
index b93339a..2ca4e9f 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Double.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Double.java
@@ -27,10 +27,12 @@
         super(Double.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).get_double();
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).set_double( value==null ? Const.default_value_double : (Double)value );
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Float.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Float.java
index 94d335b..ad5cd88 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Float.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Float.java
@@ -27,10 +27,12 @@
         super(Float.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).get_float();
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).set_float( value==null ? Const.default_value_float : (Float)value );
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Integer.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Integer.java
index 4389716..02d4cb2 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Integer.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Integer.java
@@ -27,10 +27,12 @@
         super(Integer.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).get_int();
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).set_int( value==null ? Const.default_value_int : (Integer)value );
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Long.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Long.java
index 3273e55..b4f2cd3 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Long.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Long.java
@@ -27,10 +27,12 @@
         super(Long.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).get_long();
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).set_long( value==null ? Const.default_value_long : (Long)value );
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Ref.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Ref.java
index 849f8c0..e509618 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Ref.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Ref.java
@@ -22,10 +22,12 @@
         super(Ref.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).get_ref();
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).set_ref((Ref)value);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Short.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Short.java
index 34b3221..4c4494a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Short.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/MethodAccessor_Short.java
@@ -27,10 +27,12 @@
         super(Short.class);
     }
 
+    @Override
     public Object get(Object bean) {
         return ((Bean)bean).get_short();
     }
 
+    @Override
     public void set(Object bean, Object value) {
         ((Bean)bean).set_short( value==null ? Const.default_value_short : (Short)value );
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Boolean.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Boolean.java
index feadbaf..5f028ce 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Boolean.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Boolean.java
@@ -25,10 +25,12 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_field_Boolean extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printBoolean( ((Bean)o).f_boolean );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         Boolean b = DatatypeConverterImpl._parseBoolean(lexical);
 
@@ -36,6 +38,7 @@
             ((Bean)o).f_boolean=b;
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Byte.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Byte.java
index cf4e084..35f0efa 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Byte.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Byte.java
@@ -25,14 +25,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_field_Byte extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printByte( ((Bean)o).f_byte );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).f_byte=DatatypeConverterImpl._parseByte(lexical);
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Double.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Double.java
index 634a02f..486b420 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Double.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Double.java
@@ -27,14 +27,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_field_Double extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printDouble( ((Bean)o).f_double );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).f_double=DatatypeConverterImpl._parseDouble(lexical);
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Float.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Float.java
index f2e98b2..9b66185 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Float.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Float.java
@@ -27,14 +27,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_field_Float extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printFloat( ((Bean)o).f_float );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).f_float=DatatypeConverterImpl._parseFloat(lexical);
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Integer.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Integer.java
index 5dbdd92..e1cb409 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Integer.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Integer.java
@@ -32,14 +32,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_field_Integer extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printInt( ((Bean)o).f_int );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).f_int=DatatypeConverterImpl._parseInt(lexical);
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Long.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Long.java
index 994cf12..9b66831 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Long.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Long.java
@@ -27,14 +27,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_field_Long extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printLong( ((Bean)o).f_long );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).f_long=DatatypeConverterImpl._parseLong(lexical);
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Short.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Short.java
index c3cc098..da1d747 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Short.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_field_Short.java
@@ -27,14 +27,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_field_Short extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printShort( ((Bean)o).f_short );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).f_short=DatatypeConverterImpl._parseShort(lexical);
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Boolean.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Boolean.java
index 994284f..00418f3 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Boolean.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Boolean.java
@@ -27,14 +27,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_method_Boolean extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printBoolean( ((Bean)o).get_boolean() );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).set_boolean(DatatypeConverterImpl._parseBoolean(lexical));
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Byte.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Byte.java
index 1967171..c6088da 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Byte.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Byte.java
@@ -25,14 +25,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_method_Byte extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printByte( ((Bean)o).get_byte() );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).set_byte(DatatypeConverterImpl._parseByte(lexical));
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Double.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Double.java
index 6facad1..cd0e2b1 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Double.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Double.java
@@ -27,14 +27,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_method_Double extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printDouble( ((Bean)o).get_double() );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).set_double(DatatypeConverterImpl._parseDouble(lexical));
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Float.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Float.java
index 14b3880..4d55105 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Float.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Float.java
@@ -27,14 +27,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_method_Float extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printFloat( ((Bean)o).get_float() );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).set_float(DatatypeConverterImpl._parseFloat(lexical));
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Integer.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Integer.java
index c930844..2495615 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Integer.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Integer.java
@@ -32,14 +32,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_method_Integer extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printInt( ((Bean)o).get_int() );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).set_int(DatatypeConverterImpl._parseInt(lexical));
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Long.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Long.java
index 4b461bd..4bba213 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Long.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Long.java
@@ -27,14 +27,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_method_Long extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printLong( ((Bean)o).get_long() );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).set_long(DatatypeConverterImpl._parseLong(lexical));
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Short.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Short.java
index 924b3c5..89119cf 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Short.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/reflect/opt/TransducedAccessor_method_Short.java
@@ -27,14 +27,17 @@
  * @see TransducedAccessor#get
  */
 public final class TransducedAccessor_method_Short extends DefaultTransducedAccessor {
+    @Override
     public String print(Object o) {
         return DatatypeConverterImpl._printShort( ((Bean)o).get_short() );
     }
 
+    @Override
     public void parse(Object o, CharSequence lexical) {
         ((Bean)o).set_short(DatatypeConverterImpl._parseShort(lexical));
     }
 
+    @Override
     public boolean hasValue(Object o) {
         return true;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/AttributesExImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/AttributesExImpl.java
index 6d8ba80..5f30476 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/AttributesExImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/AttributesExImpl.java
@@ -20,10 +20,12 @@
  * @author Kohsuke Kawaguchi
  */
 public final class AttributesExImpl extends AttributesImpl implements AttributesEx {
+    @Override
     public CharSequence getData(int idx) {
         return getValue(idx);
     }
 
+    @Override
     public CharSequence getData(String nsUri, String localName) {
         return getValue(nsUri,localName);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/Base64Data.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/Base64Data.java
index 7b1ffad..44a8eb6 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/Base64Data.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/Base64Data.java
@@ -101,18 +101,22 @@
         if (dataHandler == null) {
             dataHandler = new DataHandler(new DataSource() {
 
+                @Override
                 public String getContentType() {
                     return getMimeType();
                 }
 
+                @Override
                 public InputStream getInputStream() {
                     return new ByteArrayInputStream(data, 0, dataLen);
                 }
 
+                @Override
                 public String getName() {
                     return null;
                 }
 
+                @Override
                 public OutputStream getOutputStream() {
                     throw new UnsupportedOperationException();
                 }
@@ -189,6 +193,7 @@
      * Gets the number of characters needed to represent
      * this binary data in the base64 encoding.
      */
+    @Override
     public int length() {
         // for each 3 bytes you use 4 chars
         // if the remainder is 1 or 2 there will be 4 more
@@ -200,6 +205,7 @@
      * Encode this binary data in the base64 encoding
      * and returns the character at the specified position.
      */
+    @Override
     public char charAt(int index) {
         // we assume that the length() method is called before this method
         // (otherwise how would the caller know that the index is valid?)
@@ -253,6 +259,7 @@
      * which doesn't happen that much for base64.
      * So this method should be smaller than faster.
      */
+    @Override
     public CharSequence subSequence(int start, int end) {
         StringBuilder buf = new StringBuilder();
         get();  // fill in the buffer if we haven't done so
@@ -265,6 +272,7 @@
     /**
      * Returns the base64 encoded string of this data.
      */
+    @Override
     public String toString() {
         get();  // fill in the buffer
         return DatatypeConverterImpl._printBase64Binary(data, 0, dataLen);
@@ -276,6 +284,7 @@
         DatatypeConverterImpl._printBase64Binary(data, 0, dataLen, buf, start);
     }
 
+    @Override
     public void writeTo(UTF8XmlOutput output) throws IOException {
         // TODO: this is inefficient if the data source is note byte[] but DataHandler
         get();
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/DefaultIDResolver.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/DefaultIDResolver.java
index a771fb6..c823f25 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/DefaultIDResolver.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/DefaultIDResolver.java
@@ -34,13 +34,14 @@
 
     @Override
     public void bind(String id, Object obj) {
-        if(idmap==null)     idmap = new HashMap<String,Object>();
+        if(idmap==null)     idmap = new HashMap<>();
         idmap.put(id,obj);
     }
 
     @Override
     public Callable resolve(final String id, Class targetType) {
         return new Callable() {
+            @Override
             public Object call() throws Exception {
                 if(idmap==null)     return null;
                 return idmap.get(id);
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/FastInfosetConnector.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/FastInfosetConnector.java
index ac25ceb..dc93344 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/FastInfosetConnector.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/FastInfosetConnector.java
@@ -48,6 +48,7 @@
         this.fastInfosetStreamReader = fastInfosetStreamReader;
     }
 
+    @Override
     public void bridge() throws XMLStreamException {
         try {
             // remembers the nest level of elements to know when we are done.
@@ -113,10 +114,12 @@
         }
     }
 
+    @Override
     protected Location getCurrentLocation() {
         return fastInfosetStreamReader.getLocation();
     }
 
+    @Override
     protected String getCurrentQName() {
         return fastInfosetStreamReader.getNameString();
     }
@@ -203,18 +206,22 @@
 
         // CharSequence interface
 
+        @Override
         public final int length() {
             return length;
         }
 
+        @Override
         public final char charAt(final int index) {
             return ch[start + index];
         }
 
+        @Override
         public final CharSequence subSequence(final int start, final int end) {
             return new CharSequenceImpl(ch, this.start + start, end - start);
         }
 
+        @Override
         public String toString() {
             return new String(ch, start, length);
         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/IntArrayData.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/IntArrayData.java
index 5ede5a1..9dd3241 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/IntArrayData.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/IntArrayData.java
@@ -64,14 +64,17 @@
         this.literal = null;
     }
 
+    @Override
     public int length() {
         return getLiteral().length();
     }
 
+    @Override
     public char charAt(int index) {
         return getLiteral().charAt(index);
     }
 
+    @Override
     public CharSequence subSequence(int start, int end) {
         return getLiteral().subSequence(start,end);
     }
@@ -92,10 +95,12 @@
         return literal;
     }
 
+    @Override
     public String toString() {
         return literal.toString();
     }
 
+    @Override
     public void writeTo(UTF8XmlOutput output) throws IOException {
         int p = start;
         for( int i=len; i>0; i-- ) {
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/IntData.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/IntData.java
index 0c2bc8e..00f84d8 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/IntData.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/IntData.java
@@ -52,23 +52,28 @@
                 return i+1;
     }
 
+    @Override
     public String toString() {
         return String.valueOf(data);
     }
 
 
+    @Override
     public int length() {
         return length;
     }
 
+    @Override
     public char charAt(int index) {
         return toString().charAt(index);
     }
 
+    @Override
     public CharSequence subSequence(int start, int end) {
         return toString().substring(start,end);
     }
 
+    @Override
     public void writeTo(UTF8XmlOutput output) throws IOException {
         output.text(data);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/InterningXmlVisitor.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/InterningXmlVisitor.java
index 9477b24..ea54715 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/InterningXmlVisitor.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/InterningXmlVisitor.java
@@ -30,14 +30,17 @@
         this.next = next;
     }
 
+    @Override
     public void startDocument(LocatorEx locator, NamespaceContext nsContext) throws SAXException {
         next.startDocument(locator,nsContext);
     }
 
+    @Override
     public void endDocument() throws SAXException {
         next.endDocument();
     }
 
+    @Override
     public void startElement(TagName tagName ) throws SAXException {
         attributes.setAttributes(tagName.atts);
         tagName.atts = attributes;
@@ -46,28 +49,34 @@
         next.startElement(tagName);
     }
 
+    @Override
     public void endElement(TagName tagName ) throws SAXException {
         tagName.uri = intern(tagName.uri);
         tagName.local = intern(tagName.local);
         next.endElement(tagName);
     }
 
+    @Override
     public void startPrefixMapping( String prefix, String nsUri ) throws SAXException {
         next.startPrefixMapping(intern(prefix),intern(nsUri));
     }
 
+    @Override
     public void endPrefixMapping( String prefix ) throws SAXException {
         next.endPrefixMapping(intern(prefix));
     }
 
+    @Override
     public void text( CharSequence pcdata ) throws SAXException {
         next.text(pcdata);
     }
 
+    @Override
     public UnmarshallingContext getContext() {
         return next.getContext();
     }
     
+    @Override
     public TextPredictor getPredictor() {
         return next.getPredictor();
     }
@@ -79,38 +88,47 @@
             this.core = att;
         }
 
+        @Override
         public int getIndex(String qName) {
             return core.getIndex(qName);
         }
 
+        @Override
         public int getIndex(String uri, String localName) {
             return core.getIndex(uri, localName);
         }
 
+        @Override
         public int getLength() {
             return core.getLength();
         }
 
+        @Override
         public String getLocalName(int index) {
             return intern(core.getLocalName(index));
         }
 
+        @Override
         public String getQName(int index) {
             return intern(core.getQName(index));
         }
 
+        @Override
         public String getType(int index) {
             return intern(core.getType(index));
         }
 
+        @Override
         public String getType(String qName) {
             return intern(core.getType(qName));
         }
 
+        @Override
         public String getType(String uri, String localName) {
             return intern(core.getType(uri, localName));
         }
 
+        @Override
         public String getURI(int index) {
             return intern(core.getURI(index));
         }
@@ -120,14 +138,17 @@
         // we don't (probably shouldn't) intern values.
         //
 
+        @Override
         public String getValue(int index) {
             return core.getValue(index);
         }
 
+        @Override
         public String getValue(String qName) {
             return core.getValue(qName);
         }
 
+        @Override
         public String getValue(String uri, String localName) {
             return core.getValue(uri, localName);
         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/LeafPropertyLoader.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/LeafPropertyLoader.java
index 83dd04e..3fb318e 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/LeafPropertyLoader.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/LeafPropertyLoader.java
@@ -29,6 +29,7 @@
         this.xacc = xacc;
     }
 
+    @Override
     public void text(UnmarshallingContext.State state, CharSequence text) throws SAXException {
         try {
             xacc.parse(state.getPrev().getTarget(), text);
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/LocatorExWrapper.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/LocatorExWrapper.java
index f5dafc6..3232742 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/LocatorExWrapper.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/LocatorExWrapper.java
@@ -27,22 +27,27 @@
         this.locator = locator;
     }
 
+    @Override
     public ValidationEventLocator getLocation() {
         return new ValidationEventLocatorImpl(locator);
     }
 
+    @Override
     public String getPublicId() {
         return locator.getPublicId();
     }
 
+    @Override
     public String getSystemId() {
         return locator.getSystemId();
     }
 
+    @Override
     public int getLineNumber() {
         return locator.getLineNumber();
     }
 
+    @Override
     public int getColumnNumber() {
         return locator.getColumnNumber();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/MTOMDecorator.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/MTOMDecorator.java
index 86cdd64..d7fb34b 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/MTOMDecorator.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/MTOMDecorator.java
@@ -55,14 +55,17 @@
         this.au = au;
     }
 
+    @Override
     public void startDocument(LocatorEx loc, NamespaceContext nsContext) throws SAXException {
         next.startDocument(loc,nsContext);
     }
 
+    @Override
     public void endDocument() throws SAXException {
         next.endDocument();
     }
 
+    @Override
     public void startElement(TagName tagName) throws SAXException {
         if(tagName.local.equals("Include") && tagName.uri.equals(WellKnownNamespace.XOP)) {
             // found xop:Include
@@ -81,6 +84,7 @@
             next.startElement(tagName);
     }
 
+    @Override
     public void endElement(TagName tagName) throws SAXException {
         if(inXopInclude) {
             // consume </xop:Include> by ourselves.
@@ -91,14 +95,17 @@
         next.endElement(tagName);
     }
 
+    @Override
     public void startPrefixMapping(String prefix, String nsUri) throws SAXException {
         next.startPrefixMapping(prefix,nsUri);
     }
 
+    @Override
     public void endPrefixMapping(String prefix) throws SAXException {
         next.endPrefixMapping(prefix);
     }
 
+    @Override
     public void text( CharSequence pcdata ) throws SAXException {
         if(!followXop)
             next.text(pcdata);
@@ -106,10 +113,12 @@
             followXop = false;
     }
 
+    @Override
     public UnmarshallingContext getContext() {
         return next.getContext();
     }
 
+    @Override
     public TextPredictor getPredictor() {
         return next.getPredictor();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StAXConnector.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StAXConnector.java
index ae1b632..0e7f520 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StAXConnector.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StAXConnector.java
@@ -33,6 +33,7 @@
     protected final XmlVisitor.TextPredictor predictor;
 
     private final class TagNameImpl extends TagName {
+        @Override
         public String getQname() {
             return StAXConnector.this.getCurrentQName();
         }
@@ -59,18 +60,23 @@
 
     protected final void handleStartDocument(NamespaceContext nsc) throws SAXException {
         visitor.startDocument(new LocatorEx() {
+            @Override
             public ValidationEventLocator getLocation() {
                 return new ValidationEventLocatorImpl(this);
             }
+            @Override
             public int getColumnNumber() {
                 return getCurrentLocation().getColumnNumber();
             }
+            @Override
             public int getLineNumber() {
                 return getCurrentLocation().getLineNumber();
             }
+            @Override
             public String getPublicId() {
                 return getCurrentLocation().getPublicId();
             }
+            @Override
             public String getSystemId() {
                 return getCurrentLocation().getSystemId();
             }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StAXEventConnector.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StAXEventConnector.java
index c11c019..9e0a6fd 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StAXEventConnector.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StAXEventConnector.java
@@ -66,6 +66,7 @@
         staxEventReader = staxCore;
     }
 
+    @Override
     public void bridge() throws XMLStreamException {
 
         try {
@@ -117,10 +118,12 @@
         }
     }
 
+    @Override
     protected Location getCurrentLocation() {
         return event.getLocation();
     }
 
+    @Override
     protected String getCurrentQName() {
         QName qName;
         if(event.isEndElement())
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StAXStreamConnector.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StAXStreamConnector.java
index ca07402..cdd0fc8 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StAXStreamConnector.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StAXStreamConnector.java
@@ -118,6 +118,7 @@
         this.staxStreamReader = staxStreamReader;
     }
 
+    @Override
     public void bridge() throws XMLStreamException {
 
         try {
@@ -172,10 +173,12 @@
         }
     }
 
+    @Override
     protected Location getCurrentLocation() {
         return staxStreamReader.getLocation();
     }
 
+    @Override
     protected String getCurrentQName() {
         return getQName(staxStreamReader.getPrefix(),staxStreamReader.getLocalName());
     }
@@ -218,20 +221,24 @@
      * Proxy of {@link Attributes} that read from {@link XMLStreamReader}.
      */
     private final Attributes attributes = new Attributes() {
+        @Override
         public int getLength() {
             return staxStreamReader.getAttributeCount();
         }
 
+        @Override
         public String getURI(int index) {
             String uri = staxStreamReader.getAttributeNamespace(index);
             if(uri==null)   return "";
             return uri;
         }
 
+        @Override
         public String getLocalName(int index) {
             return staxStreamReader.getAttributeLocalName(index);
         }
 
+        @Override
         public String getQName(int index) {
             String prefix = staxStreamReader.getAttributePrefix(index);
             if(prefix==null || prefix.length()==0)
@@ -240,14 +247,17 @@
                 return prefix + ':' + getLocalName(index);
         }
 
+        @Override
         public String getType(int index) {
             return staxStreamReader.getAttributeType(index);
         }
 
+        @Override
         public String getValue(int index) {
             return staxStreamReader.getAttributeValue(index);
         }
 
+        @Override
         public int getIndex(String uri, String localName) {
             for( int i=getLength()-1; i>=0; i-- )
                 if( localName.equals(getLocalName(i)) && uri.equals(getURI(i)))
@@ -257,6 +267,7 @@
 
         // this method sholdn't be used that often (if at all)
         // so it's OK to be slow.
+        @Override
         public int getIndex(String qName) {
             for( int i=getLength()-1; i>=0; i-- ) {
                 if(qName.equals(getQName(i)))
@@ -265,24 +276,28 @@
             return -1;
         }
 
+        @Override
         public String getType(String uri, String localName) {
             int index = getIndex(uri,localName);
             if(index<0)     return null;
             return getType(index);
         }
 
+        @Override
         public String getType(String qName) {
             int index = getIndex(qName);
             if(index<0)     return null;
             return getType(index);
         }
 
+        @Override
         public String getValue(String uri, String localName) {
             int index = getIndex(uri,localName);
             if(index<0)     return null;
             return getValue(index);
         }
 
+        @Override
         public String getValue(String qName) {
             int index = getIndex(qName);
             if(index<0)     return null;
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StructureLoader.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StructureLoader.java
index efd2fb5..0a8e08a 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StructureLoader.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/StructureLoader.java
@@ -49,7 +49,7 @@
      * Since creating new QNames is expensive use this optimized
      * version of the map
      */
-    private final QNameMap<ChildLoader> childUnmarshallers = new QNameMap<ChildLoader>();
+    private final QNameMap<ChildLoader> childUnmarshallers = new QNameMap<>();
 
     /**
      * Loader that processes elements that didn't match anf of the {@link #childUnmarshallers}.
@@ -105,7 +105,7 @@
                 switch(p.getKind()) {
                 case ATTRIBUTE:
                     if(attUnmarshallers==null)
-                        attUnmarshallers = new QNameMap<TransducedAccessor>();
+                        attUnmarshallers = new QNameMap<>();
                     AttributeProperty ap = (AttributeProperty) p;
                     attUnmarshallers.put(ap.attName.toQName(),ap.xacc);
                     break;
@@ -189,7 +189,7 @@
 
                             // if null, create a new map.
                             if(attCatchAll.valueType.isAssignableFrom(HashMap.class))
-                                map = new HashMap<QName,String>();
+                                map = new HashMap<>();
                             else {
                                 // we don't know how to create a map for this.
                                 // report an error and back out
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/TagName.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/TagName.java
index 97995d0..2818d75 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/TagName.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/TagName.java
@@ -86,6 +86,7 @@
 //        else        return qname.substring(0,idx);
 //    }
 
+    @Override
     public String toString() {
         return '{'+uri+'}'+local;
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/TextLoader.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/TextLoader.java
index 9d3b832..7666f32 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/TextLoader.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/TextLoader.java
@@ -33,6 +33,7 @@
         this.xducer = xducer;
     }
 
+    @Override
     public void text(UnmarshallingContext.State state, CharSequence text) throws SAXException {
         try {
             state.setTarget(xducer.parse(text));
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/UnmarshallerImpl.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/UnmarshallerImpl.java
index 931d0d5..53c32b3 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/UnmarshallerImpl.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/UnmarshallerImpl.java
@@ -90,6 +90,7 @@
         }
     }
 
+    @Override
     public UnmarshallerHandler getUnmarshallerHandler() {
         return getUnmarshallerHandler(true,null);
     }
@@ -185,6 +186,7 @@
         return true;
     }
 
+    @Override
     protected Object unmarshal( XMLReader reader, InputSource source ) throws JAXBException {
         return unmarshal0(reader,source,null);
     }
@@ -308,6 +310,7 @@
         return (JAXBElement)unmarshal0(node,getBeanInfo(expectedType));
     }
 
+    @Override
     public final Object unmarshal( Node node ) throws JAXBException {
         return unmarshal0(node,null);
     }
@@ -542,6 +545,7 @@
     /**
      * Default error handling behavior for {@link Unmarshaller}.
      */
+    @Override
     public boolean handleEvent(ValidationEvent event) {
         return event.getSeverity()!=ValidationEvent.FATAL_ERROR;
     }
@@ -587,6 +591,7 @@
      *  Must be called from same thread which created the UnmarshallerImpl instance.
      * @throws IOException 
      */
+    @Override
     public void close() throws IOException {
         ClassFactory.cleanCache();
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/UnmarshallingContext.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/UnmarshallingContext.java
index 30e3f43..e969669 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/UnmarshallingContext.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/UnmarshallingContext.java
@@ -453,7 +453,7 @@
     /**
      * User-specified factory methods.
      */
-    private final Map<Class,Factory> factories = new HashMap<Class, Factory>();
+    private final Map<Class,Factory> factories = new HashMap<>();
 
     public void setFactories(Object factoryInstances) {
         factories.clear();
@@ -933,7 +933,7 @@
     }
 
     private List<String> getAllPrefixesInList(String uri) {
-        List<String> a = new ArrayList<String>();
+        List<String> a = new ArrayList<>();
 
         if( uri==null )
             throw new IllegalArgumentException();
@@ -1108,7 +1108,7 @@
             }
 
             state.loader = beanInfo.getLoader(null,false);
-            state.prev.backup = new JAXBElement<Object>(ea.createQName(),Object.class,null);
+            state.prev.backup = new JAXBElement<>(ea.createQName(),Object.class,null);
             state.receiver = this;
         }
 
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/ValidatingUnmarshaller.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/ValidatingUnmarshaller.java
index 4d0bd07..1d600a5 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/ValidatingUnmarshaller.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/ValidatingUnmarshaller.java
@@ -48,6 +48,7 @@
         validator.setErrorHandler(new FatalAdapter(getContext()));
     }
 
+    @Override
     public void startDocument(LocatorEx locator, NamespaceContext nsContext) throws SAXException {
         this.nsContext = nsContext;
         validator.setDocumentLocator(locator);
@@ -55,12 +56,14 @@
         next.startDocument(locator,nsContext);
     }
 
+    @Override
     public void endDocument() throws SAXException {
         this.nsContext = null;
         validator.endDocument();
         next.endDocument();
     }
 
+    @Override
     public void startElement(TagName tagName) throws SAXException {
         if(nsContext != null) {
             String tagNamePrefix = tagName.getPrefix().intern();
@@ -72,21 +75,25 @@
         next.startElement(tagName);
     }
 
+    @Override
     public void endElement(TagName tagName ) throws SAXException {
         validator.endElement(tagName.uri,tagName.local,tagName.getQname());
         next.endElement(tagName);
     }
 
+    @Override
     public void startPrefixMapping(String prefix, String nsUri) throws SAXException {
         validator.startPrefixMapping(prefix,nsUri);
         next.startPrefixMapping(prefix,nsUri);
     }
 
+    @Override
     public void endPrefixMapping(String prefix) throws SAXException {
         validator.endPrefixMapping(prefix);
         next.endPrefixMapping(prefix);
     }
 
+    @Override
     public void text( CharSequence pcdata ) throws SAXException {
         int len = pcdata.length();
         if(buf.length<len) {
@@ -100,16 +107,19 @@
             next.text(pcdata);
     }
 
+    @Override
     public UnmarshallingContext getContext() {
         return next.getContext();
     }
 
+    @Override
     public TextPredictor getPredictor() {
         return this;
     }
 
     // should be always invoked through TextPredictor
     @Deprecated
+    @Override
     public boolean expectText() {
         // validator needs to make sure that there's no text
         // even when it's not expected. So always have them
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/ValuePropertyLoader.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/ValuePropertyLoader.java
index b9838b1..75326aa 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/ValuePropertyLoader.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/ValuePropertyLoader.java
@@ -30,6 +30,7 @@
         this.xacc = xacc;
     }
 
+    @Override
     public void text(UnmarshallingContext.State state, CharSequence text) throws SAXException {
         try {
             xacc.parse(state.getTarget(),text);
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/WildcardLoader.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/WildcardLoader.java
index 1125207..407a986 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/WildcardLoader.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/WildcardLoader.java
@@ -36,6 +36,7 @@
         this.mode = mode;
     }
 
+    @Override
     protected Loader selectLoader(UnmarshallingContext.State state, TagName tag) throws SAXException {
         UnmarshallingContext context = state.getContext();
 
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/XsiNilLoader.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/XsiNilLoader.java
index b433623..490ba96 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/XsiNilLoader.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/XsiNilLoader.java
@@ -35,6 +35,7 @@
         assert defaultLoader!=null;
     }
 
+    @Override
     protected Loader selectLoader(UnmarshallingContext.State state, TagName ea) throws SAXException {
         int idx = ea.atts.getIndex(WellKnownNamespace.XML_SCHEMA_INSTANCE,"nil");
 
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/XsiTypeLoader.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/XsiTypeLoader.java
index a91d619..a77b4fa 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/XsiTypeLoader.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/runtime/unmarshaller/XsiTypeLoader.java
@@ -39,6 +39,7 @@
         this.defaultBeanInfo = defaultBeanInfo;
     }
 
+    @Override
     public void startElement(UnmarshallingContext.State state, TagName ea) throws SAXException {
         JaxBeanInfo beanInfo = parseXsiType(state,ea,defaultBeanInfo);
         if(beanInfo==null)
@@ -103,7 +104,7 @@
 
     @Override
     public Collection<QName> getExpectedAttributes() {
-        final Collection<QName> expAttrs =  new HashSet<QName>();
+        final Collection<QName> expAttrs =  new HashSet<>();
         expAttrs.addAll(super.getExpectedAttributes());
         expAttrs.add(XsiTypeQNAME);
         return Collections.unmodifiableCollection(expAttrs);
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/FoolProofResolver.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/FoolProofResolver.java
index e4a05aa..3fad522 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/FoolProofResolver.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/FoolProofResolver.java
@@ -34,6 +34,7 @@
         this.resolver = resolver;
     }
 
+    @Override
     public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException {
         logger.entering(getClass().getName(),"createOutput",new Object[]{namespaceUri,suggestedFileName});
         Result r = resolver.createOutput(namespaceUri,suggestedFileName);
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/Form.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/Form.java
index 9e2c901..8b64b22 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/Form.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/Form.java
@@ -25,11 +25,13 @@
  */
 enum Form {
     QUALIFIED(XmlNsForm.QUALIFIED,true) {
+        @Override
         void declare(String attName, Schema schema) {
             schema._attribute(attName,"qualified");
         }
     },
     UNQUALIFIED(XmlNsForm.UNQUALIFIED,false) {
+        @Override
         void declare(String attName,Schema schema) {
             // pointless, but required by the spec.
             // people need to understand that @attributeFormDefault is a syntax sugar
@@ -37,6 +39,7 @@
         }
     },
     UNSET(XmlNsForm.UNSET,false) {
+        @Override
         void declare(String attName,Schema schema) {
         }
     };
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/Tree.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/Tree.java
index 54df55c..df09156 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/Tree.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/Tree.java
@@ -64,7 +64,7 @@
 
         // eliminated nesting groups of the same kind.
         // this is where binary tree would have shined.
-        List<Tree> normalizedChildren = new ArrayList<Tree>(children.size());
+        List<Tree> normalizedChildren = new ArrayList<>(children.size());
         for (Tree t : children) {
             if (t instanceof Group) {
                 Group g = (Group) t;
@@ -125,6 +125,7 @@
      * Represents a terminal tree node, such as element, wildcard, etc.
      */
     abstract static class Term extends Tree {
+        @Override
         boolean isNullable() {
             return false;
         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/XmlSchemaGenerator.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/XmlSchemaGenerator.java
index e83e399..7eca34c 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/XmlSchemaGenerator.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/schemagen/XmlSchemaGenerator.java
@@ -80,7 +80,7 @@
      *
      * @see SchemaOutputResolver#createOutput(String, String)
      */
-    private final Map<String,Namespace> namespaces = new TreeMap<String,Namespace>(NAMESPACE_COMPARATOR);
+    private final Map<String,Namespace> namespaces = new TreeMap<>(NAMESPACE_COMPARATOR);
 
     /**
      * {@link ErrorListener} to send errors to.
@@ -105,7 +105,7 @@
     /**
      * Used to detect cycles in anonymous types.
      */
-    private final CollisionCheckStack<ClassInfo<T,C>> collisionChecker = new CollisionCheckStack<ClassInfo<T,C>>();
+    private final CollisionCheckStack<ClassInfo<T,C>> collisionChecker = new CollisionCheckStack<>();
 
     public XmlSchemaGenerator( Navigator<T,C,F,M> navigator, TypeInfoSet<T,C,F,M> types ) {
         this.navigator = navigator;
@@ -385,8 +385,8 @@
 
         Map<String, String> schemaLocations = types.getSchemaLocations();
 
-        Map<Namespace,Result> out = new HashMap<Namespace,Result>();
-        Map<Namespace,String> systemIds = new HashMap<Namespace,String>();
+        Map<Namespace,Result> out = new HashMap<>();
+        Map<Namespace,String> systemIds = new HashMap<>();
 
         // we create a Namespace object for the XML Schema namespace
         // as a side-effect, but we don't want to generate it.
@@ -436,7 +436,7 @@
         /**
          * Other {@link Namespace}s that this namespace depends on.
          */
-        private final Set<Namespace> depends = new LinkedHashSet<Namespace>();
+        private final Set<Namespace> depends = new LinkedHashSet<>();
 
         /**
          * If this schema refers to components from this schema by itself.
@@ -446,28 +446,28 @@
         /**
          * List of classes in this namespace.
          */
-        private final Set<ClassInfo<T,C>> classes = new LinkedHashSet<ClassInfo<T,C>>();
+        private final Set<ClassInfo<T,C>> classes = new LinkedHashSet<>();
 
         /**
          * Set of enums in this namespace
          */
-        private final Set<EnumLeafInfo<T,C>> enums = new LinkedHashSet<EnumLeafInfo<T,C>>();
+        private final Set<EnumLeafInfo<T,C>> enums = new LinkedHashSet<>();
 
         /**
          * Set of arrays in this namespace
          */
-        private final Set<ArrayInfo<T,C>> arrays = new LinkedHashSet<ArrayInfo<T,C>>();
+        private final Set<ArrayInfo<T,C>> arrays = new LinkedHashSet<>();
 
         /**
          * Global attribute declarations keyed by their local names.
          */
-        private final MultiMap<String,AttributePropertyInfo<T,C>> attributeDecls = new MultiMap<String,AttributePropertyInfo<T,C>>(null);
+        private final MultiMap<String,AttributePropertyInfo<T,C>> attributeDecls = new MultiMap<>(null);
 
         /**
          * Global element declarations to be written, keyed by their local names.
          */
         private final MultiMap<String,ElementDeclaration> elementDecls =
-                new MultiMap<String,ElementDeclaration>(new ElementWithType(true,anyType));
+                new MultiMap<>(new ElementWithType(true,anyType));
 
         private Form attributeFormDefault;
         private Form elementFormDefault;
@@ -487,7 +487,7 @@
         /**
          * Container for already processed classes
          */
-        private final Set<ClassInfo> written = new HashSet<ClassInfo>();
+        private final Set<ClassInfo> written = new HashSet<>();
 
         public Namespace(String uri) {
             this.uri = uri;
@@ -910,7 +910,7 @@
 
             if(contentModelOwner!=null) {
                 // build the tree that represents the explicit content model from iterate over the properties
-                ArrayList<Tree> children = new ArrayList<Tree>();
+                ArrayList<Tree> children = new ArrayList<>();
                 for (PropertyInfo<T,C> p : c.getProperties()) {
                     // handling for <complexType @mixed='true' ...>
                     if(p instanceof ReferencePropertyInfo && ((ReferencePropertyInfo)p).isMixed()) {
@@ -991,6 +991,7 @@
         private Tree handleElementProp(final ElementPropertyInfo<T,C> ep) {
             if (ep.isValueList()) {
                 return new Tree.Term() {
+                    @Override
                     protected void write(ContentModelContainer parent, boolean isOptional, boolean repeated) {
                         TypeRef<T,C> t = ep.getTypes().get(0);
                         LocalElement e = parent.element();
@@ -1005,9 +1006,10 @@
                 };
             }
 
-            ArrayList<Tree> children = new ArrayList<Tree>();
+            ArrayList<Tree> children = new ArrayList<>();
             for (final TypeRef<T,C> t : ep.getTypes()) {
                 children.add(new Tree.Term() {
+                    @Override
                     protected void write(ContentModelContainer parent, boolean isOptional, boolean repeated) {
                         LocalElement e = parent.element();
 
@@ -1073,6 +1075,7 @@
             final QName ename = ep.getXmlName();
             if (ename != null) { // wrapped collection
                 return new Tree.Term() {
+                    @Override
                     protected void write(ContentModelContainer parent, boolean isOptional, boolean repeated) {
                         LocalElement e = parent.element();
                         if(ename.getNamespaceURI().length()>0) {
@@ -1209,10 +1212,11 @@
          */
         private Tree handleReferenceProp(final ReferencePropertyInfo<T, C> rp) {
             // fill in content model
-            ArrayList<Tree> children = new ArrayList<Tree>();
+            ArrayList<Tree> children = new ArrayList<>();
 
             for (final Element<T,C> e : rp.getElements()) {
                 children.add(new Tree.Term() {
+                    @Override
                     protected void write(ContentModelContainer parent, boolean isOptional, boolean repeated) {
                         LocalElement eref = parent.element();
 
@@ -1256,6 +1260,7 @@
             final WildcardMode wc = rp.getWildcard();
             if( wc != null ) {
                 children.add(new Tree.Term() {
+                    @Override
                     protected void write(ContentModelContainer parent, boolean isOptional, boolean repeated) {
                         Any any = parent.any();
                         final String pcmode = getProcessContentsModeName(wc);
@@ -1273,6 +1278,7 @@
 
             if (ename != null) { // wrapped
                 return new Tree.Term() {
+                    @Override
                     protected void write(ContentModelContainer parent, boolean isOptional, boolean repeated) {
                         LocalElement e = parent.element().name(ename.getLocalPart());
                         elementFormDefault.writeForm(e,ename);
@@ -1297,6 +1303,7 @@
          */
         private Tree handleMapProp(final MapPropertyInfo<T,C> mp) {
             return new Tree.Term() {
+                @Override
                 protected void write(ContentModelContainer parent, boolean isOptional, boolean repeated) {
                     QName ename = mp.getXmlName();
 
@@ -1389,6 +1396,7 @@
                 this.nillable = nillable;
             }
 
+            @Override
             public void writeTo(String localName, Schema schema) {
                 TopLevelElement e = schema.element().name(localName);
                 if(nillable)
@@ -1401,6 +1409,7 @@
                 e.commit();
             }
 
+            @Override
             public boolean equals(Object o) {
                 if (this == o) return true;
                 if (o == null || getClass() != o.getClass()) return false;
@@ -1409,6 +1418,7 @@
                 return type.equals(that.type);
             }
 
+            @Override
             public int hashCode() {
                 return type.hashCode();
             }
@@ -1554,6 +1564,7 @@
      * so that the empty namespace "" comes to the very end. Don't ask me why.
      */
     private static final Comparator<String> NAMESPACE_COMPARATOR = new Comparator<String>() {
+        @Override
         public int compare(String lhs, String rhs) {
             return -lhs.compareTo(rhs);
         }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/util/FatalAdapter.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/util/FatalAdapter.java
index b622006..504fa25 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/util/FatalAdapter.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/util/FatalAdapter.java
@@ -26,14 +26,17 @@
         this.core = handler;
     }
 
+    @Override
     public void warning (SAXParseException exception) throws SAXException {
         core.warning(exception);
     }
 
+    @Override
     public void error (SAXParseException exception) throws SAXException {
         core.fatalError(exception);
     }
 
+    @Override
     public void fatalError (SAXParseException exception) throws SAXException {
         core.fatalError(exception);
     }
diff --git a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/util/QNameMap.java b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/util/QNameMap.java
index 527aeec..a3c4adf 100644
--- a/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/util/QNameMap.java
+++ b/jaxb-ri/runtime/impl/src/main/java/org/glassfish/jaxb/runtime/v2/util/QNameMap.java
@@ -201,7 +201,7 @@
      */
     private void addEntry(int hash, String nsUri, String localName, V value, int bucketIndex) {
         Entry<V> e = table[bucketIndex];
-        table[bucketIndex] = new Entry<V>(hash, nsUri, localName, value, e);
+        table[bucketIndex] = new Entry<>(hash, nsUri, localName, value, e);
         if (size++ >= threshold)
             resize(2 * table.length);
     }
@@ -263,7 +263,7 @@
     }
 
     public Collection<QName> keySet() {
-        Set<QName> r = new HashSet<QName>();
+        Set<QName> r = new HashSet<>();
         for (Entry<V> e : entrySet()) {
             r.add(e.createQName());
         }
@@ -285,6 +285,7 @@
             index = i;
         }
 
+        @Override
         public boolean hasNext() {
             return next != null;
         }
@@ -304,6 +305,7 @@
             return e;
         }
 
+        @Override
         public void remove() {
             throw new UnsupportedOperationException();
         }
@@ -402,11 +404,13 @@
     }
 
     private class EntryIterator extends HashIterator<Entry<V>> {
+        @Override
         public Entry<V> next() {
             return nextEntry();
         }
     }
     private class EntrySet extends AbstractSet<Entry<V>> {
+        @Override
         public Iterator<Entry<V>> iterator() {
             return newEntryIterator();
         }
@@ -422,6 +426,7 @@
         public boolean remove(Object o) {
             throw new UnsupportedOperationException();
         }
+        @Override
         public int size() {
             return size;
         }
diff --git a/jaxb-ri/runtime/impl/src/test/java/FilterList.java b/jaxb-ri/runtime/impl/src/test/java/FilterList.java
index 7ef301e..43fd0ad 100644
--- a/jaxb-ri/runtime/impl/src/test/java/FilterList.java
+++ b/jaxb-ri/runtime/impl/src/test/java/FilterList.java
@@ -134,14 +134,17 @@
             throw new IndexOutOfBoundsException(Integer.toString(index));
     }
     
+    @Override
     public void add(int index, Object element) {
         core.add(toCoreIndex(index,true),element);
     }
     
+    @Override
     public Iterator iterator() {
         return listIterator();
     }
     
+    @Override
     public ListIterator listIterator(final int index) {
         return new ListIterator() {
             /**
@@ -171,12 +174,15 @@
              */
             private int lastRet = -1;
             
+            @Override
             public int nextIndex() {
                 return thisIndex;
             }
+            @Override
             public int previousIndex() {
                 return thisIndex-1;
             }
+            @Override
             public void remove() {
                 if (lastRet == -1)
                     throw new IllegalStateException();
@@ -192,9 +198,11 @@
                     throw new ConcurrentModificationException();
                 }
             }
+            @Override
             public boolean hasNext() {
                 return coreIndex<core.size();
             }
+            @Override
             public Object next() {
                 int coreSize = core.size();
                 
@@ -210,6 +218,7 @@
                     
                 return core.get(lastRet);
             }
+            @Override
             public boolean hasPrevious() {
                 // TODO: this could be made bit more efficient
                 
@@ -220,6 +229,7 @@
                 
                 return idx>=0;
             }
+            @Override
             public Object previous() {
                 // TODO: this could be made bit more efficient
                 
@@ -237,6 +247,7 @@
                 
                 return core.get(lastRet);
             }
+            @Override
             public void add(Object o) {
                 try {
                     core.add(coreIndex,o);
@@ -245,6 +256,7 @@
                     throw new ConcurrentModificationException();
                 }
             }
+            @Override
             public void set(Object o) {
                 if (lastRet == -1)
                     throw new IllegalStateException();
@@ -258,6 +270,7 @@
         };
     }
     
+    @Override
     public Object set(int index, Object element) {
         return core.set(toCoreIndex(index,false),element);
     }
@@ -268,14 +281,17 @@
      * @param index The offset of the object.
      * @return The Object which was removed.
      */
+    @Override
     public Object remove(int index) {
         return core.remove(toCoreIndex(index,false));
     }
     
+    @Override
     public Object get(int index) {
         return core.get(toCoreIndex(index,false));
     }
 
+    @Override
     public int size() {
         if(isCoreModified() || size==-1) {
             size=0;
diff --git a/jaxb-ri/runtime/impl/src/test/java/XMLResolverAdapter.java b/jaxb-ri/runtime/impl/src/test/java/XMLResolverAdapter.java
index 34f6a67..3278f1d 100644
--- a/jaxb-ri/runtime/impl/src/test/java/XMLResolverAdapter.java
+++ b/jaxb-ri/runtime/impl/src/test/java/XMLResolverAdapter.java
@@ -31,6 +31,7 @@
         this.entityResolver = entityResolver;
     }
 
+    @Override
     public Object resolveEntity(String publicID, String systemID, String baseURI, String namespace) throws XMLStreamException {
         try {
             InputSource is = entityResolver.resolveEntity(publicID,systemID);
diff --git a/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/CompositeStructureTest.java b/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/CompositeStructureTest.java
index 330ebe1..af8d95c 100644
--- a/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/CompositeStructureTest.java
+++ b/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/CompositeStructureTest.java
@@ -50,7 +50,7 @@
         };
         cs.values = new Object[] { "foo", 5, new byte[4], new byte[4] };
 
-        JAXBElement<CompositeStructure> root = new JAXBElement<CompositeStructure>(
+        JAXBElement<CompositeStructure> root = new JAXBElement<>(
                 new QName("", "root"), CompositeStructure.class, cs);
 
         StringWriter sw = new StringWriter();
diff --git a/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/schemagen/xmlschema/JaxbContainer.java b/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/schemagen/xmlschema/JaxbContainer.java
index 707cf87..3c12825 100644
--- a/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/schemagen/xmlschema/JaxbContainer.java
+++ b/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/schemagen/xmlschema/JaxbContainer.java
@@ -45,7 +45,7 @@
      * Creates new instance of JaxbContainer with empty version, intended for JAXB purposes only!
      */
     protected JaxbContainer() {
-        this.deployments = new ArrayList<JaxbDeployment>();
+        this.deployments = new ArrayList<>();
     }
 
     /**
diff --git a/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/schemagen/xmlschema/JaxbDistribution.java b/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/schemagen/xmlschema/JaxbDistribution.java
index e0dc2a3..73804f5 100644
--- a/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/schemagen/xmlschema/JaxbDistribution.java
+++ b/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/schemagen/xmlschema/JaxbDistribution.java
@@ -40,7 +40,7 @@
      * Creates new instance of this class with default values!
      */
     public JaxbDistribution() {
-        this.deployments = new ArrayList<JaxbDeployment>();
+        this.deployments = new ArrayList<>();
     }
 
     /**
diff --git a/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/util/CollisionCheckStackTest.java b/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/util/CollisionCheckStackTest.java
index 0d10a80..9ab92f5 100644
--- a/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/util/CollisionCheckStackTest.java
+++ b/jaxb-ri/runtime/impl/src/test/java/org/glassfish/jaxb/runtime/v2/util/CollisionCheckStackTest.java
@@ -17,7 +17,7 @@
  */
 public class CollisionCheckStackTest extends TestCase {
     public void test1() {
-        CollisionCheckStack<String> s = new CollisionCheckStack<String>();
+        CollisionCheckStack<String> s = new CollisionCheckStack<>();
         assertFalse(s.push("foo"));
         assertFalse(s.push("bar"));
         s.pop();
@@ -32,7 +32,7 @@
      * Tests the reallocation and reset.
      */
     public void test2() {
-        CollisionCheckStack<Integer> s = new CollisionCheckStack<Integer>();
+        CollisionCheckStack<Integer> s = new CollisionCheckStack<>();
 
         for( int j=0; j<3; j++ ) {
             for( int i=0; i<100; i++ )
