Discussion :

[atnnn]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[broumbroum]

tu mets Iterator<Point> ...

[atnnn]

C'est justement ce que je cherche a eviter.

[yann2]

Bonjour

J'imagine que la solution

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

classe UnmodifiablePoint

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[adiGuba]

Salut,

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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++

[spekal]

En tous les cas tu peux écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[atnnn]

Merci,

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