Advanced question about generics

[Vincent Cantin]

Hello,

I have a class Server<C extends Connection> that accepts some connections
are for each of them creates an instance of C.

Problem : the implementation of the class need to have C.class in order to
create its instance but it doesn't know it unless I ask the user of my class
to give it in parameter.

So the user of the class write something like that :

Server server = new Server<MyConnection>(MyConnection.class);

but I would like him to only write something like that :

Server server = new Server<MyConnection>();

Is there something in the language of Java 1.5 that can do implicitly what I
want ?

Thank you,
Vincent

 

[xarax]

Hello,

I have a class Server<C extends Connection> that accepts some connections
are for each of them creates an instance of C.

Problem : the implementation of the class need to have C.class in order to
create its instance but it doesn't know it unless I ask the user of my class
to give it in parameter.

So the user of the class write something like that :

Server server = new Server<MyConnection>(MyConnection.class);

but I would like him to only write something like that :

Server server = new Server<MyConnection>();

Is there something in the language of Java 1.5 that can do implicitly what I
want ?

I believe there is nothing to do exactly what you
want as described.

However, you may want to consider passing a factory
object to the constructor. The factory object will
instantiate an object of the correct type. The factory
object should be declared generically (via an interface
type) so that the compiler can verify that it is delivering
the correct type.

 

[Michael Borgwardt]

So the user of the class write something like that :

Server server = new Server<MyConnection>(MyConnection.class);

but I would like him to only write something like that :

Server server = new Server<MyConnection>();

Is there something in the language of Java 1.5 that can do implicitly what I
want ?

That's IMO not possible, because generics don't exist on the bytecode level,
they're purely for the sake of the compiler. That means what gets *executed*
in the end is:

Server server = new Server();

With to MyConnection added whenever a method of server is called that
requires them.

 

[Jesper Nordenberg]

Hello,

I have a class Server<C extends Connection> that accepts some connections
are for each of them creates an instance of C.

Problem : the implementation of the class need to have C.class in order to
create its instance but it doesn't know it unless I ask the user of my class
to give it in parameter.

So the user of the class write something like that :

Server server = new Server<MyConnection>(MyConnection.class);

but I would like him to only write something like that :

Server server = new Server<MyConnection>();

Is there something in the language of Java 1.5 that can do implicitly what I
want ?

No, not possible because of type erasure. A flexible solution is to
pass a factory object that create the instances, for example:

Server server = new Server<MyConnection>(new Factory<MyConnection>() {
public MyConnection create() {
return new MyConnection();
}
});

public interface Factory<T> {
T create();
}

This has several advantages over directly calling a constructor using
reflection.

/Jesper Nordenberg

 

[Michal Kleczek]

No, not possible because of type erasure. A flexible solution is to
pass a factory object that create the instances, for example:

Server server = new Server<MyConnection>(new Factory<MyConnection>() {
public MyConnection create() {
return new MyConnection();
}
});

public interface Factory<T> {
T create();
}

This has several advantages over directly calling a constructor using
reflection.

/Jesper Nordenberg

Hi,
actually it is the same as the original solution - but more verbose.
To avoid wiriting "MyConnection" twice you should use a static generic
method:

public class Server<T extends Connection> {

public static <S> Server<? extends S> create(Class<S> clazz) {
return new Server<S>(clazz);
}

public Server(Class<T> c) {
//...
}

}

Client code:

Server<MyConnection> s = Server.create(MyConnection.class);

Cheers,
Michal

 

[Vincent Cantin]

Thank you for all the answers, it was usefull for me.

Vincent

 

[Adam Jenkins]

Hi,
actually it is the same as the original solution - but more verbose.
To avoid wiriting "MyConnection" twice you should use a static generic
method: [snip]
Client code:

Server<MyConnection> s = Server.create(MyConnection.class);

I still count two "MyConnection"s in that statement, so I'm not sure
what you've gained.

 

[Jesper Nordenberg]

Hi,
actually it is the same as the original solution - but more verbose.

No, it's not the same. The Factory solution is more flexible because
it allows you to use any constructor of the MyConnection class, or
even not to create a new object at all. For example:

final MyConnection connection = getConnection();

Server server = new Server<MyConnection>(new Factory<MyConnection>() {
public MyConnection create() {
return connection;
}
});


Server server2 = new Server<MyConnection>(new Factory<MyConnection>()
{
public MyConnection create() {
return new MyConnection("This is an argument!");
}
});

This is something you can't do by just passing the MyConnection.class
object.

/Jesper Nordenberg

 

[Michal Kleczek]

No, it's not the same. The Factory solution is more flexible because
it allows you to use any constructor of the MyConnection class, or
even not to create a new object at all. For example:

final MyConnection connection = getConnection();

Server server = new Server<MyConnection>(new Factory<MyConnection>() {
public MyConnection create() {
return connection;
}
});


Server server2 = new Server<MyConnection>(new Factory<MyConnection>()
{
public MyConnection create() {
return new MyConnection("This is an argument!");
}
});

This is something you can't do by just passing the MyConnection.class
object.

/Jesper Nordenberg

Hi,
I agree with you it's more flexible, but has nothing to do with generics.
Michal

 

[Michal Kleczek]

Hi,
actually it is the same as the original solution - but more verbose.
To avoid wiriting "MyConnection" twice you should use a static generic
method:
[snip]

Client code:

Server<MyConnection> s = Server.create(MyConnection.class);

I still count two "MyConnection"s in that statement, so I'm not sure
what you've gained.

Hi,
It's still better than three in this statement:

Server<MyConnection> s = new Server<MyConnection>(MyConnection.class>;

Michal