diff --git a/src/main/java/org/apache/sling/jcr/resource/internal/JcrListenerBaseConfig.java b/src/main/java/org/apache/sling/jcr/resource/internal/JcrListenerBaseConfig.java
index a0e8db7..8665d2a 100644
--- a/src/main/java/org/apache/sling/jcr/resource/internal/JcrListenerBaseConfig.java
+++ b/src/main/java/org/apache/sling/jcr/resource/internal/JcrListenerBaseConfig.java
@@ -19,7 +19,6 @@
 package org.apache.sling.jcr.resource.internal;
 
 import java.io.Closeable;
-import java.io.IOException;
 import java.util.Set;
 
 import javax.jcr.RepositoryException;
diff --git a/src/main/java/org/apache/sling/jcr/resource/internal/JcrResourceListener.java b/src/main/java/org/apache/sling/jcr/resource/internal/JcrResourceListener.java
index 90c755c..d152cda 100644
--- a/src/main/java/org/apache/sling/jcr/resource/internal/JcrResourceListener.java
+++ b/src/main/java/org/apache/sling/jcr/resource/internal/JcrResourceListener.java
@@ -25,7 +25,6 @@
 import static javax.jcr.observation.Event.PROPERTY_REMOVED;
 
 import java.io.Closeable;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
diff --git a/src/main/java/org/apache/sling/jcr/resource/internal/JcrValueMap.java b/src/main/java/org/apache/sling/jcr/resource/internal/JcrValueMap.java
index e4ccdd5..4bce687 100644
--- a/src/main/java/org/apache/sling/jcr/resource/internal/JcrValueMap.java
+++ b/src/main/java/org/apache/sling/jcr/resource/internal/JcrValueMap.java
@@ -92,9 +92,6 @@
     @SuppressWarnings("unchecked")
     public @Nullable <T> T get(@NotNull final String aKey, @NotNull final Class<T> type) {
         final String key = checkKey(aKey);
-        if (type == null) {
-            return (T) get(key);
-        }
 
         final JcrPropertyMapCacheEntry entry = this.read(key);
         if (entry == null) {
@@ -110,9 +107,6 @@
     @SuppressWarnings("unchecked")
     public @NotNull <T> T get(@NotNull final String aKey, @NotNull final T defaultValue) {
         final String key = checkKey(aKey);
-        if (defaultValue == null) {
-            return (T) get(key);
-        }
 
         // special handling in case the default value implements one
         // of the interface types supported by the convertToType method
@@ -254,10 +248,7 @@
                 entry = new JcrPropertyMapCacheEntry(prop);
                 cache.put(key, entry);
 
-                final Object defaultValue = entry.getPropertyValue();
-                if (defaultValue != null) {
-                    valueCache.put(key, entry.getPropertyValue());
-                }
+                valueCache.put(key, entry.getPropertyValue());
             }
             return entry;
         } catch (final RepositoryException re) {
@@ -393,7 +384,7 @@
 
     // ---------- Implementation helper
 
-    private Class<?> normalizeClass(Class<?> type) {
+    private static @NotNull Class<?> normalizeClass(Class<?> type) {
         if (Calendar.class.isAssignableFrom(type)) {
             type = Calendar.class;
         } else if (Date.class.isAssignableFrom(type)) {
@@ -406,9 +397,9 @@
         return type;
     }
 
-    private Map<String, Object> transformEntries(final Map<String, JcrPropertyMapCacheEntry> map) {
+    private static @NotNull Map<String, Object> transformEntries(final Map<String, JcrPropertyMapCacheEntry> map) {
 
-        final Map<String, Object> transformedEntries = new LinkedHashMap<String, Object>(map.size());
+        final Map<String, Object> transformedEntries = new LinkedHashMap<>(map.size());
         for ( final Map.Entry<String, JcrPropertyMapCacheEntry> entry : map.entrySet() )
             transformedEntries.put(entry.getKey(), entry.getValue().getPropertyValueOrNull());
 
diff --git a/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/BasicQueryLanguageProvider.java b/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/BasicQueryLanguageProvider.java
index 8a085cd..bef8ac5 100644
--- a/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/BasicQueryLanguageProvider.java
+++ b/src/main/java/org/apache/sling/jcr/resource/internal/helper/jcr/BasicQueryLanguageProvider.java
@@ -24,7 +24,6 @@
 import java.util.NoSuchElementException;
 
 import javax.jcr.RepositoryException;
-import javax.jcr.Session;
 import javax.jcr.Value;
 import javax.jcr.query.Query;
 import javax.jcr.query.QueryResult;
