diff --git a/querydsl-apt/src/main/java/com/querydsl/apt/SimpleTypeVisitorAdapter.java b/querydsl-apt/src/main/java/com/querydsl/apt/SimpleTypeVisitorAdapter.java
index 404692b2d..8dd8db97c 100644
--- a/querydsl-apt/src/main/java/com/querydsl/apt/SimpleTypeVisitorAdapter.java
+++ b/querydsl-apt/src/main/java/com/querydsl/apt/SimpleTypeVisitorAdapter.java
@@ -39,6 +39,7 @@ class SimpleTypeVisitorAdapter<R, P> extends SimpleTypeVisitor6<R, P> {
         } catch (Exception e) {}
     }
 
+    @Override
     public R visitUnknown(TypeMirror t, P p) {
         if (IntersectionTypeClass != null && IntersectionTypeClass.isInstance(t)) {
             try {
diff --git a/querydsl-core/src/main/java/com/querydsl/core/alias/PropertyAccessInvocationHandler.java b/querydsl-core/src/main/java/com/querydsl/core/alias/PropertyAccessInvocationHandler.java
index 5ddcab586..510b93809 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/alias/PropertyAccessInvocationHandler.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/alias/PropertyAccessInvocationHandler.java
@@ -66,6 +66,7 @@ class PropertyAccessInvocationHandler implements MethodInterceptor {
     }
 
     //CHECKSTYLE:OFF
+    @Override
     public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
     //CHECKSTYLE:ON
         Object rv = null;
diff --git a/querydsl-core/src/main/java/com/querydsl/core/support/QueryMixin.java b/querydsl-core/src/main/java/com/querydsl/core/support/QueryMixin.java
index 49f68a542..b81308d35 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/support/QueryMixin.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/support/QueryMixin.java
@@ -35,6 +35,7 @@ public class QueryMixin<T> {
     private final boolean expandAnyPaths;
 
     private final ReplaceVisitor<Void> replaceVisitor = new ReplaceVisitor<Void>() {
+        @Override
         public Expression<?> visit(Path<?> expr, @Nullable Void context) {
             return normalizePath(expr);
         }
diff --git a/querydsl-core/src/main/java/com/querydsl/core/types/ExpressionBase.java b/querydsl-core/src/main/java/com/querydsl/core/types/ExpressionBase.java
index a0d96e621..301a1fd70 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/types/ExpressionBase.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/types/ExpressionBase.java
@@ -37,11 +37,13 @@ public abstract class ExpressionBase<T> implements Expression<T> {
     public ExpressionBase(Class<? extends T> type) {
         this.type = type;
     }
-    
+
+    @Override
     public final Class<? extends T> getType() {
         return type;
     }
-    
+
+    @Override
     public final int hashCode() {
         if (hashCode == null) {
             hashCode = accept(HashCodeVisitor.DEFAULT, null);
diff --git a/querydsl-core/src/main/java/com/querydsl/core/types/MappingProjection.java b/querydsl-core/src/main/java/com/querydsl/core/types/MappingProjection.java
index 47ed3b9cc..59eccacdf 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/types/MappingProjection.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/types/MappingProjection.java
@@ -13,9 +13,10 @@
  */
 package com.querydsl.core.types;
 
+import java.util.List;
+
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.Immutable;
-import java.util.List;
 
 import com.querydsl.core.Tuple;
 
@@ -66,6 +67,7 @@ public abstract class MappingProjection<T> extends FactoryExpressionBase<T> {
         qTuple = new QTuple(ExpressionUtils.distinctList(args));
     }
 
+    @Override
     public T newInstance(Object... values) {
         return map(qTuple.newInstance(values));
     }
@@ -78,10 +80,12 @@ public abstract class MappingProjection<T> extends FactoryExpressionBase<T> {
      */
     protected abstract T map(Tuple row);
 
+    @Override
     public List<Expression<?>> getArgs() {
         return qTuple.getArgs();
     }
 
+    @Override
     public <R, C> R accept(Visitor<R, C> v, @Nullable C context) {
         return v.visit(this, context);
     }
diff --git a/querydsl-core/src/main/java/com/querydsl/core/types/MutableExpressionBase.java b/querydsl-core/src/main/java/com/querydsl/core/types/MutableExpressionBase.java
index c6dc77ca1..9840df232 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/types/MutableExpressionBase.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/types/MutableExpressionBase.java
@@ -30,11 +30,13 @@ public abstract class MutableExpressionBase<T> implements Expression<T> {
     public MutableExpressionBase(Class<? extends T> type) {
         this.type = type;
     }
-    
+
+    @Override
     public final Class<? extends T> getType() {
         return type;
     }
-    
+
+    @Override
     public final int hashCode() {
         return accept(HashCodeVisitor.DEFAULT, null);
     }
diff --git a/querydsl-core/src/main/java/com/querydsl/core/types/Ops.java b/querydsl-core/src/main/java/com/querydsl/core/types/Ops.java
index 10218a6c7..d0227c56f 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/types/Ops.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/types/Ops.java
@@ -123,6 +123,7 @@ public enum Ops implements Operator {
         this.type = type;
     }
 
+    @Override
     public Class<?> getType() {
         return type;
     }
@@ -162,6 +163,7 @@ public enum Ops implements Operator {
             this.type = type;
         }
 
+        @Override
         public Class<?> getType() {
             return type;
         }
@@ -183,6 +185,7 @@ public enum Ops implements Operator {
             this.type = type;
         }
 
+        @Override
         public Class<?> getType() {
             return type;
         }
@@ -237,6 +240,7 @@ public enum Ops implements Operator {
             this.type = type;
         }
 
+        @Override
         public Class<?> getType() {
             return type;
         }
@@ -282,6 +286,7 @@ public enum Ops implements Operator {
             this.type = type;
         }
 
+        @Override
         public Class<?> getType() {
             return type;
         }
@@ -308,6 +313,7 @@ public enum Ops implements Operator {
             this.type = type;
         }
 
+        @Override
         public Class<?> getType() {
             return type;
         }
diff --git a/querydsl-core/src/main/java/com/querydsl/core/types/ParamExpressionImpl.java b/querydsl-core/src/main/java/com/querydsl/core/types/ParamExpressionImpl.java
index 9e74dbd79..9ca753266 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/types/ParamExpressionImpl.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/types/ParamExpressionImpl.java
@@ -64,14 +64,17 @@ public class ParamExpressionImpl<T> extends ExpressionBase<T> implements ParamEx
         }
     }
 
+    @Override
     public final String getName() {
         return name;
     }
 
+    @Override
     public final boolean isAnon() {
         return anon;
     }
 
+    @Override
     public final String getNotSetMessage() {
         if (!anon) {
             return "The parameter " + name + " needs to be set";
diff --git a/querydsl-core/src/main/java/com/querydsl/core/types/PathType.java b/querydsl-core/src/main/java/com/querydsl/core/types/PathType.java
index 2b5f4eab7..578f47106 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/types/PathType.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/types/PathType.java
@@ -67,6 +67,7 @@ public enum PathType implements Operator {
      */
     VARIABLE;
 
+    @Override
     public Class<?> getType() {
         return Object.class;
     }
diff --git a/querydsl-core/src/main/java/com/querydsl/core/types/Templates.java b/querydsl-core/src/main/java/com/querydsl/core/types/Templates.java
index 6645cd9d5..610227657 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/types/Templates.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/types/Templates.java
@@ -60,6 +60,7 @@ public class Templates {
     protected Templates(char escape) {
         this.escape = escape;
         templateFactory = new TemplateFactory(escape) {
+            @Override
             public String escapeForLike(String str) {
                 return Templates.this.escapeForLike(str);
             }
diff --git a/querydsl-core/src/main/java/com/querydsl/core/types/dsl/ListPath.java b/querydsl-core/src/main/java/com/querydsl/core/types/dsl/ListPath.java
index ace672a0d..a14890c12 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/types/dsl/ListPath.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/types/dsl/ListPath.java
@@ -109,6 +109,7 @@ public class ListPath<E, Q extends SimpleExpression<? super E>> extends Collecti
         }
     }
 
+    @Override
     public Class<E> getElementType() {
         return elementType;
     }
diff --git a/querydsl-core/src/main/java/com/querydsl/core/types/dsl/SetPath.java b/querydsl-core/src/main/java/com/querydsl/core/types/dsl/SetPath.java
index 68ae1d083..7760f08c9 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/types/dsl/SetPath.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/types/dsl/SetPath.java
@@ -74,6 +74,7 @@ public class SetPath<E, Q extends SimpleExpression<? super E>> extends Collectio
         return any;
     }
 
+    @Override
     public Class<E> getElementType() {
         return elementType;
     }
diff --git a/querydsl-core/src/main/java/com/querydsl/core/util/ResultSetAdapter.java b/querydsl-core/src/main/java/com/querydsl/core/util/ResultSetAdapter.java
index 8f5649878..a09618d39 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/util/ResultSetAdapter.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/util/ResultSetAdapter.java
@@ -47,820 +47,1011 @@ public class ResultSetAdapter implements ResultSet{
         this.rs = rs;
     }
 
+    @Override
     public boolean absolute(int row) throws SQLException {
         return rs.absolute(row);
     }
 
+    @Override
     public void afterLast() throws SQLException {
         rs.afterLast();
     }
 
+    @Override
     public void beforeFirst() throws SQLException {
         rs.beforeFirst();
     }
 
+    @Override
     public void cancelRowUpdates() throws SQLException {
         rs.cancelRowUpdates();
     }
 
+    @Override
     public void clearWarnings() throws SQLException {
         rs.clearWarnings();
     }
 
+    @Override
     public void close() throws SQLException {
         rs.close();
     }
 
+    @Override
     public void deleteRow() throws SQLException {
         rs.deleteRow();
     }
 
+    @Override
     public int findColumn(String columnLabel) throws SQLException {
         return rs.findColumn(columnLabel);
     }
 
+    @Override
     public boolean first() throws SQLException {
         return rs.first();
     }
 
+    @Override
     public Array getArray(int columnIndex) throws SQLException {
         return rs.getArray(columnIndex);
     }
 
+    @Override
     public Array getArray(String columnLabel) throws SQLException {
         return rs.getArray(columnLabel);
     }
 
+    @Override
     public InputStream getAsciiStream(int columnIndex) throws SQLException {
         return rs.getAsciiStream(columnIndex);
     }
 
+    @Override
     public InputStream getAsciiStream(String columnLabel) throws SQLException {
         return rs.getAsciiStream(columnLabel);
     }
 
+    @Override
     @SuppressWarnings("deprecation")
     public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
         return rs.getBigDecimal(columnIndex, scale);
     }
 
+    @Override
     public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
         return rs.getBigDecimal(columnIndex);
     }
 
+    @Override
     @SuppressWarnings("deprecation")
     public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
         return rs.getBigDecimal(columnLabel, scale);
     }
 
+    @Override
     public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
         return rs.getBigDecimal(columnLabel);
     }
 
+    @Override
     public InputStream getBinaryStream(int columnIndex) throws SQLException {
         return rs.getBinaryStream(columnIndex);
     }
 
+    @Override
     public InputStream getBinaryStream(String columnLabel) throws SQLException {
         return rs.getBinaryStream(columnLabel);
     }
 
+    @Override
     public Blob getBlob(int columnIndex) throws SQLException {
         return rs.getBlob(columnIndex);
     }
 
+    @Override
     public Blob getBlob(String columnLabel) throws SQLException {
         return rs.getBlob(columnLabel);
     }
 
+    @Override
     public boolean getBoolean(int columnIndex) throws SQLException {
         return rs.getBoolean(columnIndex);
     }
 
+    @Override
     public boolean getBoolean(String columnLabel) throws SQLException {
         return rs.getBoolean(columnLabel);
     }
 
+    @Override
     public byte getByte(int columnIndex) throws SQLException {
         return rs.getByte(columnIndex);
     }
 
+    @Override
     public byte getByte(String columnLabel) throws SQLException {
         return rs.getByte(columnLabel);
     }
 
+    @Override
     public byte[] getBytes(int columnIndex) throws SQLException {
         return rs.getBytes(columnIndex);
     }
 
+    @Override
     public byte[] getBytes(String columnLabel) throws SQLException {
         return rs.getBytes(columnLabel);
     }
 
+    @Override
     public Reader getCharacterStream(int columnIndex) throws SQLException {
         return rs.getCharacterStream(columnIndex);
     }
 
+    @Override
     public Reader getCharacterStream(String columnLabel) throws SQLException {
         return rs.getCharacterStream(columnLabel);
     }
 
+    @Override
     public Clob getClob(int columnIndex) throws SQLException {
         return rs.getClob(columnIndex);
     }
 
+    @Override
     public Clob getClob(String columnLabel) throws SQLException {
         return rs.getClob(columnLabel);
     }
 
+    @Override
     public int getConcurrency() throws SQLException {
         return rs.getConcurrency();
     }
 
+    @Override
     public String getCursorName() throws SQLException {
         return rs.getCursorName();
     }
 
+    @Override
     public Date getDate(int columnIndex, Calendar cal) throws SQLException {
         return rs.getDate(columnIndex, cal);
     }
 
+    @Override
     public Date getDate(int columnIndex) throws SQLException {
         return rs.getDate(columnIndex);
     }
 
+    @Override
     public Date getDate(String columnLabel, Calendar cal) throws SQLException {
         return rs.getDate(columnLabel, cal);
     }
 
+    @Override
     public Date getDate(String columnLabel) throws SQLException {
         return rs.getDate(columnLabel);
     }
 
+    @Override
     public double getDouble(int columnIndex) throws SQLException {
         return rs.getDouble(columnIndex);
     }
 
+    @Override
     public double getDouble(String columnLabel) throws SQLException {
         return rs.getDouble(columnLabel);
     }
 
+    @Override
     public int getFetchDirection() throws SQLException {
         return rs.getFetchDirection();
     }
 
+    @Override
     public int getFetchSize() throws SQLException {
         return rs.getFetchSize();
     }
 
+    @Override
     public float getFloat(int columnIndex) throws SQLException {
         return rs.getFloat(columnIndex);
     }
 
+    @Override
     public float getFloat(String columnLabel) throws SQLException {
         return rs.getFloat(columnLabel);
     }
 
+    @Override
     public int getHoldability() throws SQLException {
         return rs.getHoldability();
     }
 
+    @Override
     public int getInt(int columnIndex) throws SQLException {
         return rs.getInt(columnIndex);
     }
 
+    @Override
     public int getInt(String columnLabel) throws SQLException {
         return rs.getInt(columnLabel);
     }
 
+    @Override
     public long getLong(int columnIndex) throws SQLException {
         return rs.getLong(columnIndex);
     }
 
+    @Override
     public long getLong(String columnLabel) throws SQLException {
         return rs.getLong(columnLabel);
     }
 
+    @Override
     public ResultSetMetaData getMetaData() throws SQLException {
         return rs.getMetaData();
     }
 
+    @Override
     public Reader getNCharacterStream(int columnIndex) throws SQLException {
         return rs.getNCharacterStream(columnIndex);
     }
 
+    @Override
     public Reader getNCharacterStream(String columnLabel) throws SQLException {
         return rs.getNCharacterStream(columnLabel);
     }
 
+    @Override
     public NClob getNClob(int columnIndex) throws SQLException {
         return rs.getNClob(columnIndex);
     }
 
+    @Override
     public NClob getNClob(String columnLabel) throws SQLException {
         return rs.getNClob(columnLabel);
     }
 
+    @Override
     public String getNString(int columnIndex) throws SQLException {
         return rs.getNString(columnIndex);
     }
 
+    @Override
     public String getNString(String columnLabel) throws SQLException {
         return rs.getNString(columnLabel);
     }
 
+    @Override
     public Object getObject(int columnIndex, Map<String, Class<?>> map)
             throws SQLException {
         return rs.getObject(columnIndex, map);
     }
 
+    @Override
     public Object getObject(int columnIndex) throws SQLException {
         return rs.getObject(columnIndex);
     }
-    
+
+    @Override
     public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
         // this getObject(int, Class) is available in JDK 7
         return (T)rs.getObject(columnIndex);
     }
 
+    @Override
     public Object getObject(String columnLabel, Map<String, Class<?>> map)
             throws SQLException {
         return rs.getObject(columnLabel, map);
     }
 
+    @Override
     public Object getObject(String columnLabel) throws SQLException {
         return rs.getObject(columnLabel);
     }
-    
+
+    @Override
     public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
         // this getObject(String, Class) is available in JDK 7
         return (T)rs.getObject(columnLabel);
     }
 
+    @Override
     public Ref getRef(int columnIndex) throws SQLException {
         return rs.getRef(columnIndex);
     }
 
+    @Override
     public Ref getRef(String columnLabel) throws SQLException {
         return rs.getRef(columnLabel);
     }
 
+    @Override
     public int getRow() throws SQLException {
         return rs.getRow();
     }
 
+    @Override
     public RowId getRowId(int columnIndex) throws SQLException {
         return rs.getRowId(columnIndex);
     }
 
+    @Override
     public RowId getRowId(String columnLabel) throws SQLException {
         return rs.getRowId(columnLabel);
     }
 
+    @Override
     public short getShort(int columnIndex) throws SQLException {
         return rs.getShort(columnIndex);
     }
 
+    @Override
     public short getShort(String columnLabel) throws SQLException {
         return rs.getShort(columnLabel);
     }
 
+    @Override
     public SQLXML getSQLXML(int columnIndex) throws SQLException {
         return rs.getSQLXML(columnIndex);
     }
 
+    @Override
     public SQLXML getSQLXML(String columnLabel) throws SQLException {
         return rs.getSQLXML(columnLabel);
     }
 
+    @Override
     public Statement getStatement() throws SQLException {
         return rs.getStatement();
     }
 
+    @Override
     public String getString(int columnIndex) throws SQLException {
         return rs.getString(columnIndex);
     }
 
+    @Override
     public String getString(String columnLabel) throws SQLException {
         return rs.getString(columnLabel);
     }
 
+    @Override
     public Time getTime(int columnIndex, Calendar cal) throws SQLException {
         return rs.getTime(columnIndex, cal);
     }
 
+    @Override
     public Time getTime(int columnIndex) throws SQLException {
         return rs.getTime(columnIndex);
     }
 
+    @Override
     public Time getTime(String columnLabel, Calendar cal) throws SQLException {
         return rs.getTime(columnLabel, cal);
     }
 
+    @Override
     public Time getTime(String columnLabel) throws SQLException {
         return rs.getTime(columnLabel);
     }
 
+    @Override
     public Timestamp getTimestamp(int columnIndex, Calendar cal)
             throws SQLException {
         return rs.getTimestamp(columnIndex, cal);
     }
 
+    @Override
     public Timestamp getTimestamp(int columnIndex) throws SQLException {
         return rs.getTimestamp(columnIndex);
     }
 
+    @Override
     public Timestamp getTimestamp(String columnLabel, Calendar cal)
             throws SQLException {
         return rs.getTimestamp(columnLabel, cal);
     }
 
+    @Override
     public Timestamp getTimestamp(String columnLabel) throws SQLException {
         return rs.getTimestamp(columnLabel);
     }
 
+    @Override
     public int getType() throws SQLException {
         return rs.getType();
     }
 
+    @Override
     @SuppressWarnings("deprecation")
     public InputStream getUnicodeStream(int columnIndex) throws SQLException {
         return rs.getUnicodeStream(columnIndex);
     }
 
+    @Override
     @SuppressWarnings("deprecation")
     public InputStream getUnicodeStream(String columnLabel) throws SQLException {
         return rs.getUnicodeStream(columnLabel);
     }
 
+    @Override
     public URL getURL(int columnIndex) throws SQLException {
         return rs.getURL(columnIndex);
     }
 
+    @Override
     public URL getURL(String columnLabel) throws SQLException {
         return rs.getURL(columnLabel);
     }
 
+    @Override
     public SQLWarning getWarnings() throws SQLException {
         return rs.getWarnings();
     }
 
+    @Override
     public void insertRow() throws SQLException {
         rs.insertRow();
     }
 
+    @Override
     public boolean isAfterLast() throws SQLException {
         return rs.isAfterLast();
     }
 
+    @Override
     public boolean isBeforeFirst() throws SQLException {
         return rs.isBeforeFirst();
     }
 
+    @Override
     public boolean isClosed() throws SQLException {
         return rs.isClosed();
     }
 
+    @Override
     public boolean isFirst() throws SQLException {
         return rs.isFirst();
     }
 
+    @Override
     public boolean isLast() throws SQLException {
         return rs.isLast();
     }
 
+    @Override
     public boolean isWrapperFor(Class<?> iface) throws SQLException {
         return rs.isWrapperFor(iface);
     }
 
+    @Override
     public boolean last() throws SQLException {
         return rs.last();
     }
 
+    @Override
     public void moveToCurrentRow() throws SQLException {
         rs.moveToCurrentRow();
     }
 
+    @Override
     public void moveToInsertRow() throws SQLException {
         rs.moveToInsertRow();
     }
 
+    @Override
     public boolean next() throws SQLException {
         return rs.next();
     }
 
+    @Override
     public boolean previous() throws SQLException {
         return rs.previous();
     }
 
+    @Override
     public void refreshRow() throws SQLException {
         rs.refreshRow();
     }
 
+    @Override
     public boolean relative(int rows) throws SQLException {
         return rs.relative(rows);
     }
 
+    @Override
     public boolean rowDeleted() throws SQLException {
         return rs.rowDeleted();
     }
 
+    @Override
     public boolean rowInserted() throws SQLException {
         return rs.rowInserted();
     }
 
+    @Override
     public boolean rowUpdated() throws SQLException {
         return rs.rowUpdated();
     }
 
+    @Override
     public void setFetchDirection(int direction) throws SQLException {
         rs.setFetchDirection(direction);
     }
 
+    @Override
     public void setFetchSize(int rows) throws SQLException {
         rs.setFetchSize(rows);
     }
 
+    @Override
     public <T> T unwrap(Class<T> iface) throws SQLException {
         return rs.unwrap(iface);
     }
 
+    @Override
     public void updateArray(int columnIndex, Array x) throws SQLException {
         rs.updateArray(columnIndex, x);
     }
 
+    @Override
     public void updateArray(String columnLabel, Array x) throws SQLException {
         rs.updateArray(columnLabel, x);
     }
 
+    @Override
     public void updateAsciiStream(int columnIndex, InputStream x, int length)
             throws SQLException {
         rs.updateAsciiStream(columnIndex, x, length);
     }
 
+    @Override
     public void updateAsciiStream(int columnIndex, InputStream x, long length)
             throws SQLException {
         rs.updateAsciiStream(columnIndex, x, length);
     }
 
+    @Override
     public void updateAsciiStream(int columnIndex, InputStream x)
             throws SQLException {
         rs.updateAsciiStream(columnIndex, x);
     }
 
+    @Override
     public void updateAsciiStream(String columnLabel, InputStream x, int length)
             throws SQLException {
         rs.updateAsciiStream(columnLabel, x, length);
     }
 
+    @Override
     public void updateAsciiStream(String columnLabel, InputStream x, long length)
             throws SQLException {
         rs.updateAsciiStream(columnLabel, x, length);
     }
 
+    @Override
     public void updateAsciiStream(String columnLabel, InputStream x)
             throws SQLException {
         rs.updateAsciiStream(columnLabel, x);
     }
 
+    @Override
     public void updateBigDecimal(int columnIndex, BigDecimal x)
             throws SQLException {
         rs.updateBigDecimal(columnIndex, x);
     }
 
+    @Override
     public void updateBigDecimal(String columnLabel, BigDecimal x)
             throws SQLException {
         rs.updateBigDecimal(columnLabel, x);
     }
 
+    @Override
     public void updateBinaryStream(int columnIndex, InputStream x, int length)
             throws SQLException {
         rs.updateBinaryStream(columnIndex, x, length);
     }
 
+    @Override
     public void updateBinaryStream(int columnIndex, InputStream x, long length)
             throws SQLException {
         rs.updateBinaryStream(columnIndex, x, length);
     }
 
+    @Override
     public void updateBinaryStream(int columnIndex, InputStream x)
             throws SQLException {
         rs.updateBinaryStream(columnIndex, x);
     }
 
+    @Override
     public void updateBinaryStream(String columnLabel, InputStream x, int length)
             throws SQLException {
         rs.updateBinaryStream(columnLabel, x, length);
     }
 
+    @Override
     public void updateBinaryStream(String columnLabel, InputStream x,
             long length) throws SQLException {
         rs.updateBinaryStream(columnLabel, x, length);
     }
 
+    @Override
     public void updateBinaryStream(String columnLabel, InputStream x)
             throws SQLException {
         rs.updateBinaryStream(columnLabel, x);
     }
 
+    @Override
     public void updateBlob(int columnIndex, Blob x) throws SQLException {
         rs.updateBlob(columnIndex, x);
     }
 
+    @Override
     public void updateBlob(int columnIndex, InputStream inputStream, long length)
             throws SQLException {
         rs.updateBlob(columnIndex, inputStream, length);
     }
 
+    @Override
     public void updateBlob(int columnIndex, InputStream inputStream)
             throws SQLException {
         rs.updateBlob(columnIndex, inputStream);
     }
 
+    @Override
     public void updateBlob(String columnLabel, Blob x) throws SQLException {
         rs.updateBlob(columnLabel, x);
     }
 
+    @Override
     public void updateBlob(String columnLabel, InputStream inputStream,
             long length) throws SQLException {
         rs.updateBlob(columnLabel, inputStream, length);
     }
 
+    @Override
     public void updateBlob(String columnLabel, InputStream inputStream)
             throws SQLException {
         rs.updateBlob(columnLabel, inputStream);
     }
 
+    @Override
     public void updateBoolean(int columnIndex, boolean x) throws SQLException {
         rs.updateBoolean(columnIndex, x);
     }
 
+    @Override
     public void updateBoolean(String columnLabel, boolean x)
             throws SQLException {
         rs.updateBoolean(columnLabel, x);
     }
 
+    @Override
     public void updateByte(int columnIndex, byte x) throws SQLException {
         rs.updateByte(columnIndex, x);
     }
 
+    @Override
     public void updateByte(String columnLabel, byte x) throws SQLException {
         rs.updateByte(columnLabel, x);
     }
 
+    @Override
     public void updateBytes(int columnIndex, byte[] x) throws SQLException {
         rs.updateBytes(columnIndex, x);
     }
 
+    @Override
     public void updateBytes(String columnLabel, byte[] x) throws SQLException {
         rs.updateBytes(columnLabel, x);
     }
 
+    @Override
     public void updateCharacterStream(int columnIndex, Reader x, int length)
             throws SQLException {
         rs.updateCharacterStream(columnIndex, x, length);
     }
 
+    @Override
     public void updateCharacterStream(int columnIndex, Reader x, long length)
             throws SQLException {
         rs.updateCharacterStream(columnIndex, x, length);
     }
 
+    @Override
     public void updateCharacterStream(int columnIndex, Reader x)
             throws SQLException {
         rs.updateCharacterStream(columnIndex, x);
     }
 
+    @Override
     public void updateCharacterStream(String columnLabel, Reader reader,
             int length) throws SQLException {
         rs.updateCharacterStream(columnLabel, reader, length);
     }
 
+    @Override
     public void updateCharacterStream(String columnLabel, Reader reader,
             long length) throws SQLException {
         rs.updateCharacterStream(columnLabel, reader, length);
     }
 
+    @Override
     public void updateCharacterStream(String columnLabel, Reader reader)
             throws SQLException {
         rs.updateCharacterStream(columnLabel, reader);
     }
 
+    @Override
     public void updateClob(int columnIndex, Clob x) throws SQLException {
         rs.updateClob(columnIndex, x);
     }
 
+    @Override
     public void updateClob(int columnIndex, Reader reader, long length)
             throws SQLException {
         rs.updateClob(columnIndex, reader, length);
     }
 
+    @Override
     public void updateClob(int columnIndex, Reader reader) throws SQLException {
         rs.updateClob(columnIndex, reader);
     }
 
+    @Override
     public void updateClob(String columnLabel, Clob x) throws SQLException {
         rs.updateClob(columnLabel, x);
     }
 
+    @Override
     public void updateClob(String columnLabel, Reader reader, long length)
             throws SQLException {
         rs.updateClob(columnLabel, reader, length);
     }
 
+    @Override
     public void updateClob(String columnLabel, Reader reader)
             throws SQLException {
         rs.updateClob(columnLabel, reader);
     }
 
+    @Override
     public void updateDate(int columnIndex, Date x) throws SQLException {
         rs.updateDate(columnIndex, x);
     }
 
+    @Override
     public void updateDate(String columnLabel, Date x) throws SQLException {
         rs.updateDate(columnLabel, x);
     }
 
+    @Override
     public void updateDouble(int columnIndex, double x) throws SQLException {
         rs.updateDouble(columnIndex, x);
     }
 
+    @Override
     public void updateDouble(String columnLabel, double x) throws SQLException {
         rs.updateDouble(columnLabel, x);
     }
 
+    @Override
     public void updateFloat(int columnIndex, float x) throws SQLException {
         rs.updateFloat(columnIndex, x);
     }
 
+    @Override
     public void updateFloat(String columnLabel, float x) throws SQLException {
         rs.updateFloat(columnLabel, x);
     }
 
+    @Override
     public void updateInt(int columnIndex, int x) throws SQLException {
         rs.updateInt(columnIndex, x);
     }
 
+    @Override
     public void updateInt(String columnLabel, int x) throws SQLException {
         rs.updateInt(columnLabel, x);
     }
 
+    @Override
     public void updateLong(int columnIndex, long x) throws SQLException {
         rs.updateLong(columnIndex, x);
     }
 
+    @Override
     public void updateLong(String columnLabel, long x) throws SQLException {
         rs.updateLong(columnLabel, x);
     }
 
+    @Override
     public void updateNCharacterStream(int columnIndex, Reader x, long length)
             throws SQLException {
         rs.updateNCharacterStream(columnIndex, x, length);
     }
 
+    @Override
     public void updateNCharacterStream(int columnIndex, Reader x)
             throws SQLException {
         rs.updateNCharacterStream(columnIndex, x);
     }
 
+    @Override
     public void updateNCharacterStream(String columnLabel, Reader reader,
             long length) throws SQLException {
         rs.updateNCharacterStream(columnLabel, reader, length);
     }
 
+    @Override
     public void updateNCharacterStream(String columnLabel, Reader reader)
             throws SQLException {
         rs.updateNCharacterStream(columnLabel, reader);
     }
 
+    @Override
     public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
         rs.updateNClob(columnIndex, nClob);
     }
 
+    @Override
     public void updateNClob(int columnIndex, Reader reader, long length)
             throws SQLException {
         rs.updateNClob(columnIndex, reader, length);
     }
 
+    @Override
     public void updateNClob(int columnIndex, Reader reader) throws SQLException {
         rs.updateNClob(columnIndex, reader);
     }
 
+    @Override
     public void updateNClob(String columnLabel, NClob nClob)
             throws SQLException {
         rs.updateNClob(columnLabel, nClob);
     }
 
+    @Override
     public void updateNClob(String columnLabel, Reader reader, long length)
             throws SQLException {
         rs.updateNClob(columnLabel, reader, length);
     }
 
+    @Override
     public void updateNClob(String columnLabel, Reader reader)
             throws SQLException {
         rs.updateNClob(columnLabel, reader);
     }
 
+    @Override
     public void updateNString(int columnIndex, String nString)
             throws SQLException {
         rs.updateNString(columnIndex, nString);
     }
 
+    @Override
     public void updateNString(String columnLabel, String nString)
             throws SQLException {
         rs.updateNString(columnLabel, nString);
     }
 
+    @Override
     public void updateNull(int columnIndex) throws SQLException {
         rs.updateNull(columnIndex);
     }
 
+    @Override
     public void updateNull(String columnLabel) throws SQLException {
         rs.updateNull(columnLabel);
     }
 
+    @Override
     public void updateObject(int columnIndex, Object x, int scaleOrLength)
             throws SQLException {
         rs.updateObject(columnIndex, x, scaleOrLength);
     }
 
+    @Override
     public void updateObject(int columnIndex, Object x) throws SQLException {
         rs.updateObject(columnIndex, x);
     }
 
+    @Override
     public void updateObject(String columnLabel, Object x, int scaleOrLength)
             throws SQLException {
         rs.updateObject(columnLabel, x, scaleOrLength);
     }
 
+    @Override
     public void updateObject(String columnLabel, Object x) throws SQLException {
         rs.updateObject(columnLabel, x);
     }
 
+    @Override
     public void updateRef(int columnIndex, Ref x) throws SQLException {
         rs.updateRef(columnIndex, x);
     }
 
+    @Override
     public void updateRef(String columnLabel, Ref x) throws SQLException {
         rs.updateRef(columnLabel, x);
     }
 
+    @Override
     public void updateRow() throws SQLException {
         rs.updateRow();
     }
 
+    @Override
     public void updateRowId(int columnIndex, RowId x) throws SQLException {
         rs.updateRowId(columnIndex, x);
     }
 
+    @Override
     public void updateRowId(String columnLabel, RowId x) throws SQLException {
         rs.updateRowId(columnLabel, x);
     }
 
+    @Override
     public void updateShort(int columnIndex, short x) throws SQLException {
         rs.updateShort(columnIndex, x);
     }
 
+    @Override
     public void updateShort(String columnLabel, short x) throws SQLException {
         rs.updateShort(columnLabel, x);
     }
 
+    @Override
     public void updateSQLXML(int columnIndex, SQLXML xmlObject)
             throws SQLException {
         rs.updateSQLXML(columnIndex, xmlObject);
     }
 
+    @Override
     public void updateSQLXML(String columnLabel, SQLXML xmlObject)
             throws SQLException {
         rs.updateSQLXML(columnLabel, xmlObject);
     }
 
+    @Override
     public void updateString(int columnIndex, String x) throws SQLException {
         rs.updateString(columnIndex, x);
     }
 
+    @Override
     public void updateString(String columnLabel, String x) throws SQLException {
         rs.updateString(columnLabel, x);
     }
 
+    @Override
     public void updateTime(int columnIndex, Time x) throws SQLException {
         rs.updateTime(columnIndex, x);
     }
 
+    @Override
     public void updateTime(String columnLabel, Time x) throws SQLException {
         rs.updateTime(columnLabel, x);
     }
 
+    @Override
     public void updateTimestamp(int columnIndex, Timestamp x)
             throws SQLException {
         rs.updateTimestamp(columnIndex, x);
     }
 
+    @Override
     public void updateTimestamp(String columnLabel, Timestamp x)
             throws SQLException {
         rs.updateTimestamp(columnLabel, x);
     }
 
+    @Override
     public boolean wasNull() throws SQLException {
         return rs.wasNull();
     }
diff --git a/querydsl-jdo/src/main/java/com/querydsl/jdo/JDOQuery.java b/querydsl-jdo/src/main/java/com/querydsl/jdo/JDOQuery.java
index ee0c49c79..8436ca730 100644
--- a/querydsl-jdo/src/main/java/com/querydsl/jdo/JDOQuery.java
+++ b/querydsl-jdo/src/main/java/com/querydsl/jdo/JDOQuery.java
@@ -87,6 +87,7 @@ public class JDOQuery<T> extends AbstractJDOQuery<T, JDOQuery<T>> {
      * @param persistenceManager PersistenceManager instance to use
      * @return cloned query
      */
+    @Override
     public JDOQuery<T> clone(PersistenceManager persistenceManager) {
         JDOQuery<T> query = new JDOQuery<T>(persistenceManager, getTemplates(),
                 getMetadata().clone(), isDetach());
diff --git a/querydsl-jdo/src/main/java/com/querydsl/jdo/JDOQueryFactory.java b/querydsl-jdo/src/main/java/com/querydsl/jdo/JDOQueryFactory.java
index 624cadf2c..b8fbcb6d4 100644
--- a/querydsl-jdo/src/main/java/com/querydsl/jdo/JDOQueryFactory.java
+++ b/querydsl-jdo/src/main/java/com/querydsl/jdo/JDOQueryFactory.java
@@ -116,6 +116,7 @@ public class JDOQueryFactory implements QueryFactory<JDOQuery<?>> {
         return query().from(from);
     }
 
+    @Override
     public JDOQuery<?> query() {
         return new JDOQuery<Void>(persistenceManager.get());
     }
diff --git a/querydsl-jpa/src/main/java/com/querydsl/jpa/JPAListAccessVisitor.java b/querydsl-jpa/src/main/java/com/querydsl/jpa/JPAListAccessVisitor.java
index fbf177a5b..d0836d3d0 100644
--- a/querydsl-jpa/src/main/java/com/querydsl/jpa/JPAListAccessVisitor.java
+++ b/querydsl-jpa/src/main/java/com/querydsl/jpa/JPAListAccessVisitor.java
@@ -34,6 +34,7 @@ class JPAListAccessVisitor extends ReplaceVisitor<Void> {
         this.metadata = metadata;
     }
 
+    @Override
     public Expression<?> visit(Path<?> expr, @Nullable Void context) {
         expr = (Path<?>) super.visit(expr, null);
         PathMetadata pathMetadata = expr.getMetadata();
diff --git a/querydsl-jpa/src/main/java/com/querydsl/jpa/JPAQueryBase.java b/querydsl-jpa/src/main/java/com/querydsl/jpa/JPAQueryBase.java
index 5dff701a7..545659e8b 100644
--- a/querydsl-jpa/src/main/java/com/querydsl/jpa/JPAQueryBase.java
+++ b/querydsl-jpa/src/main/java/com/querydsl/jpa/JPAQueryBase.java
@@ -56,10 +56,12 @@ public abstract class JPAQueryBase<T, Q extends JPAQueryBase<T, Q>> extends Fetc
         queryMixin.getMetadata().reset();
     }
 
+    @Override
     public Q fetchJoin() {
         return queryMixin.fetchJoin();
     }
 
+    @Override
     public Q fetchAll() {
         return queryMixin.fetchAll();
     }
@@ -67,115 +69,142 @@ public abstract class JPAQueryBase<T, Q extends JPAQueryBase<T, Q>> extends Fetc
     public Q from(EntityPath<?> arg) {
         return queryMixin.from(arg);
     }
-    
+
+    @Override
     public Q from(EntityPath<?>... args) {
         return queryMixin.from(args);
     }
 
+    @Override
     public <P> Q from(CollectionExpression<?,P> target, Path<P> alias) {
         return queryMixin.from(Expressions.as((Path)target, alias));
     }
 
+    @Override
     public <P> Q innerJoin(CollectionExpression<?,P> target) {
         return queryMixin.innerJoin(target);
     }
 
+    @Override
     public <P> Q innerJoin(CollectionExpression<?,P>target, Path<P> alias) {
         return queryMixin.innerJoin(target, alias);
     }
 
+    @Override
     public <P> Q innerJoin(EntityPath<P> target) {
         return queryMixin.innerJoin(target);
     }
 
+    @Override
     public <P> Q innerJoin(EntityPath<P> target, Path<P> alias) {
         return queryMixin.innerJoin(target, alias);
     }
 
+    @Override
     public <P> Q innerJoin(MapExpression<?,P> target) {
         return queryMixin.innerJoin(target);
     }
 
+    @Override
     public <P> Q innerJoin(MapExpression<?,P> target, Path<P> alias) {
         return queryMixin.innerJoin(target, alias);
     }
 
+    @Override
     public <P> Q join(CollectionExpression<?,P> target) {
         return queryMixin.join(target);
     }
 
+    @Override
     public <P> Q join(CollectionExpression<?,P> target, Path<P> alias) {
         return queryMixin.join(target, alias);
     }
 
+    @Override
     public <P> Q join(EntityPath<P> target) {
         return queryMixin.join(target);
     }
 
+    @Override
     public <P> Q join(EntityPath<P> target, Path<P> alias) {
         return queryMixin.join(target, alias);
     }
 
+    @Override
     public <P> Q join(MapExpression<?,P> target) {
         return queryMixin.join(target);
     }
 
+    @Override
     public <P> Q join(MapExpression<?,P> target, Path<P> alias) {
         return queryMixin.join(target, alias);
     }
 
+    @Override
     public <P> Q leftJoin(CollectionExpression<?,P> target) {
         return queryMixin.leftJoin(target);
     }
 
+    @Override
     public <P> Q leftJoin(CollectionExpression<?,P> target, Path<P> alias) {
         return queryMixin.leftJoin(target, alias);
     }
 
+    @Override
     public <P> Q leftJoin(EntityPath<P> target) {
         return queryMixin.leftJoin(target);
     }
 
+    @Override
     public <P> Q leftJoin(EntityPath<P> target, Path<P> alias) {
         return queryMixin.leftJoin(target, alias);
     }
 
+    @Override
     public <P> Q leftJoin(MapExpression<?,P> target) {
         return queryMixin.leftJoin(target);
     }
 
+    @Override
     public <P> Q leftJoin(MapExpression<?,P> target, Path<P> alias) {
         return queryMixin.leftJoin(target, alias);
     }
 
+    @Override
     public <P> Q rightJoin(CollectionExpression<?,P> target) {
         return queryMixin.rightJoin(target);
     }
 
+    @Override
     public <P> Q rightJoin(CollectionExpression<?,P> target, Path<P> alias) {
         return queryMixin.rightJoin(target, alias);
     }
 
+    @Override
     public <P> Q rightJoin(EntityPath<P> target) {
         return queryMixin.rightJoin(target);
     }
 
+    @Override
     public <P> Q rightJoin(EntityPath<P> target, Path<P> alias) {
         return queryMixin.rightJoin(target, alias);
     }
 
+    @Override
     public <P> Q rightJoin(MapExpression<?,P> target) {
         return queryMixin.rightJoin(target);
     }
 
+    @Override
     public <P> Q rightJoin(MapExpression<?,P> target, Path<P> alias) {
         return queryMixin.rightJoin(target, alias);
     }
-    
+
     public Q on(Predicate condition) {
         return queryMixin.on(condition);
     }
-    
+
+    @Override
     public Q on(Predicate... conditions) {
         return queryMixin.on(conditions);
     }
@@ -187,6 +216,7 @@ public abstract class JPAQueryBase<T, Q extends JPAQueryBase<T, Q>> extends Fetc
         return serializer.toString().trim();
     }
 
+    @Override
     public abstract Q clone();
 
 }
diff --git a/querydsl-jpa/src/main/java/com/querydsl/jpa/JPAQueryMixin.java b/querydsl-jpa/src/main/java/com/querydsl/jpa/JPAQueryMixin.java
index 86cb576e9..4a7aaca63 100644
--- a/querydsl-jpa/src/main/java/com/querydsl/jpa/JPAQueryMixin.java
+++ b/querydsl-jpa/src/main/java/com/querydsl/jpa/JPAQueryMixin.java
@@ -52,9 +52,11 @@ public class JPAQueryMixin<T> extends QueryMixin<T> {
     private final JPACollectionAnyVisitor collectionAnyVisitor;
 
     private final ReplaceVisitor<Void> replaceVisitor =  new ReplaceVisitor<Void>() {
+        @Override
         public Expression<?> visit(Path<?> expr, Void context) {
             return convertPathForOrder(expr);
         }
+        @Override
         public Expression<?> visit(SubQueryExpression<?> expr, @Nullable Void context) {
             // don't shorten paths inside subquery expressions
             return expr;
diff --git a/querydsl-jpa/src/main/java/com/querydsl/jpa/JPQLOps.java b/querydsl-jpa/src/main/java/com/querydsl/jpa/JPQLOps.java
index edb43b990..8d6d38947 100644
--- a/querydsl-jpa/src/main/java/com/querydsl/jpa/JPQLOps.java
+++ b/querydsl-jpa/src/main/java/com/querydsl/jpa/JPQLOps.java
@@ -37,6 +37,7 @@ public enum JPQLOps implements Operator {
         this.type = type;
     }
 
+    @Override
     public Class<?> getType() {
         return type;
     }
diff --git a/querydsl-jpa/src/main/java/com/querydsl/jpa/hibernate/AbstractHibernateQuery.java b/querydsl-jpa/src/main/java/com/querydsl/jpa/hibernate/AbstractHibernateQuery.java
index db87360fe..13f41c496 100644
--- a/querydsl-jpa/src/main/java/com/querydsl/jpa/hibernate/AbstractHibernateQuery.java
+++ b/querydsl-jpa/src/main/java/com/querydsl/jpa/hibernate/AbstractHibernateQuery.java
@@ -210,6 +210,7 @@ public abstract class AbstractHibernateQuery<T, Q extends AbstractHibernateQuery
         MDC.remove(MDC_PARAMETERS);
     }
 
+    @Override
     protected void reset() {
         super.reset();
         cleanupMDC();
@@ -333,7 +334,8 @@ public abstract class AbstractHibernateQuery<T, Q extends AbstractHibernateQuery
             reset();
         }
     }
-    
+
+    @Override
     protected JPQLSerializer createSerializer() {
         return new JPQLSerializer(getTemplates());
     }
@@ -375,6 +377,7 @@ public abstract class AbstractHibernateQuery<T, Q extends AbstractHibernateQuery
      *
      * @return closed query
      */
+    @Override
     public Q clone() {
         return this.clone(this.session);
     }
diff --git a/querydsl-jpa/src/main/java/com/querydsl/jpa/hibernate/sql/AbstractHibernateSQLQuery.java b/querydsl-jpa/src/main/java/com/querydsl/jpa/hibernate/sql/AbstractHibernateSQLQuery.java
index 3b588311c..2a7b835b0 100644
--- a/querydsl-jpa/src/main/java/com/querydsl/jpa/hibernate/sql/AbstractHibernateSQLQuery.java
+++ b/querydsl-jpa/src/main/java/com/querydsl/jpa/hibernate/sql/AbstractHibernateSQLQuery.java
@@ -280,7 +280,8 @@ public abstract class AbstractHibernateSQLQuery<T, Q extends AbstractHibernateSQ
         this.timeout = timeout;
         return (Q)this;
     }
-    
+
+    @Override
     protected void clone(Q query) {
         super.clone(query);
         cacheable = query.cacheable;
@@ -289,13 +290,13 @@ public abstract class AbstractHibernateSQLQuery<T, Q extends AbstractHibernateSQ
         readOnly = query.readOnly;
         timeout = query.timeout;
     }
-    
+
     protected abstract Q clone(SessionHolder session);
 
     public Q clone(Session session) {
         return this.clone(new DefaultSessionHolder(session));
-    }   
-    
+    }
+
     public Q clone(StatelessSession statelessSession) {
         return this.clone(new StatelessSessionHolder(statelessSession));
     }
diff --git a/querydsl-jpa/src/main/java/com/querydsl/jpa/impl/AbstractJPAQuery.java b/querydsl-jpa/src/main/java/com/querydsl/jpa/impl/AbstractJPAQuery.java
index ba81915a2..6deb5bb16 100644
--- a/querydsl-jpa/src/main/java/com/querydsl/jpa/impl/AbstractJPAQuery.java
+++ b/querydsl-jpa/src/main/java/com/querydsl/jpa/impl/AbstractJPAQuery.java
@@ -246,6 +246,7 @@ public abstract class AbstractJPAQuery<T, Q extends AbstractJPAQuery<T, Q>> exte
 
     @Nullable
     @SuppressWarnings("unchecked")
+    @Override
     public T fetchOne() {
         try{
             Query query = createQuery(getMetadata().getModifiers(), false);
@@ -313,6 +314,7 @@ public abstract class AbstractJPAQuery<T, Q extends AbstractJPAQuery<T, Q>> exte
      *
      * @return cloned query
      */
+    @Override
     public Q clone() {
         return clone(entityManager, getTemplates());
     }
diff --git a/querydsl-lucene3/src/main/java/com/querydsl/lucene3/LuceneOps.java b/querydsl-lucene3/src/main/java/com/querydsl/lucene3/LuceneOps.java
index 22a106805..5d9c3f143 100644
--- a/querydsl-lucene3/src/main/java/com/querydsl/lucene3/LuceneOps.java
+++ b/querydsl-lucene3/src/main/java/com/querydsl/lucene3/LuceneOps.java
@@ -32,6 +32,7 @@ public enum LuceneOps implements Operator {
         this.type = type;
     }
 
+    @Override
     public Class<?> getType() {
         return type;
     }
diff --git a/querydsl-lucene4/src/main/java/com/querydsl/lucene4/LuceneOps.java b/querydsl-lucene4/src/main/java/com/querydsl/lucene4/LuceneOps.java
index 7565e400d..52c7b5fd8 100644
--- a/querydsl-lucene4/src/main/java/com/querydsl/lucene4/LuceneOps.java
+++ b/querydsl-lucene4/src/main/java/com/querydsl/lucene4/LuceneOps.java
@@ -32,6 +32,7 @@ public enum LuceneOps implements Operator {
         this.type = type;
     }
 
+    @Override
     public Class<?> getType() {
         return type;
     }
diff --git a/querydsl-maven-plugin/src/main/java/com/querydsl/maven/MetadataExportMojo.java b/querydsl-maven-plugin/src/main/java/com/querydsl/maven/MetadataExportMojo.java
index 1a0a341af..45a625c57 100644
--- a/querydsl-maven-plugin/src/main/java/com/querydsl/maven/MetadataExportMojo.java
+++ b/querydsl-maven-plugin/src/main/java/com/querydsl/maven/MetadataExportMojo.java
@@ -25,6 +25,7 @@ import com.querydsl.sql.codegen.MetaDataExporter;
  */
 public class MetadataExportMojo extends AbstractMetaDataExportMojo{
 
+    @Override
     protected boolean isForTest() {
         return false;
     }
diff --git a/querydsl-maven-plugin/src/main/java/com/querydsl/maven/TestMetadataExportMojo.java b/querydsl-maven-plugin/src/main/java/com/querydsl/maven/TestMetadataExportMojo.java
index b2c3b8404..5f4ecde71 100644
--- a/querydsl-maven-plugin/src/main/java/com/querydsl/maven/TestMetadataExportMojo.java
+++ b/querydsl-maven-plugin/src/main/java/com/querydsl/maven/TestMetadataExportMojo.java
@@ -24,6 +24,7 @@ import com.querydsl.sql.codegen.MetaDataExporter;
  */
 public class TestMetadataExportMojo extends AbstractMetaDataExportMojo{
 
+    @Override
     protected boolean isForTest() {
         return true;
     }
diff --git a/querydsl-mongodb/src/main/java/com/querydsl/mongodb/MongodbOps.java b/querydsl-mongodb/src/main/java/com/querydsl/mongodb/MongodbOps.java
index b83f54bb0..ebcedf348 100644
--- a/querydsl-mongodb/src/main/java/com/querydsl/mongodb/MongodbOps.java
+++ b/querydsl-mongodb/src/main/java/com/querydsl/mongodb/MongodbOps.java
@@ -31,6 +31,7 @@ public enum MongodbOps implements Operator {
         this.type = type;
     }
 
+    @Override
     public Class<?> getType() {
         return type;
     }
diff --git a/querydsl-spatial/src/main/java/com/querydsl/spatial/SpatialOps.java b/querydsl-spatial/src/main/java/com/querydsl/spatial/SpatialOps.java
index 07b296577..9fb2c381c 100644
--- a/querydsl-spatial/src/main/java/com/querydsl/spatial/SpatialOps.java
+++ b/querydsl-spatial/src/main/java/com/querydsl/spatial/SpatialOps.java
@@ -126,6 +126,7 @@ public enum SpatialOps implements Operator {
         this.type = type;
     }
 
+    @Override
     public Class<?> getType() {
         return type;
     }
diff --git a/querydsl-sql-codegen/src/main/java/com/querydsl/sql/codegen/support/ForeignKeyData.java b/querydsl-sql-codegen/src/main/java/com/querydsl/sql/codegen/support/ForeignKeyData.java
index a3f728dda..81ab82fdd 100644
--- a/querydsl-sql-codegen/src/main/java/com/querydsl/sql/codegen/support/ForeignKeyData.java
+++ b/querydsl-sql-codegen/src/main/java/com/querydsl/sql/codegen/support/ForeignKeyData.java
@@ -52,6 +52,7 @@ public class ForeignKeyData implements KeyData {
         parentColumns.add(parentColumn);
     }
 
+    @Override
     public String getName() {
         return name;
     }
@@ -61,19 +62,23 @@ public class ForeignKeyData implements KeyData {
         return schema;
     }
 
+    @Override
     public String getTable() {
         return table;
     }
 
+    @Override
     public List<String> getForeignColumns() {
         return foreignColumns;
     }
 
+    @Override
     public List<String> getParentColumns() {
         return parentColumns;
     }
 
     @Nullable
+    @Override
     public Type getType() {
         return type;
     }
diff --git a/querydsl-sql-codegen/src/main/java/com/querydsl/sql/codegen/support/InverseForeignKeyData.java b/querydsl-sql-codegen/src/main/java/com/querydsl/sql/codegen/support/InverseForeignKeyData.java
index 4017d0c8b..3d403612b 100644
--- a/querydsl-sql-codegen/src/main/java/com/querydsl/sql/codegen/support/InverseForeignKeyData.java
+++ b/querydsl-sql-codegen/src/main/java/com/querydsl/sql/codegen/support/InverseForeignKeyData.java
@@ -52,6 +52,7 @@ public class InverseForeignKeyData implements KeyData{
         parentColumns.add(parentColumn);
     }
 
+    @Override
     public String getName() {
         return name;
     }
@@ -61,19 +62,23 @@ public class InverseForeignKeyData implements KeyData{
         return schema;
     }
 
+    @Override
     public String getTable() {
         return table;
     }
-    
+
+    @Override
     public List<String> getForeignColumns() {
         return foreignColumns;
     }
 
+    @Override
     public List<String> getParentColumns() {
         return parentColumns;
     }
 
     @Nullable
+    @Override
     public Type getType() {
         return type;
     }
diff --git a/querydsl-sql/src/main/java/com/querydsl/sql/AbstractSQLQuery.java b/querydsl-sql/src/main/java/com/querydsl/sql/AbstractSQLQuery.java
index 3311c4867..fba61977c 100644
--- a/querydsl-sql/src/main/java/com/querydsl/sql/AbstractSQLQuery.java
+++ b/querydsl-sql/src/main/java/com/querydsl/sql/AbstractSQLQuery.java
@@ -126,6 +126,7 @@ public abstract class AbstractSQLQuery<T, Q extends AbstractSQLQuery<T, Q>> exte
         return addFlag(SQLOps.FOR_UPDATE_FLAG);
     }
 
+    @Override
     protected SQLSerializer createSerializer() {
         SQLSerializer serializer = new SQLSerializer(configuration);
         serializer.setUseLiterals(useLiterals);
diff --git a/querydsl-sql/src/main/java/com/querydsl/sql/AbstractSQLQueryFactory.java b/querydsl-sql/src/main/java/com/querydsl/sql/AbstractSQLQueryFactory.java
index 310356546..6c5a9cd9a 100644
--- a/querydsl-sql/src/main/java/com/querydsl/sql/AbstractSQLQueryFactory.java
+++ b/querydsl-sql/src/main/java/com/querydsl/sql/AbstractSQLQueryFactory.java
@@ -53,10 +53,12 @@ public abstract class AbstractSQLQueryFactory<Q extends SQLCommonQuery<?>> imple
         return (Q) query().from(from);
     }
 
+    @Override
     public final Q from(Expression<?>... args) {
         return (Q) query().from(args);
     }
 
+    @Override
     public final Q from(SubQueryExpression<?> subQuery, Path<?> alias) {
         return (Q) query().from(subQuery, alias);
     }
diff --git a/querydsl-sql/src/main/java/com/querydsl/sql/SQLOps.java b/querydsl-sql/src/main/java/com/querydsl/sql/SQLOps.java
index 9b6531deb..e05dc6b8b 100644
--- a/querydsl-sql/src/main/java/com/querydsl/sql/SQLOps.java
+++ b/querydsl-sql/src/main/java/com/querydsl/sql/SQLOps.java
@@ -83,6 +83,7 @@ public enum SQLOps implements Operator {
         this.type = type;
     }
 
+    @Override
     public Class<?> getType() {
         return type;
     }
diff --git a/querydsl-sql/src/main/java/com/querydsl/sql/types/AbstractType.java b/querydsl-sql/src/main/java/com/querydsl/sql/types/AbstractType.java
index 11f4a4364..ff5638f0c 100644
--- a/querydsl-sql/src/main/java/com/querydsl/sql/types/AbstractType.java
+++ b/querydsl-sql/src/main/java/com/querydsl/sql/types/AbstractType.java
@@ -33,6 +33,7 @@ public abstract class AbstractType<T> implements Type<T> {
         return new int[]{type};
     }
 
+    @Override
     public String getLiteral(T value) {
         return value.toString();
     }