Why is there no StrongReference object?

Question

I'm implementing some behavior which could benefit from using weak references some of the time. I'd like the user of the class to be able to indicate at construction time whether this is the case or not. Since WeakReference extends Reference at first glance it would seem I could do something like (this is a mockup, not what I'm actually trying to do):

public class Container<T> {
    private boolean useWeakRef;
    private Reference<T> ref;

    public Container(boolean isWeak) {
        useWeakRef = isWeak;
    }

    public void store(T val) {
        if(useWeakRef) {
            ref = new WeakReference<>(val);
        } else {
            ref = new StrongReference<>(val);
        }
    }

    // May return null
    public T get() {
        return ref.get();
    }
}

However there is no StrongReference class, and according to the Reference javadocs:

Because reference objects are implemented in close cooperation with the garbage collector, this class may not be subclassed directly.

So I can't create my own subclass of Reference that holds a strong (i.e. normal) reference to the object. This seems to mean it's not possible to make a class which hides whether it uses Weak (or Soft) references from the caller.

I don't really understand why this class doesn't exist, a StrongReference object should simply always return the object from get() unless clear() has been called. Why is this missing? Is a StrongReference inconsistent with Reference in some way? It would make building generic reference-holder objects much simpler.

Answer 1

When i've needed to do this, i just created a custom Reference interface and a trivial subclass of WeakReference. it's annoying but it's about as good as you can do.

public interface MyReference<T> {
  public T get();
}

public class MyWeakReference<T> extends WeakReference<T> implements MyReference<T> {
}

public class MyStrongReference<T> implements MyReference<T> {
  // obvious implementation here ...
}

UPDATE:

to clarify, i have no idea why this wasn't included in the jdk in the first place (i, too, wish it had been), however, i feel this is a reasonable workaround.

for those seeking justification of this idea, i have found it necessary when implementing custom caches where the strength of the reference is part of the configuration for the cache.

Answer 2

You cannot subclass Reference because it does not have any public / protected constructors. But there's a workaround:

class StrongReference<T> extends WeakReference<T> {
    private final T referent;

    StrongReference(T referent) {
        super(null);
        this.referent = referent;
    }

    @Override
    public T get() {
        return referent;
    }

    // implement other methods
}