Discussion :

[TiTiSeb]

Bonjour à tous,

Je vous sollicite pour un point sur l'utilisation des generic en JAVA qui m'agace un peu .

Voici la structure de mes class:

Code :

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

1
2
3
4
5
6
7
public abstract class FieldItem <S extends FieldItem<S,T>, T extends FieldData> extends PrimitiveShape implements FieldData, ItemGroup<Long>, Cloneable{...}
 
public class FieldComponent extends FieldItem<FieldComponent, FieldPoint>{...}
 
public class FieldPlanar extends FieldComponent {...}
 
public abstract class FieldListItem <S extends FieldListItem<S,T>, T extends FieldItem<T, ?>> extends FieldItem<S,T>{...}

Je cherche à faire une class pour contenir une liste de FieldComponent herittant de FieldListItem.
Puis une autre class pour contenir une liste de FieldPlanar héritant de cette dernière class (d'où le generic en paramètre de cette class)

Voici ce que j'aimerai donc écrire:

Code :

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

public abstract class FieldListComponent<T extends FieldComponent> extends FieldListItem<FieldListComponent<T>, T>{...}

Or le compilateur me dit que type T (en rouge) n'est pas compatible:
"Bound mismatch: The type T is not a valid substitute for the bounded parameter <T extends FieldItem<T,?>> of the type FieldListItem<S,T>"

J'arrive à comprendre pourquoi (même si je trouve cela chiant ).
Le type T attendu doit être un type T extends FieldItem<T, FieldPoint> or je lui donne un type T extends FieldComponent qui est un FieldItem<FieldComponent, FieldPoint>.
Donc il voit que le Type T sera différent de FieldComponent même si il en hérite.

Le problème vient du fait de la déclaration de mon type FieldListItem qui a en deuxième paramètre généric T extends FieldItem<T, ?>.
Même si je pense avoir isolé le problème je n'ai pas de solution. Ou du moins pas convenable.

Voici ce que pourait faire:

Code :

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

public abstract class FieldListComponent<T extends FieldItem<T, FieldPoint>> extends FieldListItem<FieldListComponent<T>, T>{...}

Toutefois cette définition m'impose de "caster" toute mes méthodes utilisant des FieldItem<T, FieldPoint> en FieldComponent.
Or c'est un peu le but d'utiliser les generic d'éviter ce travail.

Merci d'avance pour toute information pouvant me faire avancer sur ce problème.

Sébastien.

[tchize_]

Le problème il est ici:

Code :

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

public abstract class FieldItem <S extends FieldItem<S,T>, T extends FieldData>

Je suppose que l'idée c'est de créer une méthode qui retourne le type réel afin de chainer des appels. C'est bien mais ça t'enchaine aussi.

Quand tu fais ça:

Code :

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

public class FieldComponent extends FieldItem<FieldComponent, FieldPoint>

Tu verouille le type pour les sous-classes. Ca permet d'écrire des sous classes plus simplement mais ça pert aussi l'idée de base de ton FielItem

par exemple tu fais un

Code :

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

public class MyFieldComponent extends FieldComponent

mais ceci n'est pas un FieldItem<MyFieldComponent,FieldData>, c'est un FieldItem<FieldComponent,FieldData>, les méthodes ne retourneront donc pas des MyFieldComponent et tu devra caster.

Tu dois garder ton typage jusque l'instanciation avec ton système. On arriverais à un truc dans ce gout là, probablement à ajuster.

Code :

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

1
2
3
4
5
6
 
public abstract class FieldItem <S extends FieldItem<S,T>, T extends FieldData> extends PrimitiveShape implements FieldData, ItemGroup<Long>, Cloneable{...}
public class FieldComponent<S extends FieldComponent<S,T>, T extends FieldPoint> extends FieldItem<S, T>{...}
public class FieldPlanar extends FieldComponent<FieldPlanar,FieldPoint> {...}
public abstract class FieldListItem <S extends FieldListItem<S,T,U>, T extends FieldItem<T, U>, U extends FieldData> extends FieldItem<S,T>{...}
public abstract class FieldListComponent<S extends FieldComponent<S,T>, T extends FieldPoint> extends FieldListItem<FieldListComponent<S,T>, S, T>{...}

[TiTiSeb]

Bonjour Tchize_ et merci pour ta réponse.

Le problème il est ici:

Code :

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

public abstract class FieldItem <S extends FieldItem<S,T>, T extends FieldData>

Je suppose que l'idée c'est de créer une méthode qui retourne le type réel afin de chainer des appels. C'est bien mais ça t'enchaine aussi.

Oui effectivement cette class représente un objet pouvant contenir une liste d'objets du même type de base.
ex : mon type de base est un "contenant" pouvant contenir une liste de "contenant".
Si on créé un objet "boite" héritant de "contenant", cet objet est un "contenant" pouvant contenir une liste de "contenant".

Mon type de base "contenant" possède deux méthodes pour ajouter soit un type de base "contenant" soit le type fils donc une liste de type de base (= type "boite").
Pour protéger cette dernière méthode et ne pas pouvoir ajouter ensemble des fils de type diffèrent, je passe en paramètre le type du fils.
Ainsi un type "boite" ne peux ajouter que des types "contenant" et des types "boite"
Si j'ai un type "caisse" héritant de "boite", il pourra nativement ajouter des "caisses" et des "contenants"
...

voici la déclaration des méthodes:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
	public abstract boolean addItem(S item, FUSIONOPERATION op);
 
	public boolean addItem(S item){
		return addItem(item, FUSIONOPERATION.KEEPLASTVALUE);
	}
 
	public abstract boolean add(T data, FUSIONOPERATION op);
 
	public boolean add(T data){
		return add(data, FUSIONOPERATION.KEEPLASTVALUE);
	}

Voici pour justifier l'utilisation du passage en paramètre du type fils.

Maintenant ce que tu proposes n'est pas possible dans mon application.
J'ai deux types d'objet à manipuler (FieldComponent et FieldPlanar).
Note : FieldPlanar hérite de FieldComponent.
Ces deux types ne peuvent pas être générique (j'ai besoin de les instancier).

J'ai un objet liste qui doit pouvoir stoker indifféremment les deux types.
Actuellement cet objet est de type FieldListComponent.

Mon problème reste donc entier.
j'espère que ces informations supplémentaires vous apporterons des idées, n'hésitez pas.

Encore merci.
Sébastien.

[tchize_]

Maintenant ce que tu proposes n'est pas possible dans mon application.
J'ai deux types d'objet à manipuler (FieldComponent et FieldPlanar).
Note : FieldPlanar hérite de FieldComponent.
Ces deux types ne peuvent pas être générique (j'ai besoin de les instancier).

Je ne vois pas le rapport, ils peuvent être générique et instanciable. Regarde tout l'api collection. Tout est générique et tout est instanciable. C'est au moment d'instancier que tu dois verrouiller le type, pas dans la déclaration de classe. Sinon comme tu l'a constaté, l'utilisateur de la classe n'a plus le controle sur les signatures.