通用List类型的getter和setter上的接口

Question

We're trying to extract an interface in a library containing versioned sets of beans (used in an XML webservice). The models themselves use only other models from the same version.

There are mostly only getters and setters, and as the versions are quite similar, the process works well most of the time. There is a bit of a hiccup as it comes to List types though.

Let's take an example:

public class Attribute implements IAttribute

This is used elsewhere:

public class Product implements IProduct {
    List<Attribute> products = new ArrayList<Attribute>();
}

The interface IProduct has this getter and setter:

public interface IProduct {
    public abstract List<? extends IAttribute> getAttributes();
    public abstract void setAttributes(List<? extends IAttribute> attributes);
}

The class Product then has this getter and setter:

public List<Attribute> getAttributes() {
    return attributes;
}

public void setAttributes(List<? extends IAttribute> attributes) {
    this.attributes = attributes;
}

There is, of course, an error on the setter: the field attributes in Product is a List of Attribute, and is narrower than a List of wildcard extending IAttribute. It feels like a catch 22 though. If we widen the declaration of the field itself, we lose the benefit of specificity. There are then also issues implementing an add method (addAttribute(Attribute attribute)).

One ugly solution would be to iterate over the List of wildcard extending IAttribute, do type checking and add only if the actual type of the objects inside are Attribute of the correct version.

public void setAttributes(List<? extends IAttribute> attributes) {
    this.attributes = new ArrayList<Attribute>();
    for (Attribute attribute : attributes) {
        if (!(attribute instanceof Attribute)) {
            throw new IllegalArgumentException();
        } else {
            this.attributes.add((Attribute)attribute);
        }
    }
}

Is there a better, more robust, more elegant way to do this?

Answer 1

I have the feeling that IProduct should be a generic interface:

public interface IProduct<T extends IAttribute> {
    public abstract List<T> getAttributes();
    public abstract void setAttributes(List<T> attributes);
}

and that the Product should be defined as

public class Product implements IProduct<Attribute> {
    private List<Attribute> attributes;

    @Override
    public List<Attribute> getAttributes() {
        return attributes;
    }

    @Override
    public void setAttributes(List<Attribute> attributes) {
        this.attributes = attributes;
    }
}