Discussion :

[professeur shadoko]

Bonjour à toutes et à tous

voila un code de test qui m'ouvre des horizons Bizarre! vous avez dit bizarre?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
public static void main(String[] args) {
            Ellipse2D.Double ellipse = new Ellipse2D.Double();
            Class aClass = ellipse.getClass();
            Class[] interfazes = aClass.getInterfaces();
        System.out.println(Arrays.toString(interfazes));
            Rectangle rect = new Rectangle();
            aClass = rect.getClass();
            interfazes = aClass.getInterfaces();
        System.out.println(Arrays.toString(interfazes));
    }

Dans le deuxième cas on trouve l'interface Shape ... qu'on ne trouve pas dans le premier!
pourtant Ellipse2D.Double implante bien l'interface Shape!
ne me dites pas que ça ne marche pas avec les classes internes comme Double et qu'il faut remonter à la classe englobante!!!!!
C'est normal docteur ... ou c'est un bug?
parce que si c'est normal ... bonjour les codes à écrire pour gérer les cas généraux!

Merci de votre attention....

[tchize_]

Mmm ce n'est pas très clair dans la javadoc mais je pense que comme les autres méthodes de class cette méthode se concentre sur cette classe et pas ses parents. Il y a un indice dans la partie sur l'ordre des éléments retournés.

The order of the interface objects in the array corresponds to the order of the interface names in the extends clause of the declaration of the interface represented by this object.The order of the interface objects in the array corresponds to the order of the interface names in the extends clause of the declaration of the interface represented by this object.

De plus je pense que si tu implemente une interface qui elle même hérite d'une autre interface l'interface parent n'est pas visible dans le résultat. Les méthodes de class ne sont souvent pas recursives afin de pouvoir avoir une vue correcte sur l'arbre de la classe et ses parents.

[professeur shadoko]

... effectivement ne ressortent que les interfaces déclarées dans le source pas les interfaces héritées...
dur dur ... maintenant tu fais quoi pour connaître par introspection les interfaces implantées par une classe?
t'es obligé de remonter la hiérarchie des classes? pas pratique, pratique ... non seulement il faut se taper cette remontée mais savoir quand s'arréter?
c'est un peu dingue (et pas très satisfaisant: la propriété est bien là et documenté dans la javadoc NDD!)
scrongneugneu j'aime pas ça

edit: bon je sais écrire le code (avec un Set en remontant la hiérarchie jusqu'au bout ... ou presque) mais c'est nul et ça fait perdre du temps ...
et d'ailleurs c'est pas une propriété écrite dans le byte-code de la classe?

reNote: en analysant une classe on peut savoir par ex. quelles sont les méthodes définies mais aussi , si on veut, toutes les autres (héritées) ... (diffférences entre "Declared" et les autres) pourquoi cette option limitative pour les interfaces? étrange

[adiGuba]

Salut,

edit: bon je sais écrire le code (avec un Set en remontant la hiérarchie jusqu'au bout ... ou presque) mais c'est nul et ça fait perdre du temps ...

Autant utiliser l'API de Stream de Java 8, c'est plus sympa :

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
	/**
         * Retourne un Stream contenant le type courant et tous ses types parents.
         */
	public static Stream<Class<?>> classesOf(final Class<?> type) {
		Objects.requireNonNull(type);
		Iterator<Class<?>> iterator = new Iterator<Class<?>>() {
			private Class<?> current = type;
 
			@Override
			public boolean hasNext() {
				return this.current != null;
			}
 
			@Override
			public Class<?> next() {
				Class<?> result = this.current;
				this.current = result.getSuperclass();
				return result;
			}
		};
		return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
				iterator, Spliterator.ORDERED | Spliterator.IMMUTABLE
						| Spliterator.NONNULL), false);
	}
 
	/**
         * Retourne un Stream contenant toutes les interfaces distinctes
         * implémentées par cette classe ou ses classes parentes.
         */
	public static Stream<Class<?>> interfacesOf(final Class<?> type) {
		return classesOf(type)
				.flatMap(t -> Arrays.stream(t.getInterfaces()))
				.distinct();
	}

Exemple :

Code :

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

1
2
		interfacesOf(Ellipse2D.Double.class)
			.forEach(System.out::println);

a++

[tchize_]

reNote: en analysant une classe on peut savoir par ex. quelles sont les méthodes définies mais aussi , si on veut, toutes les autres (héritées) ... (diffférences entre "Declared" et les autres) pourquoi cette option limitative pour les interfaces? étrange

Parce que l'usage est différent? Si je veux appeler Machin.bidule(truc) par introspection, j'ai besoin effectivement de trouver la méthode / les méthodes bidule pour pouvoir appliquer manuellement les règles de la jvm afin de choisir la méthode appropriée comme l'aurait fait le compilateur. Même chose avec les fields.

J'ai du mal à voir un usage courant où tu aurais besoin de connaitre toute la liste des interfaces implémentées. Avec les interface et les classe héritées, on travaille autrement, on prend une classe et on regarde si elle est compatible avec un paramètre de méthode données. Pour ça on a isAssignableFrom.

Tu notera d'ailleurs que du coup ça se limite aux champs / méthodes publiques cette récursivité. Si tu veux toutes les méthodes protected, il faudra faire de la récursion.

On pourra regretter par contre que la méthode ne s'appelle pas "getDeclaredInterfaces"

[professeur shadoko]

J'ai du mal à voir un usage courant où tu aurais besoin de connaitre toute la liste des interfaces implémentées.

Hélas j'ai ... bon je vais pas rentrer dans les détails (c'est un truc lié à des ressources de configuration)
mais c'est bon j'ai trouvé une optimisation ... il se trouve que , par ailleurs, je dois remonter (partiellement) dans l'arbre d'héritage ... je vais donc collecter les interfaces au passage.
Merci à tous pour vos avis

[thelvin]

Je me souviens d'une fois, j'avais des interface Machin<A>
Et des abstract class Bidule implements Machin<String> ou abstract class Chose implements Machin<LocalDate>.

Et enfin beaucoup plus bas des pléthores de class Truc extends Machin.
Et il fallait que je détecte quand une instance implémentait Machin et quel type concret elle donnait à A.

J'ai pas trouvé de moyen simple et direct de faire ça, c'était assez galère -_-°.