View difference between Paste ID: 7ng381ZN and ngCsNgxb

 package com.hazelcast.util;
 
 import com.google.common.collect.ForwardingConcurrentMap;
 
 import com.hazelcast.core.EntryListener;
 import com.hazelcast.core.IMap;
 import com.hazelcast.core.MapEntry;
 import com.hazelcast.monitor.LocalMapStats;
 import com.hazelcast.query.Expression;
 import com.hazelcast.query.Predicate;
 
 import java.util.Collection;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
 
 /**
  * A forwarding class for IMap, which is itself an extension of ConcurrentMap.
- * This is for Hazelcast 1.9 and earlier. For Hazelcast 2.0, see https://pastebin.com/7ng381ZN
+ * This is for Hazelcast 2.0, prior versions are for Hazelcast 1.9 and earlier.
  */
-public class ForwardingIMap<K, V> extends ForwardingConcurrentMap<K, V> implements IMap<K, V> {
+public abstract class ForwardingIMap<K, V> extends ForwardingConcurrentMap<K, V> implements IMap<K, V> {
 
-    public ForwardingIMap(IMap<K, V> map) {
+    protected ForwardingIMap() {
-        this.map = map;
+        // Nothing to do here except be protected.
     }
 
 
     //
     // Instance methods
     //
 
     @Override public InstanceType getInstanceType() {
         return delegate().getInstanceType();
     }
 
     @Override public void destroy() {
         delegate().destroy();
     }
 
     @Override public Object getId() {
         return delegate().getId();
     }
 
 
     //
     // IMap methods
     //
 
     @Override public void flush() {
         delegate().flush();
     }
     @Override public String getName() {
         return delegate().getName();
     }
 
     @Override public Map<K, V> getAll(Set<K> keys) {
         return delegate().getAll(keys);
     }
 
     @Override public Future<V> getAsync(K key) {
         return delegate().getAsync(key);
     }
 
     @Override public Future<V> putAsync(K key, V value) {
         return delegate().putAsync(key, value);
     }
 
     @Override public Future<V> removeAsync(K key) {
         return delegate().removeAsync(key);
     }
 
     @Override public Object tryRemove(K key, long timeout, TimeUnit timeunit) throws TimeoutException {
         return delegate().tryRemove(key, timeout, timeunit);
     }
 
     @Override public boolean tryPut(K key, V value, long timeout, TimeUnit timeunit) {
         return delegate().tryPut(key, value, timeout, timeunit);
     }
 
     @Override public V put(K key, V value, long ttl, TimeUnit timeunit) {
         return delegate().put(key, value, ttl, timeunit);
     }
 
     @Override public void putTransient(K key, V value, long ttl, TimeUnit timeunit) {
         delegate().putTransient(key, value, ttl, timeunit);
     }
 
     @Override public V putIfAbsent(K key, V value, long ttl, TimeUnit timeunit) {
         return delegate().putIfAbsent(key, value, ttl, timeunit);
     }
 
     @Override public void set(K key, V value, long ttl, TimeUnit timeUnit) {
         delegate().set(key, value, ttl, timeUnit);
     }
 
     @Override public V tryLockAndGet(K key, long time, TimeUnit timeunit) throws TimeoutException {
         return delegate().tryLockAndGet(key, time, timeunit);
     }
 
     @Override public void putAndUnlock(K key, V value) {
         delegate().putAndUnlock(key, value);
     }
 
     @Override public void lock(K key) {
         delegate().lock(key);
     }
 
     @Override public boolean tryLock(K key) {
         return delegate().tryLock(key);
     }
 
     @Override public boolean tryLock(K key, long time, TimeUnit timeunit) {
         return delegate().tryLock(key, time, timeunit);
     }
 
     @Override public void unlock(K key) {
         delegate().unlock(key);
     }
 
     @Override public void forceUnlock(K key) {
         delegate().forceUnlock(key);
     }
 
     @Override public boolean lockMap(long time, TimeUnit timeunit) {
         return delegate().lockMap(time, timeunit);
     }
 
     @Override public void unlockMap() {
         delegate().unlockMap();
     }
 
 
     @Override public void addLocalEntryListener(EntryListener<K,V> listener) {
         delegate().addLocalEntryListener(listener);
     }
 
     @Override public void addEntryListener(EntryListener<K,V> listener, boolean includeValue) {
         delegate().addEntryListener(listener, includeValue);
     }
 
     @Override public void removeEntryListener(EntryListener<K,V> listener) {
         delegate().removeEntryListener(listener);
     }
 
     @Override public void addEntryListener(EntryListener<K,V> listener, K key, boolean includeValue) {
         delegate().addEntryListener(listener, key, includeValue);
     }
 
     @Override public void removeEntryListener(EntryListener<K,V> listener, K key) {
         delegate().removeEntryListener(listener, key);
     }
 
     @Override public MapEntry<K,V> getMapEntry(K key) {
         return delegate().getMapEntry(key);
     }
 
     @Override public boolean evict(Object key) {
         return delegate().evict(key);
     }
 
     @Override public Set<K> keySet(Predicate predicate) {
         return delegate().keySet(predicate);
     }
 
     @Override public Set<Map.Entry<K,V>> entrySet(Predicate predicate) {
         return delegate().entrySet(predicate);
     }
 
     @Override public Collection<V> values(Predicate predicate) {
         return delegate().values(predicate);
     }
 
     @Override public Set<K> localKeySet() {
         return delegate().localKeySet();
     }
 
     @Override public Set<K> localKeySet(Predicate predicate) {
         return delegate().localKeySet(predicate);
     }
 
     @Override public void addIndex(String attribute, boolean ordered) {
         delegate().addIndex(attribute, ordered);
     }
 
     @Override public void addIndex(Expression<?> expression, boolean ordered) {
         delegate().addIndex(expression, ordered);
-    protected IMap<K, V> delegate() {
+
-        return map;
+
     @Override public LocalMapStats getLocalMapStats() {
         return delegate().getLocalMapStats();
-    private final IMap<K, V> map;
+
 
 
     protected abstract IMap<K, V> delegate();
 }