Java在泛型类型参数中使用关系

Question

Currently I have this setup:

public abstract class Manager<B extends Bean, C extends AbstractConstraint> { 
    public final int insert(B b);

    public final boolean update(B b);

    public final boolean delete(B b);

    public final B get(C... c);

    public final List<B> search(C... c);

    public final List<B> getAll();
}

public interface Bean { }

public abstract class AbstractConstraint { }

concretely used in:

public class AccountManager extends Manager<AccountBean, AccountConstraint> { }

public class AccountBean implements Bean { }

public class AccountConstraint extends AbstractConstraint { }

A few remarks:

• Bean is the lowest entity possible. This is the direct instance of a row from a table in the database.
• A concrete implementation of AbstractConstraint should not implement/extend a concrete implementation of Bean , unless I am mistaken here.

Via the Manager I can be sure that all you can pass in is a concrete version of <Bean, AbstractConstraint> .

However currently it is entirely valid to define this:

public class BogusManager extends Manager<AccountBean, CharacterConstraint> { }

which makes no sense at all, how can I restrict the code such that this is not allowed anymore?

I think that I have two options:

1) Change AccountConstraint to AccountConstraint<AccountBean> , but I do not think that it would be valid since the type argument would not be used in AccountConstraint itself.

2) Have a way to define a relation R and let Manager check if <B, C> is in relation R , in other words you would need to check R(B, C) . But you would also need to be able to define a relation R<AccountBean, AccountConstraint> then, which would mean that R = Manager , but I don't think that it could be true. Anyway, how would I be able to implement this if it would be true?

Regards.

Answer 1

Your first option is legal, you do not need to use type variable.

For the second option, you need to pass class instances of bean and constraint to manager constructor which will check if this is legal pair. As far as I know there is no way to implement such check in source only, ie add declarative constraint to source code.

Answer 2

Something like this should satisfy a compile-time version of option 2:

interface Witness< B, C > {}

public final class AccountConstraintsForAccountsOnly implements Witness< AccountBean, AccountConstraint > {}
public final class CharacterConstraintsForCharactersOnly implements Witness< CharacterBean, CharacterConstraint > {}

public abstract class Manager< B extends Bean, C extends AbstractConstraint, W extends Witness< B, C > { ... }

Answer 3

For Option 1

 //add a Type    
abstract class AbstractConstraint<T>{}
//Type is tied to your Concrete bean
abstract class Manager<B extends Bean, C extends AbstractConstraint<B> >
{
.
.
.
}

While implementing the Constraint , state what type of Constraint it is, by just passing the Bean Type

Ex.

 class BogusBean implements Bean { }
 class BogusConstraint extends AbstractConstraint<BogusBean> { }
 class BogusManager extends Manager<BogusBean, BogusConstraint> {}