Discussion :

[Miaou le chat thon]

Bonjour à tous,

Je suis un tout nouveau pratiquant du Java et je me vois déjà confronté à quelque chose que je ne comprends pas du tout...

Voici la définition d'une classe :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class AbstractEdge<ActualEdgeType extends AbstractEdge<ActualEdgeType, VertexType>, VertexType extends AbstractVertex<ActualEdgeType, VertexType>> implements GraphEdge<ActualEdgeType, VertexType> {
 
    private VertexType source;
    private VertexType target;
    private int label;
    private ActualEdgeType nextOutgoingEdge;
    private ActualEdgeType nextIncomingEdge;
 
    public AbstractEdge(VertexType source, VertexType target) {
        //compiled code
        throw new RuntimeException("Compiled Code");
    }
 
}

La partie que je ne me représente pas du tout (mais pas du tout...) est celle-ci :

class AbstractEdge<ActualEdgeType extends AbstractEdge<ActualEdgeType, VertexType>

Comment AbstractEdge peut-il hériter de lui-même ? Je ne comprends pas comment ces objets peuvent s'instancier ni comment ils sont représentés, notamment, en UML, comment serait décrite cette classe ?

Ensuite, ActualEdgeType et VertexType sont des classes "temporaires" ? Car j'ai, là aussi, du mal à comprendre comment je peux étendre une classe dans la définition-même d'une classe...

Je vous remercie d'avance de toute l'aide que vous pourrez m'apporter !

Bonne journée à tous

[Rei Ichido]

1. Il ne s'agit pas d'héritage récursif, mais de paramétrisation de type générique. Tes types étant plutôt lourds, je fais une comparaison facile. Si tu veux faire une liste de liste, tu fais une List<List<Object>>. Ce n'est pas de la récursion !

2. Il ne s'agit que du typage générique. Je te conseille la FAQ.

[Miaou le chat thon]

J'avais en effet finit par comprendre que c'était un Generic et non un héritage. Cependant, même sachant cela, je n'arrive toujours pas à conceptualiser la chose.

Dans List<List<Float>>, aucun soucis conceptuel. Je crée une liste qui contient une liste qui, elle-même, contient des float.
Mais ici, je ne comprends vraiment pas comment cela peut fonctionner. Quand je crée un AbstractEdge, celui-ci doit être composé d'un ActualEdgeType et d'un VertexType. Or, ActualEdgeType est (et c'est sans doute là que je dois avoir tort) lui-même de type AbstractEdge, non ? Si oui, je ne comprends pas de quoi est composé le tout premier AbstractEdge que je dois créer !

Mais je vais y arriver, je vais continuer à y réfléchir et ça finira bien par rentrer !

En tout cas, merci de m'aider, bonne soirée

[Rei Ichido]

Le typage générique n'est pas forcément une relation de composition, il s'agit plus de laisser quelque chose de (semi-)libre, mais "fixé" à l'interieur d'une instance donnée.

Par exemple on peut imaginer un Comparator<Comparator<String>> qui comparerait des comparateurs de String.

[Miaou le chat thon]

Ok, je crois que je cerne un peu mieux ce que cela signifie.

Pourriez-vous me dire si mon explication (pour moi-même) tient la route ou si je fais totalement fausse route ?

Merci

[professeur shadoko]

Code :

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

public class AbstractEdge<ActualEdgeType extends AbstractEdge<ActualEdgeType, VertexType>, VertexType ...

peut se lire de la manière suivante: pour toute sous-classe de nom "LaSousClasse" seule cette classe peut prendre la place du paramètre-type "ActualEdgeType".
donc si par exemple une méthode est définie par "méthode(ActualEdgeType arg)" pour la sous-classe le compilateur vérifiera que c'est l'appel "méthode(LaSousClasse)" qui est passé.
Cette technique, bien que bizarre, est très pratique.
par exemple je l'ai utilisée pour un type Monnaie: la classe abstraite comporte une méthode de comparaison (compareTo) mais on en peut comparer des Euros qu'avec des Euros et des Dollars qu'avec des Dollars (pas des Euros avec des Dollars: les deux sont sous-classes de Monnaie)

[Miaou le chat thon]

Ok merci, c'est donc bien ce que j'avais finit par comprendre. Je trouve ça assez difficile à comprendre pour le moment mais je suppose que ça viendra à force de pratiquer et de le voir (venant de PHP, c'est pas évident comme approche).

En tout cas, merci bien à tous les deux !

[tchize_]

Faut avouer que c'est pas l'utilisation la plus nette que j'aie vue de l'utilisation des Generic
En simplifiant, on a ça, mais ça reste

Code :

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

public class AbstractEdge<T extends AbstractEdge<T, U>, U extends AbstractVertex<T, U>> implements GraphEdge<T, U>

et là t'as un gros gros gros problème pour type les classes concretes, je suis curieux de voir la tête de la déclaration, parce que j'arrive pas à trouver comment créer une classe qui respecte ces règles de generics.

[Miaou le chat thon]

Bon je suis, quelque part, rassuré de voir que finalement, c'est presque normal que je n'ai pas compris facilement. Et heureusement, que j'en verrai peu alors !

Faut avouer que c'est pas l'utilisation la plus nette que j'aie vue de l'utilisation des Generic
En simplifiant, on a ça, mais ça reste

Code :

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

public class AbstractEdge<T extends AbstractEdge<T, U>, U extends AbstractVertex<T, U>> implements GraphEdge<T, U>

et là t'as un gros gros gros problème pour type les classes concretes, je suis curieux de voir la tête de la déclaration, parce que j'arrive pas à trouver comment créer une classe qui respecte ces règles de generics.

Pour en voir une utilisation, il suffit de télécharger findbugs qui est un logiciel d'analyse statique écrit en Java. La partie que je vous ai "présentée" concerne les graphes d'appels. Vous comprendrez sans doute mieux que moi car, pour ma part, maintenant que j'ai "compris" ce que signifiait la déclaration, je vais devoir m'amuser à comprendre comment on peut s'en servir...

Exemple de typages d'une classe concrète :

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public class InterCallGraphEdge extends AbstractEdge<InterCallGraphEdge, InterCallGraphNode> {
	//The CallSite
	private CallSite callSite;
 
	/**
        * Constructor
        */
	InterCallGraphEdge(InterCallGraphNode source, InterCallGraphNode target) {
		super(source, target);
	}
 
	/**
        * Set the call site
        */
	void setCallSite(CallSite callSite) {
		this.callSite = callSite;
	}
 
	/**
        * Get the call site
        */
	public CallSite getCallSite() {
		return callSite;
	}
 
	/**
        * Get the calling method
        */
	public Method getCallingMethod() {
		return getSource().getMethod();
	}
 
	/**
        * Get the called method
        */
	public Method getCalledMethod() {
		return getTarget().getMethod();
	}
 
	/**
        * Get the calling method's class
        */
	public JavaClass getCallingClass() {
		return getSource().getJavaClass();
	}
 
	/**
        * Get the called method's class
        */
	public JavaClass getCalledClass() {
		return getTarget().getJavaClass();
	}
}

On peut trouver cette classe ici

[tchize_]

ha oui tiens, on en apprend tous les jours, c'est quand même un typage de cinglé

[Robin56]

Ok merci, c'est donc bien ce que j'avais finit par comprendre. Je trouve ça assez difficile à comprendre pour le moment mais je suppose que ça viendra à force de pratiquer et de le voir (venant de PHP, c'est pas évident comme approche).

Rassure toi, c'est pas très courant de voir quelque chose d'aussi tordu. Ne te bloque pas sur cet aspect plutôt spécifique.