Scala Type Parameter

Cache.java

import java.util.Map;

public interface Cache<K, V> {
    V get(K k);
    void put(K key, V v);
    Map<K, V> asMap();
}

CacheImpl.scala

abstract class CacheImpl[K, V >: Null](value: V) extends Cache[K, V] {
  val flag = true
  override def get(key: K): V =  if (flag) value else null
}

CacheTest.scala

import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.ConcurrentMap
import scala.collection.JavaConversions._

trait BatchLoadingCache[K, V] {
  protected val underlyingCache: Cache[K, V]
  protected def load(key: K): V
  def get(key: K): V = {
    var v = underlyingCache.get(key)
    if (null == v) {
      v = load(key)
      underlyingCache.put(key, v)
    }
    v
  }
}

trait AbstractSimpleCacheScala[K, V] extends BatchLoadingCache[K, V] {
  self =>
  protected val underlyingCache: InternalCache = new InternalCache()
  class InternalCache extends Cache[K, V] {
    private val cache = new ConcurrentHashMap[K, V]()
    override def asMap(): ConcurrentMap[K, V] = cache
    override def get(k: K): V = cache.get(k)
    override def put(key: K, v: V): Unit = cache.put(key, v)
  }
}

class TestCache extends AbstractSimpleCacheScala[Long, String] {
  def getAll: Map[Long, String] = {
    underlyingCache.asMap().toMap
  }
  override protected def load(key: Long): String = underlyingCache.get(key)
}