Partially inherit an interface in Java?

Question

I want to implement a simple Cache interface:

public interface Cache {
    Object get(Object key);
    Object put(Object key, Object value);
    void clear();
}

I realized it's part of interface java.util.Map. So objects like HashMap should be able to be be passed to functions needing a Cache object.

But on the other hand I don't want to make my own Cache class implement the whole Map interface because I don't really need other methods other than these three.

Java is not a duck-typed language, so what's the best practice in this situation?

Implement all methods, because you have to; make the methods you aren't planning to invoke throw UnsupportedOperationException. — Andy Turner
– Andy Turner, Commented May 8, 2018 at 18:10
The only purpose of Interfaces is to enforce a class implements certain methods. — L.Spillner
– L.Spillner, Commented May 8, 2018 at 18:11
add deprecited flag to the method you are not planning to invoke — Thecarisma
– Thecarisma, Commented May 8, 2018 at 18:15
@Stephan Yes. What I can do now is to make a wrapper Cache class which accept a Map object as single parameter. And implements all there method by calling the internal Map object. — Ken
– Ken, Commented May 8, 2018 at 18:22
I would personally make my own Cache interface and implement that. You shouldn't have a class implement Map unless it's a map. — markspace
– markspace, Commented May 8, 2018 at 18:27

Mạnh Quyết Nguyễn · Accepted Answer · 2018-05-08 18:39:51Z

There are no such features in java.

I think the best you can do is to create a wrapper of HashMap as you concern.

An interface is a contract. The implemented class should fullfill the contract by implement the virtual / abstract methods.

Your CacheImpl only fullfills the contract with Cache interface. Meanwhile HashMap only fullfills the contract with Map interface.

The Cache and Map interface share method with same signatures but they requires different contract / implementation.

You really can not determine if an interface contains the method Object put(Object key, Object value); is compatible with your Cache interface or not, because you don't understand which contract that interface provide.

So in Java, unless they provide semantic to create kind of "parent" interface of existing interface, you cannot do that.

Amit Bera · Accepted Answer · 2018-05-08 19:03:43Z

I think you can wrapper Map inside the Implementation of Cache class

class CacheImpl<K, V> implements Cache<K, V> {
    Map<K, V> cacheMap;

    CacheImpl() {
        this(new LinkedHashMap<>());
    }

    CacheImpl(Map<K,V> cacheMap) {
        this.cacheMap = cacheMap;
    }

    @Override
    public V get(K key) {
        return cacheMap.get(key);
    }

    @Override
    public V put(K key, V value) {
        return cacheMap.put(key, value);
    }

    @Override
    public void clear() {
        cacheMap.clear();
    }
}

I have added the example with the Generic but you are always free to Use Object as the key and value.

So, in my example to make it thread safe We can we ConcurrentHashMap which is already thread safe and well implemented. I will suggest having a Factory class to create the cache object like below.

class CacheImplFactory {
    public static <K, V> Cache<K, V> newSimpleCache() {
        return new CacheImpl<K, V>();
    }

    public static <K, V> Cache<K, V> newSynchronizedCache() {
        return new CacheImpl<K, V>(new ConcurrentHashMap<>());
    }

    public static <K, V> Cache<K, V> newWeakCache() {
        return new CacheImpl<K, V>(new WeakHashMap<>());
    }
}

The map should be passed in rather than instantiated in the constructor. Otherwise, great answer.
Good, but no thread safety considerations at all. This class is a memory leak waiting to happen. HashMap will work, but I'd prefer something that kicked out long lived objects using LRU in LinkedHashMap. stackoverflow.com/questions/224868/…
@shmosel Thanks!!! Yes, you are right it will make loosely coupled code and testable code. I will improve my answer.
I like the idea of a wrapper class. However, personally I would implement it as a static method of Cache returning an anonymous class.
Don't use raw generics. Change constructor parameter to Map<K, V>. You should also add @Override annotations to the methods implementing the interface.

Stephan · Accepted Answer · 2018-05-08 18:47:28Z

If I understand your question, you're asking how to back the interface with an existing java class like HashMap.

You will have to create your own implementation that implements your interface, and extends HashMap.

The Interface methods will delegate the action to the HashMap. In this manner, your custom class will meet the interface needs for any Method with a signature of your interface.

A working example I threw together to showcase how to do what you're asking with Generics:

The Cache Interface:

package interfaces;

public interface Cache<K,V> {
    V get(K key);
    V put(K key, V value);
    void clear();
}

The Implementation:

package classes;

import java.util.HashMap;
import interfaces.Cache;

public class MyCache<K,V> extends HashMap<K,V> implements Cache<K,V> {

    private static final long serialVersionUID = 1L;

    @Override
    public V get(Object key) {
        return super.get(key);
    }

    @Override
    public V put(K key, V value) {
        return super.put(key, value);
    }

    @Override
    public void clear() {
        super.clear();
    }
}

You can then use it like so:

import classes.MyCache;
import interfaces.Cache;

public class DoStuff {

    private Cache<String,Integer> cache;

    public void initCache() {
        //This works
        //Since MyCache implements Cache
        MyCache<String,Integer> mCache=new MyCache<String,Integer>();
        setCache(mCache);

        //This will not
        //Since HashMap does not implement Cache
        HashMap<String,Integer> mMap=new HashMap<String,Integer>();
        setCache(mMap);
    }

    public void setCache(Cache<String,Integer> c) {
        cache=c;
    }

    public Cache<String,Integer> getCache() {
        return cache;
    }
}

OP want to pass exactly a HashMap to method that accept a Cache interface

Collectives™ on Stack Overflow

Partially inherit an interface in Java?

3 Answers 3

Comments

7 Comments

2 Comments

Linked

Hot Network Questions