TP Java Avancé 17/03/2004 -- Ing2 SIGL1 -- Exercice
======================================================

I. Modalités de rendu
---------------------

    - Date/heure	: mardi 23/03/2004 à 14:00
    - Répertoire	: ~/rendu/java/sigl1/reflect
    - Fichiers		: ClassInfo.java*
    - Droits		: 700 répertoires, 600 fichiers

(*) Gardez la clause package (org.insia.reflect) mais ne me rendez que le
fichier, sans le placer dans un sous-répertoire correspondant. Juste à même le
répertoire de rendu. Evidemment, ne TRAVAILLEZ PAS dans votre répertoire de
RENDU.


------------------------------------------------------------------------------
Principe
------------------------------------------------------------------------------

Le but de l'exercice est de mettre en oeuvre le principe de reflexivité.

Vous réaliserez une petite classe qui aura pour but de récupérer toutes les
informations conçernant une classe ( le nom de cette dernière sera passé en
paramètre ).

Pour cela, vous aurez à réaliser une classe ClassInfo, qui permet d'obtenir,
à la norme et uniquement avec des noms courts, le squelette de n'importe
quelle classe ou interface Java accessible par le chargeur de classe.

Vous devez afficher tous les membres : publics, "package", protégés et privés.

IMPORTANT : dans une classe, on peut avoir de nombreux éléments : champs,
constructeurs, méthodes, mais aussi classes membres (statiques ou non),
pour lesquelles l'ensemble de la problématique se repose, récursivement !
Voyez par exemple String ou Map, qui ont des classes/interfaces membres,
publiques ou non. Il peut arriver que des classes, champs ou méthodes soit
anonymes (classes anonymes, champs ou méthodes apparaissant dans des classes
anonymes...). Leur nom "court" (voir plus loin "getShortName") est alors un
entier décimal. Vous ignorerez systématiquement ces éléments.

IMPORTANT : vous n'avez pas à gérer les classes "spéciales" (en entrée en
tout cas) : tableaux et primitives. Uniquement les "véritables" classes et
les interfaces. En revanche, des champs, méthodes ou argument pourraient bien
sûr avoir ces "classes spéciales" comme type, et vous devez l'afficher
correctement.

Par ailleurs, il est très souhaitable que vous respectiez les lignes vides
présentes dans les exemples de sortie fournis dans le répertoire du présent
sujet. En résumé : ligne vide autour des constructeurs, méthodes et classes,
mais :

    - pas de ligne vide entre les champs
    - pas de ligne vide autour de la classe "top-level" (celle dont on a
      donné le nom en ligne de commande)
    - pas de ligne vide immédiatement à l'intérieur d'une classe (après le
      "{" et avant le "}" qui la délimitent).

------------------------------------------------------------------------------
La classe ClassInfo
------------------------------------------------------------------------------

Recommendations techniques
- - - - - - - - - - - - - -

- Vous utiliserez un StringBuffer pour agréger la représentation texte au
  fur et à mesure de sa définition

- Vous découperez votre code autour de petites méthodes utilitaires précisées
  ci-dessous.

- Votre classe ne doit pas être instanciable de l'extérieur ni extensible.
  Elle est utilisée uniquement au travers d'une méthode statique publique, qui
  doit être thread-safe (pouvoir être invoquée en parallèle par plusieurs
  threads avec plusieurs noms de classes, et renvoyer un résultat correct pour
  tous).

La seule méthode publique autorisée est donc :

    public static String getClassText(final String className)
	throws ClassNotFoundException

Elle prend en paramètre le nom complet (i.e. paquet compris) de la classe à
représenter. S'il est impossible de trouver la classe, laissez se propager
une exception ClassNotFoundException.

Les méthodes privées que nous vous recommandons d'implémenter pour faciliter
votre travail sont :

	- String getShortName(final String className)

	  retourne le nom court de className :
        "java.lang.String" -> "String".
        "java.util.Map$Entry" -> "Entry".

	- String getModifierString(final int modifiers)

      Renvoie la chaîne de modificateurs dans l'ordre suivant :
      public/private/protected, abstract, static, transient,
      volatile/final, synchronized, native, strictfp.

Nous ne saurions trop vous recommander de créer des méthode dédiées à la
construction du texte d'un constructeur, d'une méthode, d'un champ, etc., en
disposant d'une indentation de base à chaque fois (pour les classes internes
notamment).

L'ORDRE OBLIGATOIRE AU SEIN D'UNE CLASSE EST : champs, classes, constructeurs,
méthodes. A chaque fois, vous placerez par ordre ALPHABETIQUE INSENSIBLE
A LA CASSE, sans vous soucier de séparer statique et non-statique.


------------------------------------------------------------------------------
Ressources
------------------------------------------------------------------------------

http://profs.insia.org/~tdd/sigl1/java
http://java.sun.com/docs/books/tutorial/reflect/index.html

-- FIN DE SUPPORT TP --