Use simple class names

compatibility-server/src/main/java/com/vaadin/v7/data/util/BeanItem.java

 
 package com.vaadin.v7.data.util;
 
+import java.beans.IntrospectionException;
 import java.beans.PropertyDescriptor;
 import java.lang.reflect.Method;
 import java.util.Arrays;
                     pdMap.put(pd.getName(), vaadinPropertyDescriptor);
                 }
             }
-        } catch (final java.beans.IntrospectionException ignored) {
+        } catch (final IntrospectionException ignored) {
         }
 
         return pdMap;

compatibility-server/src/main/java/com/vaadin/v7/data/util/DefaultItemSorter.java

 @Deprecated
 public class DefaultItemSorter implements ItemSorter {
 
-    private java.lang.Object[] sortPropertyIds;
+    private Object[] sortPropertyIds;
     private boolean[] sortDirections;
     private Container container;
     private Comparator<Object> propertyValueComparator;

compatibility-server/src/main/java/com/vaadin/v7/data/util/MethodProperty.java

 import static com.vaadin.util.ReflectTools.convertPrimitiveType;
 
 import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Arrays;
     private static final Object[] DEFAULT_SET_ARGS = new Object[1];
 
     /* Special serialization to handle method references */
-    private void writeObject(java.io.ObjectOutputStream out)
+    private void writeObject(ObjectOutputStream out)
             throws IOException {
         out.defaultWriteObject();
         SerializerHelper.writeClass(out, type);
     }
 
     /* Special serialization to handle method references */
-    private void readObject(java.io.ObjectInputStream in)
+    private void readObject(ObjectInputStream in)
             throws IOException, ClassNotFoundException {
         in.defaultReadObject();
         try {
         getMethod = null;
         try {
             getMethod = initGetterMethod(beanPropertyName, beanClass);
-        } catch (final java.lang.NoSuchMethodException ignored) {
+        } catch (final NoSuchMethodException ignored) {
             throw new MethodException(this,
                     "Bean property " + beanPropertyName + " can not be found");
         }
         try {
             setMethod = beanClass.getMethod("set" + beanPropertyName,
                     new Class[] { returnType });
-        } catch (final java.lang.NoSuchMethodException skipped) {
+        } catch (final NoSuchMethodException skipped) {
         }
 
         // Gets the return type from get method
         try {
             getMethod = beanClass.getMethod("get" + propertyName,
                     new Class[] {});
-        } catch (final java.lang.NoSuchMethodException ignored) {
+        } catch (final NoSuchMethodException ignored) {
             try {
                 getMethod = beanClass.getMethod("is" + propertyName,
                         new Class[] {});
-            } catch (final java.lang.NoSuchMethodException ignoredAsWell) {
+            } catch (final NoSuchMethodException ignoredAsWell) {
                 getMethod = beanClass.getMethod("are" + propertyName,
                         new Class[] {});
             }

compatibility-server/src/main/java/com/vaadin/v7/data/util/MethodPropertyDescriptor.java

 package com.vaadin.v7.data.util;
 
 import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.lang.reflect.Method;
 import java.util.logging.Level;
 import java.util.logging.Logger;
     }
 
     /* Special serialization to handle method references */
-    private void writeObject(java.io.ObjectOutputStream out)
+    private void writeObject(ObjectOutputStream out)
             throws IOException {
         out.defaultWriteObject();
         SerializerHelper.writeClass(out, propertyType);
     }
 
     /* Special serialization to handle method references */
-    private void readObject(java.io.ObjectInputStream in)
+    private void readObject(ObjectInputStream in)
             throws IOException, ClassNotFoundException {
         in.defaultReadObject();
         try {

compatibility-server/src/main/java/com/vaadin/v7/data/util/NestedMethodProperty.java

 import static com.vaadin.util.ReflectTools.convertPrimitiveType;
 
 import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
     private Class<? extends T> type;
 
     /* Special serialization to handle method references */
-    private void writeObject(java.io.ObjectOutputStream out)
+    private void writeObject(ObjectOutputStream out)
             throws IOException {
         out.defaultWriteObject();
         // getMethods and setMethod are reconstructed on read based on
     }
 
     /* Special serialization to handle method references */
-    private void readObject(java.io.ObjectInputStream in)
+    private void readObject(ObjectInputStream in)
             throws IOException, ClassNotFoundException {
         in.defaultReadObject();
 
                             simplePropertyName, propertyClass);
                     propertyClass = getter.getReturnType();
                     getMethods.add(getter);
-                } catch (final java.lang.NoSuchMethodException e) {
+                } catch (final NoSuchMethodException e) {
                     throw new IllegalArgumentException("Bean property '"
                             + simplePropertyName + "' not found", e);
                 }

compatibility-server/src/main/java/com/vaadin/v7/data/util/sqlcontainer/CacheFlushNotifier.java

 package com.vaadin.v7.data.util.sqlcontainer;
 
 import java.io.Serializable;
+import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
      * Removes dead references from instance list
      */
     private static void removeDeadReferences() {
-        java.lang.ref.Reference<? extends SQLContainer> dead = deadInstances
+        Reference<? extends SQLContainer> dead = deadInstances
                 .poll();
         while (dead != null) {
             allInstances.remove(dead);

compatibility-server/src/main/java/com/vaadin/v7/data/util/sqlcontainer/SQLContainer.java

 package com.vaadin.v7.data.util.sqlcontainer;
 
 import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
         return refdCont.getItem(getReferencedItemId(itemId, refdCont));
     }
 
-    private void writeObject(java.io.ObjectOutputStream out)
+    private void writeObject(ObjectOutputStream out)
             throws IOException {
         out.defaultWriteObject();
     }
 
-    private void readObject(java.io.ObjectInputStream in)
+    private void readObject(ObjectInputStream in)
             throws IOException, ClassNotFoundException {
         in.defaultReadObject();
         if (notificationsEnabled) {

compatibility-server/src/main/java/com/vaadin/v7/data/util/sqlcontainer/connection/SimpleJDBCConnectionPool.java

 package com.vaadin.v7.data.util.sqlcontainer.connection;
 
 import java.io.IOException;
+import java.io.ObjectOutputStream;
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.SQLException;
 
     }
 
-    private void writeObject(java.io.ObjectOutputStream out)
+    private void writeObject(ObjectOutputStream out)
             throws IOException {
         initialized = false;
         out.defaultWriteObject();

compatibility-server/src/main/java/com/vaadin/v7/event/ItemClickEvent.java

         try {
             ITEM_CLICK_METHOD = ItemClickListener.class.getDeclaredMethod(
                     "itemClick", new Class[] { ItemClickEvent.class });
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException();
+            throw new RuntimeException();
         }
     }
 

compatibility-server/src/main/java/com/vaadin/v7/ui/AbstractColorPicker.java

         try {
             COLOR_CHANGE_METHOD = ColorChangeListener.class.getDeclaredMethod(
                     "colorChanged", new Class[] { ColorChangeEvent.class });
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in ColorPicker");
         }
     }

compatibility-server/src/main/java/com/vaadin/v7/ui/AbstractField.java

             VALUE_CHANGE_METHOD = Property.ValueChangeListener.class
                     .getDeclaredMethod("valueChange",
                             new Class[] { Property.ValueChangeEvent.class });
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in AbstractField");
         }
     }
             READ_ONLY_STATUS_CHANGE_METHOD = Property.ReadOnlyStatusChangeListener.class
                     .getDeclaredMethod("readOnlyStatusChange", new Class[] {
                             Property.ReadOnlyStatusChangeEvent.class });
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in AbstractField");
         }
     }

compatibility-server/src/main/java/com/vaadin/v7/ui/Label.java

             VALUE_CHANGE_METHOD = Property.ValueChangeListener.class
                     .getDeclaredMethod("valueChange",
                             new Class[] { Property.ValueChangeEvent.class });
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in Label");
         }
     }

compatibility-server/src/main/java/com/vaadin/v7/ui/Table.java

                 HEADER_CLICK_METHOD = HeaderClickListener.class
                         .getDeclaredMethod("headerClick",
                                 new Class[] { HeaderClickEvent.class });
-            } catch (final java.lang.NoSuchMethodException e) {
+            } catch (final NoSuchMethodException e) {
                 // This should never happen
-                throw new java.lang.RuntimeException(e);
+                throw new RuntimeException(e);
             }
         }
 
                 FOOTER_CLICK_METHOD = FooterClickListener.class
                         .getDeclaredMethod("footerClick",
                                 new Class[] { FooterClickEvent.class });
-            } catch (final java.lang.NoSuchMethodException e) {
+            } catch (final NoSuchMethodException e) {
                 // This should never happen
-                throw new java.lang.RuntimeException(e);
+                throw new RuntimeException(e);
             }
         }
 
                 COLUMN_RESIZE_METHOD = ColumnResizeListener.class
                         .getDeclaredMethod("columnResize",
                                 new Class[] { ColumnResizeEvent.class });
-            } catch (final java.lang.NoSuchMethodException e) {
+            } catch (final NoSuchMethodException e) {
                 // This should never happen
-                throw new java.lang.RuntimeException(e);
+                throw new RuntimeException(e);
             }
         }
 
                 METHOD = ColumnReorderListener.class.getDeclaredMethod(
                         "columnReorder",
                         new Class[] { ColumnReorderEvent.class });
-            } catch (final java.lang.NoSuchMethodException e) {
+            } catch (final NoSuchMethodException e) {
                 // This should never happen
-                throw new java.lang.RuntimeException(e);
+                throw new RuntimeException(e);
             }
         }
 

compatibility-server/src/main/java/com/vaadin/v7/ui/Upload.java

 import java.io.OutputStream;
 import java.io.Serializable;
 import java.lang.reflect.Method;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
                     "uploadStarted", new Class[] { StartedEvent.class });
             UPLOAD_SUCCEEDED_METHOD = SucceededListener.class.getDeclaredMethod(
                     "uploadSucceeded", new Class[] { SucceededEvent.class });
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in Upload");
         }
     }
     }
 
     @Override
-    public java.util.Collection<?> getListeners(java.lang.Class<?> eventType) {
+    public Collection<?> getListeners(Class<?> eventType) {
         if (StreamingProgressEvent.class.isAssignableFrom(eventType)) {
             if (progressListeners == null) {
                 return Collections.EMPTY_LIST;

compatibility-server/src/main/java/com/vaadin/v7/ui/components/calendar/handler/BasicBackwardHandler.java

         // set new start and end times
         Calendar javaCalendar = event.getComponent().getInternalCalendar();
         javaCalendar.setTime(start);
-        javaCalendar.add(java.util.Calendar.DATE, durationInDays);
+        javaCalendar.add(Calendar.DATE, durationInDays);
         Date newStart = javaCalendar.getTime();
 
         javaCalendar.setTime(end);
-        javaCalendar.add(java.util.Calendar.DATE, durationInDays);
+        javaCalendar.add(Calendar.DATE, durationInDays);
         Date newEnd = javaCalendar.getTime();
 
         if (start.equals(end)) { // day view
 
             // we suppose that 7 >= lastDay >= firstDay >= 1
             while (!(firstDay <= dayOfWeek && dayOfWeek <= lastDay)) {
-                javaCalendar.add(java.util.Calendar.DATE, -1);
+                javaCalendar.add(Calendar.DATE, -1);
                 dayOfWeek = javaCalendar.get(Calendar.DAY_OF_WEEK);
             }
 

compatibility-server/src/main/java/com/vaadin/v7/ui/components/calendar/handler/BasicForwardHandler.java

         // set new start and end times
         Calendar javaCalendar = Calendar.getInstance();
         javaCalendar.setTime(start);
-        javaCalendar.add(java.util.Calendar.DATE, durationInDays);
+        javaCalendar.add(Calendar.DATE, durationInDays);
         Date newStart = javaCalendar.getTime();
 
         javaCalendar.setTime(end);
-        javaCalendar.add(java.util.Calendar.DATE, durationInDays);
+        javaCalendar.add(Calendar.DATE, durationInDays);
         Date newEnd = javaCalendar.getTime();
 
         if (start.equals(end)) { // day view
 
             // we suppose that 7 >= lastDay >= firstDay >= 1
             while (!(firstDay <= dayOfWeek && dayOfWeek <= lastDay)) {
-                javaCalendar.add(java.util.Calendar.DATE, 1);
+                javaCalendar.add(Calendar.DATE, 1);
                 dayOfWeek = javaCalendar.get(Calendar.DAY_OF_WEEK);
             }
 

compatibility-server/src/main/java/com/vaadin/v7/ui/components/colorpicker/ColorPickerGradient.java

         try {
             COLOR_CHANGE_METHOD = ColorChangeListener.class.getDeclaredMethod(
                     "colorChanged", new Class[] { ColorChangeEvent.class });
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in ColorPicker");
         }
     }

compatibility-server/src/main/java/com/vaadin/v7/ui/components/colorpicker/ColorPickerGrid.java

         try {
             COLOR_CHANGE_METHOD = ColorChangeListener.class.getDeclaredMethod(
                     "colorChanged", new Class[] { ColorChangeEvent.class });
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in ColorPicker");
         }
     }

compatibility-server/src/main/java/com/vaadin/v7/ui/components/colorpicker/ColorPickerHistory.java

         try {
             COLOR_CHANGE_METHOD = ColorChangeListener.class.getDeclaredMethod(
                     "colorChanged", new Class[] { ColorChangeEvent.class });
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in ColorPicker");
         }
     }

compatibility-server/src/main/java/com/vaadin/v7/ui/components/colorpicker/ColorPickerPopup.java

         try {
             COLOR_CHANGE_METHOD = ColorChangeListener.class.getDeclaredMethod(
                     "colorChanged", new Class[] { ColorChangeEvent.class });
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in ColorPicker");
         }
     }

compatibility-server/src/main/java/com/vaadin/v7/ui/components/colorpicker/ColorPickerPreview.java

         try {
             COLOR_CHANGE_METHOD = ColorChangeListener.class.getDeclaredMethod(
                     "colorChanged", new Class[] { ColorChangeEvent.class });
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in ColorPicker");
         }
     }

compatibility-server/src/test/java/com/vaadin/v7/data/util/sqlcontainer/connection/MockInitialContextFactory.java

 package com.vaadin.v7.data.util.sqlcontainer.connection;
 
+import java.util.Hashtable;
+
 import javax.naming.Context;
 import javax.naming.NamingException;
 import javax.naming.spi.InitialContextFactory;
     }
 
     @Override
-    public Context getInitialContext(java.util.Hashtable<?, ?> environment)
+    public Context getInitialContext(Hashtable<?, ?> environment)
             throws NamingException {
         if (mockCtx == null) {
             throw new IllegalStateException("mock context was not set.");

compatibility-shared/src/main/java/com/vaadin/v7/shared/ui/colorpicker/Color.java

             red = green = blue = (int) (value * 255.0f + 0.5f);
         } else {
             float h = (hue - (float) Math.floor(hue)) * 6.0f;
-            float f = h - (float) java.lang.Math.floor(h);
+            float f = h - (float) Math.floor(h);
             float p = value * (1.0f - saturation);
             float q = value * (1.0f - saturation * f);
             float t = value * (1.0f - (saturation * (1.0f - f)));

server/src/main/java/com/vaadin/event/ListenerMethod.java

 
 import java.io.IOException;
 import java.io.NotSerializableException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.io.Serializable;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.EventListener;
     private int eventArgumentIndex;
 
     /* Special serialization to handle method references */
-    private void writeObject(java.io.ObjectOutputStream out)
+    private void writeObject(ObjectOutputStream out)
             throws IOException {
         try {
             out.defaultWriteObject();
     }
 
     /* Special serialization to handle method references */
-    private void readObject(java.io.ObjectInputStream in)
+    private void readObject(ObjectInputStream in)
             throws IOException, ClassNotFoundException {
         in.defaultReadObject();
         try {
      *            eventArgumentIndex is negative, the triggering event object
      *            will not be passed to the trigger method, though it is still
      *            called.
-     * @throws java.lang.IllegalArgumentException
+     * @throws IllegalArgumentException
      *             if <code>method</code> is not a member of <code>target</code>
      *             .
      */
     public ListenerMethod(Class<?> eventType, Object target, Method method,
             Object[] arguments, int eventArgumentIndex)
-            throws java.lang.IllegalArgumentException {
+            throws IllegalArgumentException {
 
         // Checks that the object is of correct type
         if (!method.getDeclaringClass().isAssignableFrom(target.getClass())) {
-            throw new java.lang.IllegalArgumentException(
+            throw new IllegalArgumentException(
                     "The method " + method.getName()
                             + " cannot be used for the given target: "
                             + target.getClass().getName());
 
         // Checks that the event argument is null
         if (eventArgumentIndex >= 0 && arguments[eventArgumentIndex] != null) {
-            throw new java.lang.IllegalArgumentException(
+            throw new IllegalArgumentException(
                     "argument[" + eventArgumentIndex + "] must be null");
         }
 
         if (eventArgumentIndex >= 0
                 && !method.getParameterTypes()[eventArgumentIndex]
                         .isAssignableFrom(eventType)) {
-            throw new java.lang.IllegalArgumentException(
+            throw new IllegalArgumentException(
                     "The method " + method.getName()
                             + " does not accept the given eventType: "
                             + eventType.getName());
      *            eventArgumentIndex is negative, the triggering event object
      *            will not be passed to the trigger method, though it is still
      *            called.
-     * @throws java.lang.IllegalArgumentException
+     * @throws IllegalArgumentException
      *             unless exactly one match <code>methodName</code> is found in
      *             <code>target</code>.
      */
     public ListenerMethod(Class<?> eventType, Object target, String methodName,
             Object[] arguments, int eventArgumentIndex)
-            throws java.lang.IllegalArgumentException {
+            throws IllegalArgumentException {
 
         // Finds the correct method
         final Method[] methods = target.getClass().getMethods();
 
         // Checks that the event argument is null
         if (eventArgumentIndex >= 0 && arguments[eventArgumentIndex] != null) {
-            throw new java.lang.IllegalArgumentException(
+            throw new IllegalArgumentException(
                     "argument[" + eventArgumentIndex + "] must be null");
         }
 
         if (eventArgumentIndex >= 0
                 && !method.getParameterTypes()[eventArgumentIndex]
                         .isAssignableFrom(eventType)) {
-            throw new java.lang.IllegalArgumentException(
+            throw new IllegalArgumentException(
                     "The method " + method.getName()
                             + " does not accept the given eventType: "
                             + eventType.getName());
      *            the trigger method.
      * @param arguments
      *            the arguments to be passed to the trigger method.
-     * @throws java.lang.IllegalArgumentException
+     * @throws IllegalArgumentException
      *             if <code>method</code> is not a member of <code>target</code>
      *             .
      */
     public ListenerMethod(Class<?> eventType, Object target, Method method,
-            Object[] arguments) throws java.lang.IllegalArgumentException {
+            Object[] arguments) throws IllegalArgumentException {
 
         // Check that the object is of correct type
         if (!method.getDeclaringClass().isAssignableFrom(target.getClass())) {
-            throw new java.lang.IllegalArgumentException(
+            throw new IllegalArgumentException(
                     "The method " + method.getName()
                             + " cannot be used for the given target: "
                             + target.getClass().getName());
      *            <code>java.lang.IllegalArgumentException</code> is thrown.
      * @param arguments
      *            the arguments to be passed to the trigger method.
-     * @throws java.lang.IllegalArgumentException
+     * @throws IllegalArgumentException
      *             unless exactly one match <code>methodName</code> is found in
      *             <code>object</code>.
      */
     public ListenerMethod(Class<?> eventType, Object target, String methodName,
-            Object[] arguments) throws java.lang.IllegalArgumentException {
+            Object[] arguments) throws IllegalArgumentException {
 
         // Find the correct method
         final Method[] methods = target.getClass().getMethods();
      *            the object instance that contains the trigger method.
      * @param method
      *            the trigger method.
-     * @throws java.lang.IllegalArgumentException
+     * @throws IllegalArgumentException
      *             if <code>method</code> is not a member of <code>object</code>
      *             .
      */
     public ListenerMethod(Class<?> eventType, Object target, Method method)
-            throws java.lang.IllegalArgumentException {
+            throws IllegalArgumentException {
 
         // Checks that the object is of correct type
         if (!method.getDeclaringClass().isAssignableFrom(target.getClass())) {
-            throw new java.lang.IllegalArgumentException(
+            throw new IllegalArgumentException(
                     "The method " + method.getName()
                             + " cannot be used for the given target: "
                             + target.getClass().getName());
      *            the name of the trigger method. If the object does not contain
      *            the method or it contains more than one matching methods
      *            <code>java.lang.IllegalArgumentException</code> is thrown.
-     * @throws java.lang.IllegalArgumentException
+     * @throws IllegalArgumentException
      *             unless exactly one match <code>methodName</code> is found in
      *             <code>target</code>.
      */
     public ListenerMethod(Class<?> eventType, Object target, String methodName)
-            throws java.lang.IllegalArgumentException {
+            throws IllegalArgumentException {
 
         // Finds the correct method
         final Method[] methods = target.getClass().getMethods();
                     method.invoke(target, arguments);
                 }
 
-            } catch (final java.lang.IllegalAccessException e) {
+            } catch (final IllegalAccessException e) {
                 // This should never happen
-                throw new java.lang.RuntimeException(
+                throw new RuntimeException(
                         "Internal error - please report", e);
-            } catch (final java.lang.reflect.InvocationTargetException e) {
+            } catch (final InvocationTargetException e) {
                 // An exception was thrown by the invocation target. Throw it
                 // forwards.
                 throw new MethodException(

server/src/main/java/com/vaadin/event/MethodEventSource.java

      * @param method
      *            the activation method.
      * @return a registration object for removing the listener
-     * @throws java.lang.IllegalArgumentException
+     * @throws IllegalArgumentException
      *             unless <code>method</code> has exactly one match in
      *             <code>object</code>
      * @throws NullPointerException
      * @param methodName
      *            the name of the activation method.
      * @return a registration object for removing the listener
-     * @throws java.lang.IllegalArgumentException
+     * @throws IllegalArgumentException
      *             unless <code>method</code> has exactly one match in
      *             <code>object</code>
      * @throws NullPointerException

server/src/main/java/com/vaadin/server/LocaleService.java

         /*
          * First day of week (0 = sunday, 1 = monday)
          */
-        final java.util.Calendar cal = new GregorianCalendar(locale);
+        final Calendar cal = new GregorianCalendar(locale);
         localeData.firstDayOfWeek = cal.getFirstDayOfWeek() - 1;
 
         /*

server/src/main/java/com/vaadin/server/PaintTarget.java

      * @throws PaintException
      *             if the paint operation failed.
      */
-    public void addUIDL(java.lang.String uidl) throws PaintException;
+    public void addUIDL(String uidl) throws PaintException;
 
     /**
      * Adds text node. All the contents of the text are XML-escaped.

server/src/main/java/com/vaadin/ui/ConnectorTracker.java

 package com.vaadin.ui;
 
 import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
     }
 
     /* Special serialization to JsonObjects which are not serializable */
-    private void writeObject(java.io.ObjectOutputStream out)
+    private void writeObject(ObjectOutputStream out)
             throws IOException {
         out.defaultWriteObject();
         // Convert JsonObjects in diff state to String representation as
     }
 
     /* Special serialization to JsonObjects which are not serializable */
-    private void readObject(java.io.ObjectInputStream in)
+    private void readObject(ObjectInputStream in)
             throws IOException, ClassNotFoundException {
         in.defaultReadObject();
 

server/src/main/java/com/vaadin/ui/GridLayout.java

      * @author Vaadin Ltd.
      * @since 3.0
      */
-    public class OverlapsException extends java.lang.RuntimeException {
+    public class OverlapsException extends RuntimeException {
 
         private final Area existingArea;
 
      * @author Vaadin Ltd.
      * @since 3.0
      */
-    public class OutOfBoundsException extends java.lang.RuntimeException {
+    public class OutOfBoundsException extends RuntimeException {
 
         private final Area areaOutOfBounds;
 

server/src/main/java/com/vaadin/ui/PopupView.java

             POPUP_VISIBILITY_METHOD = PopupVisibilityListener.class
                     .getDeclaredMethod("popupVisibilityChange",
                             PopupVisibilityEvent.class);
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in PopupView");
         }
     }
      * @param large
      *            the full, Component-type representation
      */
-    public PopupView(final java.lang.String small, final Component large) {
+    public PopupView(final String small, final Component large) {
         this(createContent(small, large));
     }
 
             if (visible) {
                 visibleComponent = content.getPopupComponent();
                 if (visibleComponent == null) {
-                    throw new java.lang.IllegalStateException(
+                    throw new IllegalStateException(
                             "PopupView.Content did not return Component to set visible");
                 }
                 if (visibleComponent.getParent() != null) {

server/src/main/java/com/vaadin/ui/TabSheet.java

             SELECTED_TAB_CHANGE_METHOD = SelectedTabChangeListener.class
                     .getDeclaredMethod("selectedTabChange",
                             SelectedTabChangeEvent.class);
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in TabSheet");
         }
     }

server/src/main/java/com/vaadin/ui/Upload.java

                     .getDeclaredMethod("uploadStarted", StartedEvent.class);
             UPLOAD_SUCCEEDED_METHOD = SucceededListener.class
                     .getDeclaredMethod("uploadSucceeded", SucceededEvent.class);
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error finding methods in Upload");
         }
     }

server/src/main/java/com/vaadin/ui/Window.java

         try {
             WINDOW_CLOSE_METHOD = CloseListener.class
                     .getDeclaredMethod("windowClose", CloseEvent.class);
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error, window close method not found");
         }
     }
         try {
             WINDOW_RESIZE_METHOD = ResizeListener.class
                     .getDeclaredMethod("windowResized", ResizeEvent.class);
-        } catch (final java.lang.NoSuchMethodException e) {
+        } catch (final NoSuchMethodException e) {
             // This should never happen
-            throw new java.lang.RuntimeException(
+            throw new RuntimeException(
                     "Internal error, window resized method not found");
         }
     }

server/src/main/java/com/vaadin/util/ReflectTools.java

 import java.beans.IntrospectionException;
 import java.beans.PropertyDescriptor;
 import java.io.Serializable;
+import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
      *             If the value could not be retrieved
      */
     public static Object getJavaFieldValue(Object object,
-            java.lang.reflect.Field field) throws IllegalArgumentException,
+            Field field) throws IllegalArgumentException,
             IllegalAccessException, InvocationTargetException {
         PropertyDescriptor pd;
         try {
      *             If the value could not be retrieved
      */
     public static Object getJavaFieldValue(Object object,
-            java.lang.reflect.Field field, Class<?> propertyType)
+            Field field, Class<?> propertyType)
             throws IllegalArgumentException, IllegalAccessException,
             InvocationTargetException {
         PropertyDescriptor pd;
      *             If the value could not be assigned to the field
      */
     public static void setJavaFieldValue(Object object,
-            java.lang.reflect.Field field, Object value)
+            Field field, Object value)
             throws IllegalAccessException, IllegalArgumentException,
             InvocationTargetException {
         PropertyDescriptor pd;

server/src/test/java/com/vaadin/util/ReflectToolsGetFieldValueByTypeTest.java

 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import java.lang.reflect.Field;
+
 import org.junit.Test;
 
 public class ReflectToolsGetFieldValueByTypeTest {
 
         MySubClass myInstance = new MySubClass();
 
-        java.lang.reflect.Field memberField;
+        Field memberField;
         Object fieldValue = false;
         try {
             memberField = myInstance.getClass().getField("field");
 
         MySubClass myInstance = new MySubClass();
 
-        java.lang.reflect.Field memberField;
+        Field memberField;
         try {
             memberField = myInstance.getClass().getField("field");
             // Should throw an IllegalArgument exception as the mySubClass class

server/src/test/java/com/vaadin/util/ReflectToolsGetPrimitiveFieldValueTest.java

 
 import static org.junit.Assert.assertFalse;
 
+import java.lang.reflect.Field;
+
 import org.junit.Test;
 
 public class ReflectToolsGetPrimitiveFieldValueTest {
 
         MyClass myInstance = new MyClass();
 
-        java.lang.reflect.Field memberField;
+        Field memberField;
         Object fieldValue = false;
         try {
             memberField = myInstance.getClass().getField("field");

shared/src/main/java/com/vaadin/shared/ui/colorpicker/Color.java

             red = green = blue = (int) (value * 255.0f + 0.5f);
         } else {
             float h = (hue - (float) Math.floor(hue)) * 6.0f;
-            float f = h - (float) java.lang.Math.floor(h);
+            float f = h - (float) Math.floor(h);
             float p = value * (1.0f - saturation);
             float q = value * (1.0f - saturation * f);
             float t = value * (1.0f - (saturation * (1.0f - f)));

uitest/src/main/java/com/vaadin/tests/RandomLayoutStress.java

         panelBLayout.addComponent(layoutB);
 
         // Create grid layout
-        final int gridSize = (int) java.lang.Math.sqrt(componentCountC);
+        final int gridSize = (int) Math.sqrt(componentCountC);
         VerticalLayout panelGLayout = new VerticalLayout();
         panelGLayout.setMargin(true);
         final Panel panelG = new Panel("Panel containing grid layout ("

uitest/src/main/java/com/vaadin/tests/components/colorpicker/ColorPickerTestUI.java

     public class MyImageSource implements StreamResource.StreamSource {
 
         /** The imagebuffer. */
-        private java.io.ByteArrayOutputStream imagebuffer = null;
+        private ByteArrayOutputStream imagebuffer;
 
         /** The bg color. */
         private final java.awt.Color bgColor;

uitest/src/main/java/com/vaadin/tests/components/table/MissingScrollbar.java

 package com.vaadin.tests.components.table;
 
+import java.io.ObjectOutputStream;
 import java.io.Serializable;
 
 import com.vaadin.tests.components.TestBase;
         return ic;
     }
 
-    private void writeObject(java.io.ObjectOutputStream out) throws Exception {
-
+    private void writeObject(ObjectOutputStream out) throws Exception {
         out.defaultWriteObject();
         System.out.println("Serialize " + getClass().getName() + "("
                 + (this instanceof Serializable) + ")");

uitest/src/test/java/com/vaadin/tests/components/table/DisabledSortingTableTest.java

     Class<?> uiClass;
 
     @Override
-    protected java.lang.Class<?> getUIClass() {
+    protected Class<?> getUIClass() {
         return uiClass;
     };