Generics et Types Incompatibles

Version imprimable

Je veut permettre aux utilisateurs de ma classe d'iterer sur les points qu'elle contient, mais pas de changer ces points. J'ai donc cree une interface StaticPoint:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
interface StaticPoint {
    int getx();
    int gety();
}
 
class Point implements StaticPoint{
    public int x, y;
 
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    public int getx(){ return x; }
    public int gety(){ return y; }
}

Dans ma classe j'ai:

Code:

1
2
3
4
5
6
 
    ArrayList<Point> points;
 
    public StaticPoint point(int i){
        return points.get(i);
    }

Tout cela fonctionne bien, mais pas mon iterateur ne compile pas:

Code:

1
2
3
4
 
    public Iterator<StaticPoint> iterator(){
        return points.iterator();
    }

Code:

1
2
3
4
5
6
incompatible types
found   : java.util.Iterator<Point>
required: java.util.Iterator<StaticPoint>
        return points.iterator();
                              ^

Est-il possible de contourner cette limitation?

19/01/2007, 22h51
broumbroum

tu mets Iterator<Point> ...
20/01/2007, 00h37
atnnn

C'est justement ce que je cherche a eviter.

Bonjour

J'imagine que la solution

Code:

1
2
3
4
5
6
 
    ArrayList<StaticPoint> points;
 
    public StaticPoint point(int i){
        return points.get(i);
    }

ne te conviendra pas !

Dans tout les cas, je ne pense pas que Point doit hérité de StaticPoint ! Que répond tu à la question :
Point est-il un point statique ?

La réponse est évidemment non.

Je verrais plus quelque chose du genre...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public class UnmodifiablePoint extends implements StaticPoint {
 
    private Point point;
 
    public UnmodifiablePoint(Point p) {
        this.point = p;
    }
 
    public int getx(){ return p.getX(); }
    public int gety(){ return p.getY(); }
 
}

Code:

1
2
3
public StaticPoint point(int i){
    return new UnmodifiablePoint(points.get(i));
}

Code:

1
2
3
4
5
6
7
8
 
public Iterator<StaticPoint> iterator(){
        List<StaticPoint> listeStatique = new ArrayList<StaticPoint>(this.points.size());
        for (Point point : this.points) {
            listeStatique.add(new UnmodifiablePoint(point));
        }
        return listeStatique.iterator();
}

Question performance ce n'est pas trop ça ! Le mieux serait que tu crées ton propre Iterator de la manière suivante (Réponse complète et testée ;) ):

Classe Point

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
public class Point {
 
	private int x;
 
	private int y;
 
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
 
	public int getX() {
		return this.x;
	}
 
	public void setX(int x) {
		this.x = x;
	}
 
	public int getY() {
		return this.y;
	}
 
	public void setY(int y) {
		this.y = y;
	}
 
}

Interface StaticPoint

Code:

1
2
3
4
5
6
7
8
 
public interface StaticPoint {
 
	public int getX();
 
	public int getY();
 
}

classe UnmodifiablePoint

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class UnmodifiablePoint implements StaticPoint {
 
	private Point point;
 
	public UnmodifiablePoint(Point point) {
		this.point = point;
	}
 
	public int getX() {
		return point.getX();
	}
 
	/**
         * @return
         * @see test.StaticPoint#getY()
         */
	public int getY() {
		return point.getY();
	}
 
}

classe UnmodifablePointIterator

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
public class UnmodifiablePointIterator<T extends StaticPoint> implements
        Iterator<StaticPoint> {
 
	private Iterator<Point> pointsAIterer;
 
	public UnmodifiablePointIterator(List<Point> pointsAIterer) {
		this.pointsAIterer = pointsAIterer.iterator();
	}
 
	public boolean hasNext() {
		return this.pointsAIterer.hasNext();
	}
 
	public StaticPoint next() {
		Point point = this.pointsAIterer.next();
		UnmodifiablePoint unmodifiablePoint = new UnmodifiablePoint(point);
		return unmodifiablePoint;
	}
 
	public void remove() {
		this.pointsAIterer.remove();
	}
 
}

Classe EnsembleDePoints

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
public class EnsembleDePoints implements Iterable<StaticPoint> {
 
	private List<Point> points;
 
	public EnsembleDePoints() {
		this.points = new ArrayList<Point>();
	}
 
	public StaticPoint point(int i) {
		return new UnmodifiablePoint(this.points.get(i));
	}
 
	public Iterator<StaticPoint> iterator() {
		return new UnmodifiablePointIterator<StaticPoint>(this.points);
	}
 
	public void ajouter(Point p) {
		this.points.add(p);
	}
}

et le test :

Code:

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
		EnsembleDePoints ensembleDePoints = new EnsembleDePoints();
		ensembleDePoints.ajouter(new Point(1, 0));
		ensembleDePoints.ajouter(new Point(3, 4));
 
		for (StaticPoint staticPoint : ensembleDePoints) {
			System.out.println("[" + staticPoint.getX() + ","
			        + staticPoint.getY() + "]");
		}
}

Bon courage.

Salut,

Citation:

Envoyé par atnnn

Citation:

Envoyé par broumbroum

tu mets Iterator<Point> ...

C'est justement ce que je cherche a eviter.

Pourquoi ?
Pourquoi définir des interfaces si tu ne les utilises pas ?

L'erreur que tu obtiens est tout à fait normal car le type des deux listes n'est pas "compatible". Dans ton ArrayList<Point> tu pourrais très bien avoir autre chose qu'un StaticPoint (comme une autre classe fille de Point), et donc tu ne peux pas faire de telle conversion (en fait c'est possible en supprimant les generics lors de la conversion mais ce n'est pas très propre).

Enfin, je te conseille également d'utiliser des interfaces pour cacher l'implémentation des collections :
Code:

1 2 3 4 5 6 7 8 9 List<Point> points = new ArrayList<Point>(); public Point point(int i){ return points.get(i); } public Iterator<Point> iterator(){ return points.iterator(); }
a++

20/01/2007, 21h57
spekal
En tous les cas tu peux écrire :
Code:

1 2 3 4 5 public Iterator<? extends StaticPoint> iterator() { return points.iterator(); }
... mais cela te posera peut être d'autres problèmes, je ne sais pas ; prend la subsentifique moelle de toutes les suggestions, et tiens-nous au courant.
22/01/2007, 16h26
atnnn

Merci,

Je vais ecrire mon propre iterateur, base sur celui de yann.