The reason intersection types are not implemented for direct use is in the way the JVM works, and Java 5 is chosen to be implemented. Currently, there is no special runtime type to represent intersection type, it’s always compiled as the erasure of its first bound.

Implementing it in a different way most probably requires some changes in the JVM and/or generation of synthetic classes. From a number of reasons it was a change the Java architects wanted to avoid. But, who knows? Maybe future versions will support that?…

P.S. Thank you for formatting my previous comment, but there are still some incompleteness in my code caused by a replay form.

In my original example a reference holder was declared as:

public class ListRef<T extends List<String> & RandomAccess> {
    public final T value;

    public ListRef(T value) {
        this.value = value;
    }
}

Example method implementation as:

public ListRef<?> foo() {
    return new ListRef<ArrayList<String>>(new ArrayList<String>());
}

And sample use snippet as:

ListRef<?> listRef = foo();
List<String> list = listRef.value;
RandomAccess ra = listRef.value;
...

public class RandomAccessListDelegate<E, T extends <List<E> & RandomAccess> implements RandomAccess, List<E> {
  private final T delegate;
  private RandomAccessListDelegate(T delegate) {
    this.delegate = delegate;
  }
  public static <E, T extends <List<E> & RandomAccess> RandomAccessListDelegate<E, T> create(T delegate) {
    return new RandomAccessListDelegate(delegate);
  }
  public T getDelegate() { return delegate; }
  // Delegate all methods to delegate
  // [code snipped]
}

Still, I shouldn’t have to jump this hoop.

For example, having a reference holder declared as:

public class ListRef<T extends List & RandomAccess> {
    public final T value;

    public ListRef(T value) {
        this.value = value;
    }
}

you can return any implementation matching declared intersection type this way:

public ListRef foo() {
   return new ListRef<ArrayList>(new ArrayList());
}

and use it as follows:

ListRef listRef = foo();
List list = listRef.value;
RandomAccess ra = listRef.value;
...

I think, it is a bit more than just “Almost Useful” Java feature, isn’t it?

SomeRandomAccessListType list = myObject.<SomeRandomAccessListType>foo();

ArrayList is not a subclass of SomeRandomAccessListType, so you would get a cast error.