Genericity and Inheritance

[Ricky58]

I am facing a problem quite unique I put you below.
Consider first the following abstract class:

public abstract class Lattice<E extends Pattern> {
public Lattice () {}
public abstract E meet(E pattern1, E pattern2);
public abstract E join(E pattern1, E pattern2);
public abstract boolean isSubsuming(E pattern1, E pattern2);
public abstract Vector<E> getElements();
public abstract void addElement(E pattern);
}

and the following:

public abstract class Pattern implements Cloneable
{
public Pattern() {}
public abstract Pattern clone();
}

I use these two classes this way:

public class IntervalLattice extends Lattice<IntervalPattern> {
Vector<IntervalPattern> elements = new Vector<IntervalPattern> ();
//Here I give an implementation for each abstract method inherited. 
public boolean isSubsuming(IntervalPattern pattern1,IntervalPattern pattern2) 
//.... 
}

and

public class IntervalPattern extends Pattern
{
private double inf;
private double sup;
// Here I give a default constructor, and another to fill the fields 
//Then some methods of work not relevant to our problem 
}

The problem with that is that I often make as cast

Lattice<IntervalPattern> l = ...
IntervalLattice il = (IntervalLattice) l;

and this is very bad... not clean, very poorly reusable, and finally not at all generic. In fact, I seek a way of having a single entity and Lattice <E> "ELattice.

I hope I have stated the problem clearly, feel free to say otherwise

[Katty]

It's not ugly, it is an upper cast. All Lattice are not IntervalLattice must therefore wait for you that the conversion fails.

[Ricky58]

Thank you. Yes, I quite agree with you, but there is not any lattice, Lattice is a <IntervalPattern>. So, I modeled wrong because it has redundancy and cast, but I can find no way to avoid ...

I'm not saying that the cast are not good, I'm just saying that I'd like to do without

[kelfro]

If in your code you have only one variant of Lattice <IntervalPattern> is IntervalLattice, then you can declare the variable as type IntervalLattice, you should not do the cast!

Otherwise it's like Katty says that you have several kinds of Lattice <IntervalPattern> with whom you work, one of which is IntervalLattice and there you have to actually make a cast if you put them all in the same bag. Otherwise you can always store them in different collections and use variables of the corresponding type.

On the other hand if any class that implements the interface extends Lattice <E Pattern> (yes you have declared as abstract class but you should make an interface) method declares additional public or she says but you do not use them in most operations, so you can work directly in your code with the interface, ie with variables of type Lattice <IntervalPattern> and you have no need to cast except when you have access to these methods which are not in the interface.

Otherwise, it's crazy the number of people who continue to use Vector.

[Ricky58]

Thank you, here is an example that exhibits better my problem

public class Lattice<E extends Pattern> extends Vector<E> {
private static final long serialVersionUID = 1L;
public E meet (E p, E q)
{
 return (E) p.methode(q);  // here I am compelled to cast, what I try to avoid
}
public static void main (String[] args){
 Lattice<Interval> l  = new Lattice<Interval>();
 l.add(new Interval());
}
}

So I missed something in the generics, and I can not find anything ...
Thank you!