What I want to do is the following:
public class DBManager<T extends Type , Q extends Query>{
T create(T t);
Collection<T> read(Q query);
T update(T t);
}
However, I only want instantiations of this class where T and Q are related. For instance, if T is AppleType, then I want Q to be AppleQuery and not PearQuery.
Is there a way to do this, or produce a similar behavior?
I tried Q extends T & Query, but that isn't allowed.
You cannot do that unless the types themselves have some kind of relation in the type system.
Since I don't know exactly what you want to do, it's hard to recommend something with precision, but it sounds like you might want to do something like this:
public abstract class Type {
...
}
public class AppleType extends Type {
...
}
public abstract class Query<T extends Type> {
public abstract T doQuery(); /* Or so? */
}
public class AppleQuery extends Query<AppleType> {
public AppleType doQuery() {...}
}
With such a formal relation from Query to Type, you could then define your DBManager as such:
public class DBManager<T extends Type, Q extends Query<T>> {
T read(Q id);
}
Since Q is not used in return types, you don't need it. Simply
interface DbManager<T extends Type>
T read(Query<? extends T> query)
where
interface Type
interface Query<T extends Type>
You could make everything generic:
public class Type<Q extends Query<? extends Type<Q>>
public class Query<T extends Type<? extends Query<T>>
public class DBManager<T extends Type<Q> , Q extends Query<T>>
public class Type<T extends Type<T, Q>, Q extends Query<Q, T>>, etc., to be useful.
There isn't multiple inheritance in Java. Why not just to do this?
public class Generic{
// Generic atributes and methods.
}
public class ClassA extends Generic{
// ClassA atributes and methods overwriting, if need it, the extended methods from Generic class.
}
public class ClassB extends Generic{
// ClassB atributes and methods overwriting, if need it, the extended methods from Generic class.
}
... // You can instantiate so many classes as you need. You can use the factory pattern.
TypeandQueryclasses?