可选单值或集合的Java泛型

Question

I'm trying to define a container for a whole bunch of classes as some parts of the code will make more sense with a collection but other places will make sense with single values.

Ideally I'd like to do this:

public class AllModes<T> {
   private T<Car> car;
   private T<Boat> boat;
   private T<Train> train;
   private T<Plane> plane;
   ...40 more of these...
}

then I'd like to use the class like:

AllModes<List> allModes;
AllModes<Optional> oneOfEachMode;

But I get the error I get is "The type T is not generic; it cannot be parameterized with arguments "

The reason I'm defining these in multiple variables and not a single HashSet based on a superclass is I want to have get methods that return the correct types to avoid consumers of this class needing to cast down everywhere as each object has its own distinct fields.

I also considered just storing a single value list or set but I thought it might less error prone to use the correct type I intended (ie. one value)

Answer 1

You can't solve it this way. Use the instanceof operator instead. Here is an example:

public class AllModes<T> {
    private T object;

    private void check(T object) {
        if(object instanceof Boat){
            System.out.println("Boat");
            // your code for Boat goes here
        } else if (object instanceof Car) {
            System.out.println("Car");
            // your code for Car goes here
        }
    }
}

Answer 2

From The Java™ Tutorials - Why Use Generics? :

By using generics, programmers can implement generic algorithms that work on collections of different types, can be customized, and are type safe and easier to read.

You can have multiple types in class and then you can associated them with the fields. But in your case, you have several fields with some type. A class don't have much dependencies on others. You should design you class in a way that there are no much dependencies there.

public class AllModes<T,T1,T2,T3> {
       private T car;
       private T1 boat;
       private T2 train;
       private T3 plane;

}

Answer 3

You can't achieve what you want using the Java type system. Since you can't have a generic container type, you'll need to enforce the invariants with dedicated constructors (or subclasses).

But if you do so, the clients of your class will not be able to distinguish between different container types ( Optional vs List ), they will need to work with a generic abstraction (like Stream , Iterator , Iterable , whatever suits you).

Here's an example:

public class AllModes {
    private final Supplier<Stream<Car>> cars;
    private final Supplier<Stream<Boat>> boats;

    public AllModes(Optional<Car> car, Optional<Boat> boat) {
        // Assuming Java 8, when Optional did not have a stream() method yet
        this.cars = () -> car.map(Stream::of).orElse(Stream.empty());
        this.boats = () -> boat.map(Stream::of).orElse(Stream.empty());
    }

    public AllModes(List<Car> cars, List<Boat> boats) {
        this.cars = cars::stream;
        this.boats = boats::stream;
    }

    public Stream<Car> getCars() {
        return cars.get();
    }

    public Stream<Boat> getBoats() {
        return boats.get();
    }
}

Answer 4

I'd suggest you take a step back and re-consider what exactly you want to achieve with this container. Eg ask yourself what its domain is or what the client is supposed to do with Allmodes<T> ...

Another more concrete question that comes to mind is how exactly you intend to popuplate that Optional<T> generically? Will it be the first element in the List<T> or the last? Or an element which satisfies a specific Predicate<T> ?

Your design doesn't seem to be that well thought out yet.

What you could do which would come close to what you descibed (in case I got that right) is provide an accessor of type Stream<T> as you could get both a List<T> aswell as an Optional<T> from it. Your client would then have to make that decision and also determine how exactly to derive the Optional<T> from the Stream<T> .