9

(This is probably a duplicate, but I could not find it - feel free to point it out)

Consider the following Java class:

public class A<T0, T1> {
    public A(T0 t0, T1 t1) {
        ...
    }
}

Instantiating this class is easy using something along the lines of new A<Integer, String>(1, "X").

Suppose now that most instances of this class have a String as the second type parameter T1 and that the object of this type used in the constructor call is also pretty much standard.

If A had not been using generics, a common extension would be an additional constructor without the second argument:

public class A {
    public A(int t0, String t1) {
        ...
    }

    public A(int t0) {
        this(t0, new String("X"));
    }
}

Unfortunately, this does not seem to be possible for a class that does use generics - at least not without a forced cast:

    public A(T0 t0) {
        this(t0, (T1)(...));
    }

The reason? While this constructor only takes a single argument, it still uses two type parameters and there is no way to know a priori that whatever type T1 the user of the class supplies will be compatible with the default value used in the constructor.

A slightly more elegant solution involves the use of a subclass:

 public class B<T0> extends A<T0, String> {
     ...
 }

But this approach forces yet another branch in the class hierarchy and yet another class file with what is essentially boilerplate code.

  • Is there a way to declare a constructor that forces one or more of the type parameters to a specific type? Something with the same effects as using a subclass, but without the hassle?

  • Is there something fundamentally wrong in my understanding of generics and/or my design? Or is this a valid issue?

Improve this question
2
  • Perhaps its time to use static factory method(s). This provides more flexibility in this regard. Commented Dec 12, 2011 at 17:10
  • @PeterLawrey: ah, thought I forgot to mention something. I do use static factory methods normally. The usual case for the issue in my question is when I want to come up with a standardized constructor for use by third-party code - usually the default constructor... Commented Dec 12, 2011 at 17:15

6 Answers 6

Reset to default
6

Easiest method is just to add a static creation method.

public static <T0> A<T0,String> newThing(T0 t0) {
    return new A<T0,String>(t0, "X");
}

(Perhaps choose a name appropriate for the particular usage. Usually no need for new String("...").)

From Java SE 7, you can use the diamond:

A<Thing,String> a = new A<>(thing);
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

I do use static factory methods when possible. I reserve the constructor mambo-jumbo for when dealing with third-party code that uses reflection blindly. BTW I don't think that the Java 7 diamond operator solves this particular problem, but +1 for mentioning this great step into DRY for Java.
What is the name of <T0>? I looked through the JLS but I couldn't find a precise name for it. Hard to explain to other people when you don't know what to call it yourself :)
@NobleUplift <T0> is knowns as TypeParameters in the grammar. docs.oracle.com/javase/specs/jls/se8/html/… T0 is a type variable. docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4
2

As I understand it, you want to have a second constructor that (if called) would force the generic type T1 to be a String.

However, the generics are specified BEFORE you call the constructor.

That second constructor, if valid, could allow someone to do this:

B<Integer, Integer> b = new B<Integer, Integer>(5);

The error here is that you've specified the second generic type as an Integer BEFORE calling the constructor. And then the constructor would, in theory, specify the second generic type as a String. Which is why I believe it's not allowed.

Improve this answer

1 Comment

+1 That was my understanding as well. I was just hoping for some magic trick that would combine the normal constructor syntax with a factory method.
1

You could qualify the generic types, i.e. 

A<T0, T1 super MyDefaultType> {
   public A(T0 t0) {
    this(t0, new MyDefaultType());
   }
}

You can't use T1 extends MyDefaultType since if you define a subclass, a MyDefaultType instance would not be compatible with the type of T1.

Improve this answer

2 Comments

+1 for reminding me of the super keyword in generics. I can honestly say that it slipped my mind - I don't believe I have ever needed it... and I don't really think it would help here, either. The usage you suggest implies a linear class hierarchy which is not my case.
@thkala yes, I suspected that would not solve your problem. However, I don't quite get how you create the default values if you don't know their types beforehand. Do you want to use reflection?
1

"Most instances" is the root problem.

Either T1 is a parameterized type or not. The single-argument constructor presumes both. Therein lies the problem.

The subclass solution solves the problem by making all instances satisfy T1=String.

A named constructor / factory method would also solve the problem, by ensuring T1=String.

    public static <T0> A<T0,String> makeA( T0 t0 ) {
       return new A<T0,String>( t0, "foo" );
    }
Improve this answer

1 Comment

+1 for pointing out the inherent contradiction in this issue. In my case it may just be worth it to go through the third-party code and stop it from using constructors blindly.
0

Is there a way to declare a constructor that forces one or more of the type parameters to a specific type? Something with the same effects as using a subclass, but without the hassle?

I believe it is impossible. Think about this. Developer defines class that can be generic, i.e. the type of parameter is defined during creating the object. How can the developer define constructor that forces user to use specific type of the parameter?

EDIT: If you need this you have to create factory or factory method that creates instances of this class with predefined parameter type.

Improve this answer

Comments

0

Subclass it. As far as I've ever been taught, that's one of the great features of OOP. Enjoy it. Disk space is cheap.

If it's an issue with future maintenance of the code, consider making the original class abstract, and creating two subclasses off of it (one with the double-generic constructor, and one with the single.

Improve this answer

2 Comments

Inheritance is arguably one of the least great features of OOP. I'd go so far as to suggest that is entirely optional (not in Java, obviously).
Hmm... I honestly fail to see how making two subclasses instead of one would help with maintenance to the degree you seem to imply.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.