Les conseils et astuces suivants fournissent quelques idées pratiques d'augmentation de votre productivité. Voir aussi Conseils et astuces pour la plateforme pour obtenir des conseils généraux pour Eclipse et Nouveautés de la version 3.6 (JDT) pour les fonctions de cette édition.
Edition | Restructuration | Recherche | Navigation | Vues | Divers | Débogage
| Assistant de contenu | Cet assistant fournit une
liste d'exécutions suggérées pour des chaînes saisies partiellement.
Dans l'éditeur Java, appuyez sur les touches Ctrl+Espace ou sélectionnez Editer >
Assistant de contenu.
|
| Assistant de contenu dans des commentaires Javadoc | L'assistant de contenu est
également disponible dans des commentaires Javadoc.
|
| Assistant de contenu pour les importations statiques | Pour obtenir des propositions de l'assistant de contenu pour des membres statiques, configurez votre liste de membres statiques favoris dans la page des préférences
Java > Editeur > Assistant de contenu > Page des préférences des favoris.
Par exemple, si vous avez ajouté
|
| Suppression de types dans l'assistant de contenu |
Pour que certains types n'apparaissent pas dans l'assistant de contenu, utilisez
la fonction de filtrage des types configurés dans la page des préférences
Java > Apparence > Filtres de type. Les types correspondant à
l'un de ces masques de filtre n'apparaîtront pas dans la boîte de dialogue
Ouverture d'un type et ne seront pas disponibles pour l'assistant de contenu,
les correctifs rapides et l'organisation des importations. Ces masques de filtre n'affectent pas les vues Package et Hiérarchie des types.
|
| Assistant de contenu pour l'exécution de variables, paramètres de méthode et noms de zone |
Vous pouvez utiliser l'assistant de contenu pour accélérer la création
de zones, de paramètres de méthode et de variables locales. Le curseur placé après le nom de type de la déclaration, appuyez sur les touches Ctrl+Espace ou utilisez Editer > Assistant de contenu.
Si vous utilisez un préfixe ou un suffixe de nom pour les zones, les
variables locales ou les paramètres de méthode, n'oubliez pas de le
spécifier dans la page des préférences
|
| Assistant de contenu pour variable de type non résolu | L'aide à la saisie de code fonctionne aussi pour les accès aux types qui n'ont pas encore été importés. Suivant la préférence
Java > Editeur > Assistant de contenu
> Ajouter une importation au lieu d'un nom qualifié, l'éditeur ajoutera automatiquement des importations ou dotera de noms qualifiés complets les types pour de telles propositions.
En appuyant sur ; dans le scénario suivant :
on obtient le résultat suivant :
|
| Assistant de contenu après une condition instanceof | L'assistant de contenu peut proposer des membres disponibles sur les types utilisés dans les conditions instanceof.
Eclipse ajoutera pour vous le transtypage lors de la sélection d'une telle proposition. |
| Conseils sur les paramètres | Avec le curseur placé sur un
argument de méthode, vous pouvez voir une liste de conseils sur les paramètres. Dans l'éditeur Java, appuyez sur les touches Ctrl+Maj+Espace ou sélectionnez Editer > Assister de contenu > Conseils sur les paramètres.
|
| Assistant de contenu sur des classes anonymes | L'assistant de contenu
fournit également de l'aide lors de la création d'une classe anonyme. Le curseur étant placé après "nouveau" et le début d'une classe abstraite ou d'un nom d'interface, appuyez sur Ctrl+Barre d'espacement ou sélectionnez Editer > Assistant de contenu > Défaut.
Elle fonctionne également si vous placez le caret après les parenthèses ouvrantes d'une création d'instance de classe :
|
| Activer/désactiver l'insertion ou le remplacement de l'assistant de contenu | Lorsque l'assistant de contenu est
appelé sur un identificateur existant, il peut remplacer l'identificateur par
l'exécution choisie ou procéder à une insertion. Le comportement par
défaut (remplacement ou insertion) est défini dans la page des préférences
Java > Editeur >
Assistant de contenu.Vous pouvez temporairement inverser le comportement en étant à l'intérieur de la boîte de dialogue de sélection de l'assistant de contenu, en appuyant sur la touche Ctrl et en la maintenant enfoncée, pendant la sélection de l'exécution. |
| Assistant de contenu incrémentiel | L'assistant de contenu peut aussi insérer des préfixes communs automatiquement, de façon similaire au développement dans l'interpréteur de commandes Unix. Pour activer ce comportement, cochez la case dans la page des préférences
Java > Editeur > Assistant de contenu.
|
| Prise en charge de la casse mixte dans l'exécution de code | L'exécution du code prend en charge les masques à casse mixte.
Par exemple, une exécution avec NPE ou NuPoiE proposera NullPointerException.
Vous pouvez désactiver cette prise en charge à l'aide de la
préférence permettant d'afficher les correspondances de la
casse ChatMot) de la page de préférences
Java > Editeur > Assistant de contenu.
|
| Personnalisation des catégories de l'assistant de contenu |
Les appel répétés à l'assistant de contenu (Ctrl+Espace sur la
plupart des plateformes) passent maintenant par différentes catégories de
propositions.
Java > Editeur > Assistant de contenu > Avancé.
Vous pouvez aussi affecter des raccourcis clavier différents à vos catégories de proposition favorites. |
| Création de méthode d'accès get (getter) et de méthode d'accès set (setter) | Pour créer des méthodes getter et
setter pour une zone, sélectionnez la déclaration de la zone et sélectionnez
Source > Générer les méthodes Getter et Setter.
Java > Style de code. |
| Assistant rapide de création de méthodes getter et setter | Un assistant rapide (Ctrl+1) est disponible dans les zones permettant de créer des méthodes getter et setter.
|
| Utilisation de l'assistant de contenu pour créer des méthodes d'accès get et de méthode d'accès set | Vous pouvez également créer des
méthodes getter et setter à l'aide de l'assistant de contenu. Placez le curseur
dans le corps du type entre des membres et appuyez sur Ctrl+Espace pour
obtenir les propositions qui créent un raccord de méthode getter ou setter. ![]() |
| Suppression de méthodes d'accès get et set avec une zone | Lorsque vous supprimez une zone
d'une vue, Eclipse peut vous proposer de supprimer ses méthodes Getter et
Setter.
Si vous utilisez un préfixe ou un suffixe de nom pour les zones,
n'oubliez pas de l'indiquer dans la page des préférences
Java > Style de code. |
| Création de méthodes déléguées | Pour créer une méthode déléguée
pour une zone, sélectionnez la déclaration de la zone, puis appelez Source >
Générer des méthodes déléguées. Les méthodes sélectionnées
sont alors ajoutées au type contenant un appel d'envoi aux méthodes
déléguées. L'exemple suivant illustre une méthode déléguée :
|
Création de méthodes
hashCode() et equals()
|
Pour créer les méthodes
hashCode() et equals(), appelez Source
> Générer hashCode() et equals().
|
| Utilisation de modèles pour créer une méthode | Les modèles sont présentés dans les propositions de
l'Assistant de contenu (Ctrl+Espace). Vous disposez de modèles existants, tels que 'private_method', 'public_method', 'protected_method', entre autres, mais vous pouvez aussi définir de nouveaux modèles pour des modules de remplacement de méthode. Après application d'un modèle, utilisez la touche de Tabulation pour naviguer parmi les valeurs à saisir (type de retour, nom et arguments). |
| Utilisation de modèles pour créer des widgets SWT | Sur les projets dont le chemin d'accès aux classes contient la bibliothèque SWT, vous pouvez créer des objets SWT à l'aide de l'assistant de contenu (Ctrl+Espace)
Par exemple, pour ajouter un bouton SWT, tapez Bouton et appuyez sur Ctrl+Espace, sélectionnez le modèle Bouton et appuyez sur Entrée. Pour afficher tous les modèles disponibles, accédez à la page des préférences
|
| Création de vos propres modèles |
Pour créer vos propres modèles, accédez à la page des préférences
Java > Editeur >
Modèles et appuyez sur le bouton Nouveau
pour créer un modèle. Par exemple, un modèle permettant de faire une itération en arrière
dans un tableau ressemblerait à ce qui suit :
|
| Utilisation du correctif rapide pour créer une méthode | Commencez par appeler la méthode
et sélectionnez Correctif rapide (Ctrl+1) pour créer la méthode.
|
| Utilisation du correctif rapide pour modifier une signature de méthode | Ajoutez un argument à un appel de méthode
sur un site d'appel. Utilisez ensuite Correctif rapide (Ctrl+1) pour ajouter le
paramètre requis dans l'instruction de la méthode.
|
| Utilisation de l'assistant de contenu pour créer un module de remplacement de constructeur | A l'emplacement où vous voulez
ajouter le nouveau constructeur, utilisez l'assistant de contenu après avoir
saisi les premières lettres du nom du constructeur.![]() |
| Création de zones à partir de paramètres | Avez-vous besoin de créer des zones pour
stocker les arguments transmis au constructeur ? Utilisez l'Assistant rapide (Ctrl + 1)
sur un paramètre pour créer l'affectation et la déclaration de zone et laisser Eclipse
proposer un nom en fonction de vos préférences de style de code.![]() |
| Utilisation de l'assistant de contenu pour remplacer une méthode | Appelez l'assistant de
contenu (Ctrl+Espace) dans le corps du type à l'emplacement où la méthode
doit être ajoutée. L'assistant de contenu propose toutes les méthodes qui
peuvent être remplacées. Un corps de méthode est créé pour la méthode choisie.
|
| Utilisation du correctif rapide pour ajouter des méthodes non implémentées | Pour implémenter une nouvelle
interface, ajouter d'abord au type la déclaration 'implements'.
Même sans opération de sauvegarde ou de génération, l'éditeur Java souligne le type pour
signaler que des méthodes sont manquantes et affiche l'icône en forme d'ampoule
électrique du correctif rapide. Cliquez sur l'ampoule ou appuyez sur Ctrl+1 (Editer > Correctif
rapide) pour choisir entre ajouter des méthodes non implémentées ou rendre
votre classe abstraite.
|
| Utilisation du nettoyage pour ajouter des méthodes non implémentées | Si vous ajoutez une nouvelle méthode à une interface ou une méthode abstraite à une classe abstraite, Eclipse peut générer un module de remplacement à l'ensemble des sous-classes concrètes en même temps. Appelez Source > Nettoyer... sur un ensemble d'éléments Java, utilisez un profil personnalisé et sélectionnez dans la boîte de dialogue Configurer... l'option Ajouter des méthodes non implémentées dans l'onglet Code manquant. |
| Remplacement d'une méthode à partir d'une classe de base | Pour créer une méthode qui en
remplace une autre à partir d'une classe de base, procédez comme suit : Sélectionnez le type auquel les méthodes doivent être ajoutées et appelez Source > Remplacer/Implémenter des méthodes. Une boîte de dialogue s'ouvre permettant de choisir les méthodes à remplacer.
|
| Changement de nom dans un fichier | Pour effectuer
rapidement un changement de nom ne nécessitant pas une analyse complète des
dépendances dans d'autres fichiers, utilisez le correctif rapide de changement
de nom dans le fichier. Dans l'éditeur Java, placez le curseur dans l'identificateur d'une variable,
d'une méthode ou d'un type et appuyez sur Ctrl+1 (Editer > Correctif
rapide). L'éditeur passe en mode d'édition lié (comme les modèles) et le changement d'identificateur modifie simultanément toutes les autres références à la variable, à la méthode ou au type.
Général > Touches pour configurer les raccourcis (dans la
catégorie 'Source').
|
| Utilisation du correctif rapide pour traiter les exceptions | Le traitement des exceptions lancées est
simple. Les exceptions non traitées sont détectées lors de la saisie et
soulignées d'une ligne rouge dans l'éditeur.
|
| Moins de saisie pour les affectations | Au lieu de saisir une affectation, commencez par l'expression qui sera assignée.
![]() |
| Moins de travail avec les expressions de transtypage | Ne perdez pas trop de temps avec la saisie des transtypages. Commencez
par les ignorer, puis ajoutez-les à l'aide de l'assistant rapide une fois que vous avez
terminé l'instruction.
Par exemple, pour les affectations : |
| Affectation d'une expression transtypée |
Après une vérification 'instanceof', il est très courant de transtyper l'expression et de l'affecter à une nouvelle variable locale. Pour éviter des opérations de saisie, appelez l'Assistant rapide (Ctrl+1) dans le mot clé 'instanceof' ou au début du corps de bloc :
|
| Délimitation de lignes | Pour entourer les instructions avec une
instruction if / while / for ou un bloc, sélectionnez les lignes à entourer
et appelez Source > Entourer de ou appuyez sur
Alt+Maj+Z.
Les entrées du menu sont dérivées des modèles normaux de l'éditeur. Tous les modèles contenant la variable ${line_selection} s'affichent dans le menu. Les modèles peuvent être configurés dans la page des préférences
Java > Editeur > Modèles. Editez les modèles correspondants
pour personnaliser le code résultant
ou définissez vos propres modèles de délimitation. |
| Assistants rapides et correctifs supplémentaires |
Consultez la page Assistant rapide pour obtenir la liste complète des transformations de code disponibles. Pour obtenir une liste des correctifs rapides, cliquez ici. |
| Raccourcis pour les assistants et les correctifs rapides |
Vous pouvez appeler directement certains des assistants rapides les plus utilisés tels que
Renommer dans un fichier et Affecter à une variable locale à l'aide des combinaisons de touches Ctrl+2 R et Ctrl+2 L. Consultez la page des préférences
Général > Touches pour connaître d'autres correctifs rapides et assistants rapides pouvant être appelés directement.
Sélectionnez "Assistant rapide" ou "Correctif rapide" dans la zone de filtre :
|
| L'assistant de contenu peut insérer des noms d'argument automatiquement |
L'assistant de contenu peut insérer des noms d'argument automatiquement
à la fin de la méthode. Ce comportement peut être personnalisé sur la page des préférences Java > Editeur > Assistant de contenu (voir la case à cocher Compléter les arguments de méthode et afficher les arguments devinés.) Par exemple, lorsque vous
sélectionnez la seconde entrée,
l'assistant de contenu insère automatiquement des noms d'argument :
Vous pouvez alors utiliser la touche de tabulation pour naviguer parmi les noms insérés. Si vous choisissez Insérer les arguments les mieux devinés, les meilleures suppositions seront insérées par défaut. Les propositions alternatives sont encore disponibles. |
| Insertion automatique d'arguments de type |
L'activation de l'option Compléter les arguments de méthode et afficher les arguments devinés dans la page de préférences Java > Editeur > Assistant de contenu est également utile lorsque vous travaillez avec des types paramétrés dans J2SE 5.0.
on obtient le résultat suivant :
|
| Suppression d'une instruction de délimitation | Pour supprimer une instruction ou un bloc
délimiteur, placez le curseur sur la parenthèse ouvrante ou fermante et appuyez
sur les touches Ctrl+1 (Editer > Correctif rapide).
|
| Correction orthographique | Vous pouvez activer la fonction de vérification orthographique dans
l'éditeur Java sur la page des préférences
Général >
Editeurs > Editeurs de texte >
Correcteur orthographique. Les
erreurs d'orthographe sont affichées dans l'éditeur et les correctifs rapides
correspondants sont disponibles :
Vous pouvez également activer le dictionnaire pour l'assistant de contenu. Un correctif rapide vous permet d'ajouter à la volée de nouveaux mots au dictionnaire utilisateur. |
| Sélections structurées | Les actions de Sélection structurée peuvent être utilisées pour agrandir la sélection en cours à l'élément englobant suivant :
Mettez une partie du texte en évidence et appuyez sur les touches Alt+Maj+Flèche haut ou sélectionnez Editer > Développer la sélection vers > Elément délimiteur dans la barre de menu. La sélection est développée jusqu'au plus petit élément de syntaxe Java contenant la sélection. Vous pouvez encore développer la sélection en appelant à nouveau l'action (ou d'autres actions de développement de la sélection dans le menu). Il est notamment utile de sélectionner l'identifiant pour renommer ou de sélectionner des instructions adjacentes pour une restructuration ultérieure de l'option Extraire la méthode. |
| Recherche du crochet correspondant | Pour trouver un crochet correspondant,
sélectionnez un crochet ouvrant ou fermant et appuyez sur les touches
Ctrl+Maj+P ou sélectionnez Naviguer > Accéder à > Crochet
correspondant. Vous pouvez également cliquer deux fois
avant un crochet ouvrant ou après un crochet fermant, pour que le texte figurant entre les deux crochets soit sélectionné.
L'éditeur Java prend également en charge la mise en évidence des crochets.
L'éditeur peut être configuré depuis la page de préférences
|
| Smart Javadoc | Entrez '/**' et appuyez sur Entrée. Un
raccord de commentaire Javadoc contenant les balises standard @param, @return
et @exception est automatiquement ajouté.
Java > Style de code > Modèles de code.
|
| Utilisation de l'historique local pour revenir à une édition antérieure de méthode | Chaque fois que vous éditez un
fichier, son précédent contenu est conservé dans l'historique local. Les outils Java rendent l'historique local disponible pour les éléments
Java, ainsi vous pouvez revenir à une précédente édition de la méthode, et pas
nécessairement du fichier complet.
Sélectionnez un élément (par exemple la vue Structure) et utilisez Remplacer par > Historique local pour revenir à la précédente édition de l'élément.
|
| Utilisation de l'historique local pour restaurer des méthodes supprimées | Chaque fois que vous éditez un
fichier, son précédent contenu est conservé dans l'historique local. Les outils Java rendent l'historique local disponible pour les éléments Java,
ainsi vous pouvez restaurer les méthodes de manière sélective.
Sélectionnez un conteneur (par exemple dans la vue Structure) et utilisez Restaurer à partir de l'historique local pour restaurer des membres supprimés.
|
| Génération de code personnalisable | La page des préférences
Java > Style de code >
Modèles de code permet de personnaliser le code générés et les
commentaires de la même manière que pour les modèles normaux.
Ces modèles de code sont
utilisés chaque fois que du code est généré.
|
| Créer des commentaires dans votre code | Vous pouvez ajouter des
commentaires de façon explicite en cliquant sur Source > Générer un
commentaire d'élément (Alt+Maj+J) ou automatiquement via divers assistants,
restructurations ou correctifs rapides. Configurez les modèles de commentaire dans la page des préférences
Java > Style de code > Modèles de code.Activez ou désactivez la génération automatique de commentaires, soit directement dans l'assistant (en utilisant la case à cocher 'Générer un commentaire' dans les nouveaux assistants de type Java) soit via la case à cocher 'Ajouter automatiquement des nouveaux commentaires pour les nouvelles méthodes et les nouveaux types' de la page de préférences Java > Style de code > Modèles de code.Ces paramètres peuvent également être configurés par projet. Ouvrez les Propriétés du projet afin d'activer les paramètres spécifiques au projet. |
| Tri des membres | Vous pouvez trier les membres
d'une unité de compilation ou d'un ensemble d'unités de compilation Java en fonction de l'ordre défini dans la page des préférences
Java > Apparence > Ordre de tri des membres.L'action figure sous Source > Trier les membres. |
| Renvoi des chaînes à la ligne |
Les littéraux chaînes peuvent passer à la ligne lorsque vous les
éditez. Par exemple, si le code est comme suit :
String message= "This is a very long message."; placez le caret après le mot "very" et appuyez sur Entrée. Le code est automatiquement changé en : String message= "This is a very" +
" long message.";
Vous pouvez personnaliser ce comportement dans la page des préférences
|
| Saisie avancée et contrôle de cette fonction |
Les fonctions de saisie avancée de l'éditeur Java facilitent votre travail quotidien. Vous pouvez les configurer dans la page des préférences
Java > Editeur > Saisie.
Si l'option Insertion automatique des points-virgules à l'emplacement correct est activée, lorsque vous saisissez un point-virgule, le curseur se place automatiquement à la fin de l'instruction avant d'insérer celui-ci. Cela vous évite de déplacer vous-même le curseur. |
| Correction du retrait du code à l'aide d'une touche | La fonction Source >
Corriger le retrait ou Ctrl+I est particulièrement utile. Sélectionnez le code dans lequel le retrait est incorrect et appelez l'action. Si vous n'avez effectué aucune sélection, l'action corrige le retrait de la ligne en cours. |
| Correction du retrait du code à l'enregistrement | Eclipse peut corriger le retrait de votre code lorsque vous enregistrez l'éditeur. Accédez à la page des préférences
Java > Editeur > Actions de sauvegarde, sélectionnez Configurer... Actions supplémentaires, puis Corriger le retrait dans l'onglet Organisation du code.
|
| Menus rapides pour l'action source et l'action de restructuration |
Vous pouvez accéder à l'action source et à l'action de restructuration via un menu rapide. Sélectionnez l'élément à utiliser dans
l'éditeur Java ou dans une vue Java et appuyez sur Alt+Maj+S pour le
menu source rapide ou sur Alt+Maj+T pour le menu de restructuration
rapide et sur Alt+Maj+Z pour le menu de délimitation.
|
| Recherche de code inutilisé | Le compilateur Java détecte
un code inaccessible, des variables inutilisées, des paramètres, des
importations et des types, des méthodes et des zones privés inutilisés.
Modifiez les paramètres pour la détection dans la page des préférences
Java > Compilateur > Erreurs/avertissements
. Ces paramètres peuvent aussi être indiqués par projet, utilisez : Projet > Propriétés > Compilateur Java > Erreur/avertissements.
|
| Rechercher les incidents avec la valeur null | Le compilateur peut vous aider à rechercher les incidents avec la valeur null dans votre code.
La page des préférences
Java > Compilateur > Erreurs/avertissements
comporte trois options pour détecter les incidents :
|
| Rechercher les incidents liés aux chaînes externalisées | L'action Source > Recherche des chaînes externalisées qui ne fonctionnent pas recherche pour vous les clés non définies, non utilisées et en double :
|
| Modification du niveau de gravité des incidents dans une aide contextuelle d'incident | Lors de l'enrichissement de l'aide contextuelle d'un incident, une action permettant de modifier la gravité de l'incident en cours est disponible.
Cliquez sur le bouton de la barre d'outils pour accéder à la page de préférences
|
| Traitement des commentaires Javadoc | Le compilateur Java d'Eclipse peut traiter les commentaires Javadoc. La
recherche signale les références dans les commentaires de la documentation et la
restructuration met également à jour ces références. Cette
fonction est contrôlée à partir de la page des préférences
Java > Compilateur > Javadoc
(ou définie pour un projet à l'aide de l'option Projet > Propriétés >
Compilateur Java > Javadoc).
|
| Supprimer les avertissements | Dans la version 5.0 de J2SE et les versions supérieures, vous pouvez supprimer tous les avertissements optionnels émis par le compilateur à l'aide de l'annotation SuppressWarnings.Dans cet exemple, addAll() est signalée comme une méthode non
utilisée. Le Correctif rapide (Ctrl+1) est utilisé pour ajouter une
annotation SuppressWarnings de façon à ce que l'avertissement ne
soit pas affiché pour cette méthode.
|
| Nettoyages | Source > Nettoyer... résout plusieurs problèmes à la fois et facilite la mise en place d'un style de code cohérent. Par exemple, vous pouvez effectuer les opérations suivantes :
Les nettoyages sont organisés dans les profils de nettoyage. Un profil peut être joint à l'espace de travail ou à des projets donnés. Les paramètres de projet peuvent être partagés dans une équipe avec un système de contrôle des versions. Il est également possible d'exporter et d'importer chaque profil.
Des nettoyages peuvent être exécutés en tant qu'actions de sauvegarde lors de l'enregistrement. Accédez à la page des préférences
|
| Ecriture de scripts de restructurations |
La plupart des restructurations de JDT peuvent être non seulement exécutées
de façon interactive mais aussi être exécutées par un script de restructuration. Pour créer un script de restructuration à partir de l'historique de restructuration, utilisez Restructurer > Création d'un script.... Un script de restructuration peut ensuite être appliqué à un espace de travail arbitraire à l'aide de Restructurer > Appliquer le script.... Ces scripts de restructuration peuvent être utilisés dans différents scénarios tels que la réparation automatique de modifications créant des ruptures d'API entre les couches logicielles ou la fourniture de correctifs de sémantique riche. |
| Migration sécurisée des fichiers JAR |
Lors de l'exportation d'un fichier JAR à partir de l'espace de travail,
l'assistant d'exportation de fichier JAR propose une option permettant
d'inclure les informations de restructuration dans le fichier JAR. Utilisez Fichier > Exporter... puis sélectionnez Fichier JAR. Dans la première page de l'assistant d'exportation de fichier JAR, sélectionnez Exporter les restructurations des projets sélectionnés. Cliquez sur le lien pour sélectionner les restructurations à inclure. Les clients peuvent migrer une ancienne version du fichier JAR vers une nouvelle version à l'aide de la restructuration Restructurer > Migrer le fichier JAR.... Cette restructuration met à jour automatiquement tout le code dépendant de l'ancienne version du fichier JAR afin qu'il utilise la nouvelle version du fichier JAR. |
| Localisation des variables et de leur accès en lecture/écriture | Vous pouvez localiser les variables et voir leur état en lecture/écriture en sélectionnant un identificateur (variable, référence ou déclaration de méthode ou de type) et en ouvrant Rechercher > Occurrences dans le fichier > Identificateur . Cette
opération marque toutes les références de l'identificateur dans le même
fichier. Les résultats s'affichent également dans la vue Recherche, avec des couleurs différentes pour les accès en lecture ou en écriture, ainsi qu'avec des icônes affichant l'accès à la variable en lecture ou en écriture.
Vous pouvez également utiliser la fonction Marquer les occurrences pour mettre en évidence les occurrences de manière dynamique. La recherche peut s'effectuer sur plusieurs fichiers en utilisant les fonctions de recherche générale (Recherche > Références). |
| Recherche de méthodes avec un type de retour spécifique |
Pour rechercher des méthodes avec un type de retour spécifique, utilisez
"* <type de retour>" comme suit :
|
| Filtrer les correspondances de recherche dans Javadoc | Par défaut, la recherche Java recherche des références dans le code Java et Javadoc. Si vous ne souhaitez pas trouver de références au sein de Javadoc, vous pouvez filtrer ces correspondances en activant l'option 'Filtre Javadoc' dans le menu Afficher (symbole triangulaire) de la vue Recherche |
| Filtrer les correspondances de recherche potentielles | Les correspondances potentielles se produisent lorsqu'un incident pendant le temps de compilation empêche le moteur de recherche de résoudre complètement la correspondance. Filtrez ces correspondances à l'aide de l'option de filtrage sur correspondance potentielle dans le menu Afficher (symbole triangulaire) de la vue Recherche. |
| Suivi des chaînes d'appel de méthode à l'aide de la hiérarchie d'appels |
La nouvelle hiérarchie d'appels permet de suivre les chaînes d'appel longues ou
complexes sans perdre le contexte d'origine : il vous suffit d'appeler une
méthode et d'appeler Naviguer > Ouvrir la hiérarchie d'appels
(Ctrl+Alt+H).
Vous pouvez également utiliser la fonction glisser-déposer pour remplacer l'entrée de la vue par les méthodes sélectionnées. La combinaison de touches Ctrl+glissement ajoute les méthodes sélectionnées aux éléments existants dans la vue. Les méthodes des classes anonymes ou les types spéciaux, tels que |
| Ouverture d'ne sélection dans l'éditeur Java | Vous pouvez ouvrir un élément depuis une référence dans l'éditeur Java de deux manières.
Si vous maintenez la touche Ctrl enfoncée sur une méthode remplaçable, vous affichez une fenêtre en incrustation comportant l'entrée d'ouverture d'implémentation qui ouvre directement l'implémentation s'il en existe une seule ou affiche toutes les implémentations concrètes de la méthode dans la hiérarchie de son type déclarant en utilisant la hiérarchie de type rapide. La navigation à l'aide de liens hypertexte peut être configurée dans la page des préférences
Général > Editeurs > Editeurs de texte > Liens hypertexte.
|
| Structures en place | Appuyez sur les touches
Ctrl+F3 dans l'éditeur Java pour afficher une structure en place de
l'élément à la position courante du curseur ou appuyez sur les
touches Ctrl+O (Naviguer > Structure rapide) pour afficher une
structure en place du fichier source courant.
|
| Les structures en place montrent les membres hérités | Appuyez de nouveau sur Ctrl+O ou Ctrl+F3
pour ajouter les membres hérités à une structure en place ouverte. Les membres hérités possèdent un libellé bleu.
Filtrez et triez la structure à l'aide du menu qui se trouve dans le coin supérieur droit.
).
|
| Hiérarchie en place | Recherchez les destinataires
possibles d'un appel virtuel à l'aide de la hiérarchie rapide.
Placez le curseur dans l'appel de méthode et appuyez sur Ctrl+T
(Naviguer > Hiérarchie rapide).
La vue affiche tous les types qui implémentent la méthode avec une icône pleine.
Appuyez sur Entrée pour ouvrir la méthode correspondante dans un éditeur. Appuyez de nouveau sur Ctrl+T pour passer à la hiérarchie des supertypes. |
| Elément de navigation de l'éditeur Java | L'éditeur Java contient une barre de trajet de navigation indiquant le chemin d'accès à l'élément se trouvant à l'emplacement du curseur. Cet élément peut être activé à l'aide du bouton de la barre d'outils Activer les éléments de navigation ou via la combinaison de touches Alt+Maj+B.
Chaque élément de l'élément de navigation peut être sélectionné et des actions peuvent être appelées par le biais d'un menu contextuel ou de raccourcis clavier. En outre, l'élément de navigation vous permet d'accéder à d'autres éléments par le biais de menus déroulants. |
| Mise en évidence avancée |
L'éditeur Java peut mettre en évidence le code source en fonction de sa sémantique (par
exemple : les zones statiques, les variables locales, les appels de méthode statique). Vous pouvez consulter les différentes options dans la page des préférences
Java > Editeur > Couleurs pour la syntaxe.
|
| Régions initialement réduites | Vous pouvez spécifier les régions devant être réduites par défaut lorsqu'un éditeur est ouvert. Pour personnaliser cette fonction, consultez la page des préférences
Java > Editeur > Réduction.
|
| Marquage des occurrences |
Lorsque vous utilisez l'éditeur, activez l'option Marquer les occurrences dans la barre d'outils ( ) ou appuyez sur Alt+Maj+O.
Des couleurs différentes sont utilisées pour marquer les accès en lecture et en écriture. Lorsque vous sélectionnez un type de retour, vous pouvez voir les points de sortie de la méthode. Sélectionnez une exception pour voir où elle est générée. Sélectionnez une superclasse ou une interface pour voir les remplacements de méthodes ou implémentez une méthode à partir du supertype sélectionné. Paramétrez l'option 'marquer les occurrences' dans la page des préférences
Pour afficher les occurrences dans la vue Rechercher, utilisez la fonction Rechercher > Occurrences. |
| Passage à la méthode suivante ou précédente | Pour naviguer rapidement jusqu'à
la méthode ou à la zone suivante ou précédente, utilisez : Ctrl+Maj+Flèche haut (Naviguer > Accéder à > Membre précédent) ou Ctrl+Maj+Flèche bas (Naviguer > Accéder à > Membre suivant) |
| Contrôle de la navigation entre les annotations |
Utilisez les boutons Suivant/Précédent de la barre d'outils Annotation ou sélectionnez
Naviguer > Annotation suivante (Ctrl+.) et Navigation > Annotation
précédente (Ctrl+,) pour passer d'une annotation à une autre dans un fichier source
Java.
A l'aide des menus déroulants des boutons, vous pouvez définir les annotations à
arrêter :
|
| Rappels dans votre code Java | Lorsque vous balisez un
commentaire dans du code source Java avec la marque "TODO", le compilateur Java
crée automatiquement une tâche correspondante comme aide-mémoire. L'ouverture de la tâche vous ramène à la balise "TODO" figurant dans le code. Utilisez la page des préférences
Java > Compilateur > Balises de tâche
pour configurer d'autres balises spéciales (telle que "FIXME") que vous
souhaitez voir apparaître dans la liste des tâches.
|
| Astuces dans la boîte de dialogue Ouverture d'un type |
La boîte de dialogue Ouverture d'un type (Naviguer > Ouvrir le
type ou bouton de la barre d'outils) vous aide à naviguer jusqu'à un type
en fonction de son nom.
![]() |
| Aides contextuelles fixes | Vous pouvez ouvrir le texte d'une aide contextuelle sous forme de fenêtre déroulante en appuyant sur F2 (Editer > Afficher une description de type infobulle) ou en déplaçant le pointeur de la souris dessus. Vous pouvez sélectionner et copier le contenu de cette fenêtre, appeler des actions ou suivre des liens.
Vous pouvez configurer la façon d'enrichir l'aide contextuelle dans la page de préférences
|
| Aides contextuelles dans l'éditeur Java | Vous pouvez afficher les diverses
infobulles de l'éditeur Java à l'aide des touches de modification (Maj, Ctrl, Alt). Lorsque vous placez le pointeur de la souris sur un identificateur qui n'a pas d'avertissement ou d'annotation d'incident dans l'éditeur Java, une infobulle avec le Javadoc extrait de la source correspondante de cet élément s'affiche par défaut. S'il existe une annotation d'incident sur l'identificateur, l'infobulle affiche le message correspondant. Maintenez la touche Maj enfoncée pour afficher le code source :
Java > Editeur > Infobulles.
|
| Signature déduite de méthode générique |
Vous pouvez utiliser une
infobulle pour afficher la signature déduite de méthode générique.
|
| Ouverture et configuration de la documentation Javadoc externe | Si vous souhaitez ouvrir la
documentation Javadoc pour un type, une méthode ou une zone à l'aide de Maj+F2
(Naviguer > Ouvrir le Javadoc externe), vous devez d'abord
spécifier les emplacements de la documentation à la bibliothèque parent
des éléments (JAR, dossier classe) ou au projet (dossier source). Pour les bibliothèques, ouvrez la page du chemin de génération (Projet > Propriétés > Chemin de génération Java), accédez aux bibliothèques, développez le noeud de la bibliothèque où vous pouvez éditer le noeud 'Emplacement du Javadoc'. La documentation peut être locale sur votre système de fichiers dans un dossier ou une archive, ou sur un serveur Web.
|
| Organisation de l'espace de travail avec plusieurs projets | Pour activer un nouveau mode affichant les jeux de documents comme des
éléments de niveau supérieur, cliquez sur Eléments de niveau supérieur >
Jeux de documents dans le menu d'affichage de la vue Explorateur de packages. Ce mode vous permet de gérer beaucoup plus facilement les espaces de travail comportant de nombreux projets.
Pour déterminer les jeux de documents à afficher, utilisez la fonction Configuration de jeux de documents... du menu Afficher de l'explorateur de packages. Cette boîte de dialogue vous permet de créer de nouveaux jeux de documents Java, de déterminer lesquels doivent être affichés et dans quel ordre. Si Trier les jeux de documents n'est pas activé, les jeux de documents peuvent également être réorganisés directement dans l'explorateur de packages à l'aide de la fonction glisser-déposer. |
||||
| Attribuer des jeux de documents | Pour attribuer un élément à un jeu de documents différent, sélectionnez l'élément dans l'explorateur de packages et sélectionnez Attribuer des jeux de documents... dans le menu contextuel.
|
||||
| Vue Déclaration | La vue Déclaration (
Fenêtre > Afficher la vue > Autres... > Java > Déclaration) affiche la source de l'élément sélectionné dans l'éditeur Java ou dans une vue Java.
|
||||
| Vue Javadoc | La vue Javadoc (
Fenêtre > Afficher la vue > Autres... > Java > Javadoc) affiche la documentation Javadoc de l'élément sélectionné dans l'éditeur Java ou dans une vue Java.
|
||||
| Vue Hiérarchie des types et implémentations /définitions de méthodes | Pour identifier les types d'une
hiérarchie qui remplacent une méthode, utilisez la fonction 'Afficher les membres
de la hiérarchie' :
isEmpty() est défini dans Liste et implémenté dans
ArrayList et Vector, mais pas dans
AbstractList.
|
||||
| La vue Hiérarchie des types prend en charge le regroupement par type de définition. | La vue Méthodes de la hiérarchie
des types permet de trier les méthodes du type sélectionné par ses types de
définition.
Par exemple, pour AbstractList, vous pouvez voir qu'il contient des méthodes
définies dans Objet, Collection et Liste :
|
||||
| Astuces dans la hiérarchies des types |
|
||||
| Comparaison structurelle de la source Java | Une comparaison structurelle d'une source Java ignore
l'ordre textuel des éléments Java, tels que les méthodes et les zones et affiche
plus clairement quels éléments ont été modifiés, ajoutés ou supprimés. Pour initialiser une comparaison structurelle de fichiers Java, vous avez deux options :
|
||||
| Comparaison structurelle des fichiers de propriétés | Une comparaison structurelle de fichiers de
propriétés Java (extension .properties) ignore l'ordre textuel des propriétés et affiche
quelles propriétés ont été modifiées, ajoutées ou supprimées. Pour initialiser une comparaison structurelle de fichiers de propriétés, vous avez deux options :
|
||||
| Structure de packages hiérarchique comparée à une présentation à plat | Une option du menu Afficher de la
vue Packages Java (et Explorateur de packages) permet de modifier la façon dont les
packages sont affichés. L'option Présentation du package >
Hiérarchique affiche les packages sous forme d'arborescence, avec des
sous-packages sous les packages. L'option Présentation du package > A
plat les affiche de manière standard, sous forme de liste à plat avec tous
les packages et les sous-packages apparentés.
|
||||
| Packages logiques | La vue Packages Java (perspective
Navigation Java) regroupe les packages de même nom parmi les dossiers source
d'un projet. La capture d'écran représente la vue Packages contenant un package
logique.
|
||||
| Compression des noms de package | Si vos noms de package sont très
longs, vous pouvez configurer un nom compressé qui apparaît dans les
afficheurs.
La configuration du schéma de compression s'effectue dans la page des
préférences
Java > Apparence.
|
||||
| Abréviations des noms de package | Vous pouvez abréger les noms de package dans les vues Java en fonction de règles personnalisées. Par exemple, les règles suivantes génèrent l'affichage ci-dessous :
org.eclipse.ui={UI}
org.eclipse.ui.texteditor={T}
org.eclipse.ui.internal.texteditor=[iT]
Vous pouvez configurer les règles d'abréviation dans la page de préférences
|
||||
| Manipulation du chemin de génération Java directement à partir de l'explorateur de packages | Au lieu de manipuler le chemin de
génération Java via Projet > Propriétés > Chemin de génération
Java, vous pouvez utiliser les actions du menu contextuel de l'explorateur
de packages.
Par exemple, il est possible d'ajouter de nouveaux dossiers, archives et bibliothèques source au chemin de génération ou d'inclure/exclure des fichiers et dossiers d'un dossier source.
|
||||
| Collage de fragments de code pour créer un type | Vous pouvez coller un fragment de
code contenant un type Java directement dans un package ou un dossier source
pour créer une nouvelle unité de compilation.
Par exemple, sélectionnez et copiez ce code source :
package pack;
public class HelloWorld {
public static void main (String [] args) {
System.out.println("Hello World");
}
}
Ensuite, sélectionnez un dossier source dans la vue Explorateur de packages et utilisez Ctrl+V (Edition > Coller).
Ceci crée automatiquement un nouveau 'pack' de package et le fichier
'HelloWorld.java' avec le contenu copié.
Vous pouvez également coller une méthode ou un ensemble d'instructions ; Eclipse créera pour vous les éléments englobants. Si vous collez alors que rien n'est sélectionné dans l'explorateur de packages, Eclipse créera même un nouveau projet Java en y créant le fichier *.java. En outre, le presse-papiers peut aussi contenir plusieurs déclarations de package et de type, auquel cas Eclipse créera tous les modules et fichiers *.java nécessaires lors du collage. |
||||
| Collage d'un correctif dans l'explorateur de packages | Quel est la méthode la plus rapide pour appliquer un correctif depuis Bugzilla ? Ouvrez l'attachement, copiez le correctif vers le presse-papiers et collez-le dans l'explorateur de package. | ||||
| Regroupement des problèmes Java |
Configurez la vue Erreurs pour regrouper les erreurs Java par catégories en
sélectionnant Regrouper par > Type d'erreur Java dans le menu
Afficher.
Java > Compilateur > Erreurs/avertissements.
|
||||
| Indicateur de type Java |
Active l'Indicateur de type Java dans la page de préférence
Général > Apparence >
Décorations d'intitulés pour savoir quel est le premier type dans une
unité de compilation ou d'un fichier de classe. Une décoration
s'affiche pour les interfaces, les annotations et les énumérations tandis
qu'une classe ordinaire ne comporte pas de décoration.
|
| Préférences spécifiques au projet | Toutes les options du compilateur
et du style de code peuvent être définies par projet. Ouvrez la page des propriétés du projet en cliquant sur Projet > Propriétés dans un projet ou via le lien dans les préférences de l'espace de travail (par exemple, la page de préférences Java > Style de code).
|
||||||||||||
| Règles d'accès |
La fonction Règles d'accès vous donne la possibilité de renforcer les règles API pour les types des bibliothèques référencées. Dans la page du chemin de génération Java (Projet
> Propriétés > Chemin de génération Java), modifiez le noeud 'Règles d'accès' disponible sur les projets, archives, bibliothèques et dossiers de classes référencés. Vous pouvez classer les packages ou les types de ces références dans les catégories suivantes :
Java > Compilateur >
Erreurs/Avertissements, le compilateur signalera les références
déconseillées et interdites par des avertissements ou des erreurs.
|
||||||||||||
| JUnit | Choisissez une méthode test JUnit et sélectionnez Exécuter > Test JUnit Test dans le menu contextuel ou Exécuter > Exécuter en tant que > Test JUnit dans le menu principal. Une configuration de lancement est alors créée pour exécuter le test sélectionné. | ||||||||||||
| Masquage de la vue JUnit jusqu'à ce que des erreurs ou des incidents se produisent | Vous pouvez configurer la vue
JUnit pour qu'elle ne s'ouvre que lorsque des erreurs ou des incidents se
produisent. Pour ce faire, activez Activer uniquement en cas d'erreurs/incidents
dans le menu de la vue JUnit. De cette façon, la vue peut être définie comme vue rapide et ne
jamais la regarder lorsqu'aucun test n'est défaillant. S'il n'y a pas d'erreur
dans vos tests, l'icône (le
nombre de petits carrés verts augmente, indiquant la progression) s'affiche
pendant leur exécution et l'icône
s'affiche une fois qu'ils sont terminés. Si cependant, des erreurs ou des incidents se produisent, l'icône se transforme en
(ou si les tests sont terminés) et la vue JUnit s'affiche. |
||||||||||||
| Assistant de contenu dans les zones de boîte de dialogue | L'assistant de contenu (Ctrl+Barre d'espacement) est également
disponible dans les zones d'entrée de diverses boîtes de dialogue Java. Recherchez les petites icônes en forme d'ampoule électrique en regard de la
zone lorsque cette dernière est mise en évidence.
|
||||||||||||
| Positionnement intelligent du caret dans les boîtes de dialogue affichant des noms Java |
Les zones de texte permettant d'éditer des noms Java prennent en charge le
positionnement intelligent du caret. Utilisez Ctrl+Gauche et
Ctrl+Droit pour vous arrêter aux frontières en casse ChatMot à
l'intérieur d'un nom. Utilisez Ctrl+Maj+Gauche et
Ctrl+Maj+Droit pour étendre la sélection petit à petit.
Utilisez Ctrl+Suppr pour supprimer la partie suivante d'un nom et
Ctrl+Retour arrière pour supprimer la partie précédente.
|
||||||||||||
| Définition de préfixes ou de suffixes pour les zones, les paramètres et les variables locales | Vous pouvez configurer le préfixe
ou le suffixe des zones, des zones statiques, des paramètres et des variables
locales.
Ces paramètres de la page des préférences
Java > Style de code sont
utilisés par l'assistant de contenu, le correctif rapide et la restructuration
chaque fois qu'un nom de variable est calculé.
|
||||||||||||
| L'organisation des importations ne fonctionne pas que sur des fichiers simples | Vous pouvez appeler Source > Organiser les importations sur des ensembles d'unités de compilation, des packages, des dossiers source ou des projets Java. | ||||||||||||
| Organiser les importations à l'enregistrement | Eclipse peut organiser automatiquement des importations chaque fois que vous enregistrez un éditeur.
Cette fonction peut être activée globalement dans la page des préférences
Java > Editeur > Actions d'enregistrement.
Les actions d'enregistrement peuvent aussi être configurées par projet, ce qui permet facilement de faire respecter une norme dans tout un projet en partageant les paramètres dans une équipe :
Outre organiser des importations, les actions d'enregistrement peuvent aussi formater le code de format et exécuter d'autres nettoyages. |
||||||||||||
| Sélection d'un format | Sélectionnez plusieurs fichiers Java à formater et choisissez Source > Format pour les formater tous. L'action de formatage
est également disponible pour les packages, les dossiers source et les projets Java.
Dans l'éditeur Java, Source > Format (Ctrl+Maj+F) formatera uniquement la région sélectionnée. Si rien n'est sélectionné, le fichier sera entièrement formaté. |
||||||||||||
| Sélectionner l'environnement d'exécution du projet Java | Lorsque vous créez un projet Java que vous voulez partager avec une équipe, il est judicieux d'utiliser un environnement d'exécution au lieu d'un environnement d'exécution Java particulier.
Les environnements d'exécution sont des représentations symboliques d'environnements d'exécution Java (JRE) avec des entrées normalisées telles que 'J2SE-1.4', 'J2SE-1.5'. Cela signifie qu'aucun système de fichiers n'entrera dans le chemin de génération partagé. Les JRE peuvent être affectés aux environnements dans la page des préférences Pour définir un environnement JRE spécifique d'un projet, ouvrez la page des propriétés du chemin de génération Java du projet (Projet > Propriétés > Chemin de génération Java), puis la page Bibliothèques, sélectionnez "Bibliothèque système JRE" et cliquez sur Editer. Dans la boîte de dialogue 'Edition d'une bibliothèque', vous pouvez sélectionner un environnement d'exécution, un environnement JRE spécifique ou l'environnement JRE par défaut de l'espace de travail. |
||||||||||||
| Utilisation de la fonction glisser-déposer |
La fonction glisser-déposer remplace avantageusement Edition >
Couper et Edition > Coller ou Edition >
Copier et Edition > Coller. Maintenez la touche
Ctrl enfoncée pendant le glissement pour passer de la fonction
déplacer à la fonction copier.
Important à savoir :
|
||||||||||||
| Propagation d'une balise d'élément déconseillé |
Le compilateur Java peut être configuré pour diagnostiquer les éléments
déconseillés à l'aide des options de la page des préférences
Java > Compilateur >
Erreurs/Avertissements.
|
||||||||||||
| Restauration suite à des incohérences |
Dans le cas assez rare d'un dysfonctionnement, JDT peut révéler certaines incohérences :
Pour éliminer ces incohérences dans JDT, effectuez les actions suivantes, en respectant l'ordre indiqué :
|
||||||||||||
| Décorateur d'erreur de chemin de génération |
L'explorateur de packages et l'explorateur de projets associent ce décorateur d'erreur
dans les projets Java et les jeux de documents s'ils contiennent des erreurs de chemin de génération :
|
||||||||||||
| Type de fichier '*.class sans source' |
Le type de fichier *.class sans source permet d'associer un éditeur interne ou externe à des fichiers classe qui n'ont aucune source associée. Cet exemple permet d'ouvrir le fichier classe dans un décompilateur :
|
||||||||||||
| Ignorez sélectivement les erreurs/avertissements des dossiers source |
Vous pouvez configurer l'outil de développement Java pour ignorer les erreurs/avertissements optionnels de certains dossiers source.
Voir Propriétés du projet > Chemin de génération Java > Compilateur > Source.
Lorsque cette option est définie sur Oui, les erreurs/avertissements configurés dans la page de préférences seront supprimés par JDT
|
|
Lancement à partir du menu contextuel |
Vous pouvez exécuter et déboguer les applications Java à partir du menu contextuel. Vous pouvez lancer un fichier source, un package, une méthode, un type, etc., en choisissant Exécuter en tant que (ou Déboguer en tant que) > Application Java dans le menu contextuel d'une vue ou d'un éditeur. Sinon, vous pouvez utiliser le raccourci de lancement des applications Java ((Alt+Maj+D, J)). Les actions de niveau supérieur Exécuter en tant que (ou Déboguer en tant que) sont également sensibles à l'éditeur actif ou à la sélection en cours.
|
| Evaluations dans le débogueur |
L'évaluation des fragments de code est disponible à partir de divers endroits du débogueur. Si vous choisissez Affichage ou Inspection dans le menu contextuel de l'éditeur ou de la vue Variables, le résultat sera affiché dans un menu en incrustation dont le résultat pourra être envoyé à la vue Affichage ou Expressions.
|
|
Gestion des vues dans les perspectives de non-débogage |
La vue Débogage gère automatiquement les vues liées au débogage en fonction de la vue sélectionnée (par exemple, affichage des vues Java pour les cadres de pile Java et des vues C pour les cadres de pile C). Par défaut, cette gestion automatique des vues n'intervient que dans la perspective Débogage, mais vous pouvez l'activer pour d'autres perspectives via la page des préférences Gestion des vues disponible à partir du menu déroulant Vue Débogage de la barre d'outils. |
|
Variable d'environnement |
Vous pouvez spécifier l'environnement utilisé pour lancer les applications Java via l'onglet Environnement.
|
|
Substitutions de chaînes |
Les variables sont prises en charge pour de nombreux paramètres des configurations de lancement des applications Java. Un bouton Variables est placé en regard de la plupart des zones prenant en charge les variables (c'est le cas des zones Programme et Arguments VM, par exemple). La zone Main Type prend aussi en charge des variables ; la variable ${java_type_name} permet de créer une configuration qui exécutera le type sélectionné.
|
|
Structures logiques |
L'action Structures logiques de la barre d'outils de la vue Variables présente d'autres structures pour les types standard. JDT fournit des vues logiques pour les mappes, les collections et les éléments composite SWT. Vous pouvez définir des structures logiques pour d'autres types à partir de la page de préférences Structures logiques.
|
|
Colonnes de variables |
Vous pouvez configurer les colonnes de la vue Variables en sélectionnant Présentation > Sélectionner des colonnes... dans le menu Afficher. Une boîte de dialogue vous permet de sélectionner les colonnes à afficher. Par exemple, vous pouvez ajouter une colonne pour afficher le nombre d'instances des classes (lors du débogage avec JavaSE-1.6). Vous pouvez afficher ou masquer les colonnes en sélectionnant l'action Présentation > Afficher les colonnes.
|
|
Afficher les références |
Lors du débogage avec JavaSE-1.6, vous pouvez afficher les références aux objets dans la vue Variables en sélectionnant Java > Afficher les références dans le menu Afficher. Une entrée "référencé à partir de" apparaît sous chaque objet pouvant être développé pour l'affichage des références à cet objet.
|
|
Toutes les instances |
Lors du débogage avec JavaSE-1.6, vous pouvez inspecter toutes les instances d'une classe en sélectionnant une classe dans la structure de l'éditeur, dans la vue variables, l'éditeur de fichier classe ou l'éditeur d'unité de compilation et en appelant Toutes les instances... dans le menu contextuel. Une boîte de dialogue en incrustation affiche toutes les instances de la classe sélectionnée.
|
|
Arguments VM par défaut |
Si vous spécifiez souvent les mêmes arguments pour une machine VM donnée, vous pouvez configurer Arguments VM par défaut dans la page des préférences JRE installés. Cela est plus pratique que de les spécifier pour chaque configuration de lancement.
|
| Arrêt dans main |
Vous pouvez utiliser l'option Arrêter dans main dans une configuration de lancement d'application Java afin que le programme s'arrête à la première ligne exécutable de la méthode main lorsque vous l'exécutez en mode débogage.
|
| Points d'arrêt conditionnels | Vous pouvez utiliser des expressions pour définir des points d'arrêt conditionnels dans la boîte de dialogue Propriétés du point d'arrêt... ou dans la sous-fenêtre de détails de la vue Points d'arrêt. Une condition contrôle le moment auquel l'exécution d'un point d'arrêt s'arrête. Vous pouvez indiquer si vous souhaitez que le point d'arrêt suspende
l'exécution uniquement si la condition est vérifiée (true) ou si la valeur de
la condition change. L'éditeur de condition de point d'arrêt prend en charge l'assistant de contenu.
|
| Débogage via l'écriture dans la console |
Vous pouvez éviter d'insérer des instructions System.out.println() dans votre code pour le débogage en utilisant des points d'arrêt conditionnels pour écrire les données dans la vue Console.
Pour ce faire, définissez un point d'arrêt conditionnel avec l'option Suspendre lorsque la condition est 'true' et une condition qui est toujours associée à la valeur 'false', par exemple
|
| Désactivation de points d'arrêt |
S'il s'avère que vous ajoutez et supprimez fréquemment un point d'arrêt au même
endroit, désactivez le point d'arrêt lorsque vous n'en avez plus besoin et réactivez-le lorsque vous en avez à
nouveau besoin. Pour cela, vous pouvez utiliser l'option Désactiver le point
d'arrêt du menu contextuel du point d'arrêt ou désélectionner le point
d'arrêt dans la vue Points d'arrêt.
Vous pouvez également désactiver temporairement tous les points d'arrêt à l'aide de l'action Ignorer tous les points d'arrêt de la barre d'outils de la vue Points d'arrêt. Le débogueur ignore alors tous les points d'arrêt en conservant leur état actuel activé.
|
| Changement des valeurs de variable |
Lorsqu'une unité d'exécution est interrompue dans le débogueur, vous
pouvez modifier les valeurs des primitives Java et des chaînes de la
vue Variables. Dans le menu contextuel de la variable, sélectionnez Modifier la valeur de la variable. Vous pouvez également modifier la valeur en en entrant une nouvelle dans la sous-fenêtre Détails et en utilisant l'action Affecter une valeur du menu contextuel (combinaison de touches CTRL+S).
|
| Valeurs de la variable dans l'aide contextuelle | Lorsqu'une unité d'exécution est interrompue
et que vous placez le curseur sur une variable dans l'éditeur Java, la valeur
de cette variable s'affiche sous forme d'infobulle.
|
| Passage au cadre |
Lors de l'exécution du code pas à pas, il
peut arriver que vous alliez trop loin ou que vous ignoriez une ligne dans
laquelle vous aviez l'intention d'entrer. Plutôt que de redémarrer votre session de débogage, vous pouvez utiliser
l'action Passer au cadre pour rapidement revenir au début d'une
méthode. Sélectionnez le cadre de pile correspondant à la méthode Java que
vous souhaitez redémarrer et sélectionnez Passer au cadre dans la barre d'outils
de la vue Débogage ou dans le menu contextuel du cadre de pile. Le pointeur de l'instruction courante est réinitialisé sur la
première instruction exécutable de la méthode. Cela fonctionne également
pour les piles de cadre inférieures.
Notez que l'action Passer au cadre est disponible uniquement lors du débogage avec une VM version 1.4 ou supérieure ou avec la VM J9. Dans certains cas, il se peut qu'une machine JVM ne parvienne pas à extraire les cadres désirés de la pile. Par exemple, il est généralement impossible de passer au cadre inférieur de la pile ou à tout cadre situé sous la méthode native. |
| Remplacement de code à chaud | Le débogueur prend en charge la fonction de remplacement du code à chaud lors du débogage avec une VM version 1.4 ou supérieure ou la VM J9. Ceci vous permet d'effectuer des modifications dans le code en cours de débogage. Notez que certaines modifications, telles que des méthodes nouvelles ou supprimées, des variables de classe ou des classes internes ne peuvent pas être remplacés à chaud, suivant le type de support fourni par une machine VM donnée. |
| Pas à pas dans des sélections et débogage des liens hypertexte |
Le débogueur Java permet d'avancer d'un pas avec entrée dans une
seule méthode au sein d'une série d'appels de méthode chaînés ou imbriqués. Sélectionnez simplement la méthode dans laquelle vous souhaitez
avancer d'un pas avec entrée et sélectionnez Avancer d'un pas avec entrée
dans la sélection dans le menu contextuel de l'éditeur Java.
Cette fonction est utilisable ailleurs qu'à la ligne actuellement exécutée. Essayez d'effectuer un débogage jusqu'à un point d'arrêt et d'avancer pas à pas dans une méthode, quelques lignes en dessous du pointeur d'instruction actuel.
Lorsque le caret ne se trouve pas dans un nom de méthode, la fonction entre dans la méthode suivante sur la ligne sélectionnée.
Par exemple, lorsque le caret se trouve au début de la ligne Vous pouvez aussi avancer d'un pas avec entrée dans une méthode à l'aide de la navigation dans les liens hypertexte. Il suffit de placer le curseur sur la méthode dans laquelle vous voulez entrer après avoir avancé d'un pas et d'utiliser Ctrl+Alt+clic pour avancer d'un pas et entrer dans la méthode (et non Ctrl+clic qui naviguera jusqu'au code source).
|
| Fixation et arrêt du défilement de la console | La sortie affichée dans la console peut être verrouillée sur un processus spécifique à l'aide de l'action Fixer la console de la barre d'outils de la vue Console. Une action Arrêt défil empêche également la console de défiler lorsqu'une nouvelle sortie est ajoutée. |
| Création d'éléments de contrôle | Un élément de contrôle est une expression dans la vue Expressions dont la valeur est mise à jour lors du débogage. Vous pouvez créer des éléments de contrôle à partir de l'éditeur Java en sélectionnant une expression ou une variable et en choisissant Contrôle dans son menu contextuel ou le menu supérieur Exécution. |
| Points de contrôle |
Un point de contrôle est un point d'arrêt qui interrompt l'exécution
chaque fois qu'une zone spécifiée est accédée ou modifiée. Pour définir un
point de contrôle, sélectionnez une zone dans la vue Structure et choisissez
Ajouter/Supprimer un point de contrôle dans son menu contextuel. Pour configurer un point de contrôle, sélectionnez-le dans la vue
Points d'arrêt et choisissez Propriétés dans son menu contextuel. Les propriétés les plus importantes pour ce type de point d'arrêt sont les
cases à cocher Accès et Modification qui contrôlent le moment où
le point d'arrêt peut interrompre l'exécution.
|
| Points d'arrêt de chargement de classe |
Un point d'arrêt de chargement de classe interrompt l'exécution lorsqu'une classe spécifiée est chargée sur la machine virtuelle. Pour définir un point d'arrêt de chargement de classe, sélectionnez une classe dans la vue Structure et choisissez Ajouter/Supprimer un point d'arrêt de chargement de classe à partir de son menu contextuel. Vous pouvez aussi utiliser l'action de menu Exécuter > Ajouter un point d'arrêt de chargement de classe... pour créer un point d'arrêt de chargement de classe.
|
| Points d'arrêt de méthode |
Un point d'arrêt de méthode interrompt l'exécution lorsqu'une méthode spécifique est entrée ou quittée.
Pour définir un point d'arrêt de méthode, sélectionnez une méthode dans la vue Structure et choisissez Ajouter/Supprimer un point d'arrêt dans une méthode à partir de son menu contextuel. Vous pouvez aussi cliquer deux fois sur une ligne de déclaration de méthode dans la règle de l'éditeur ou utiliser l'action de menu Exécuter > Ajouter/Supprimer un point d'arrêt dans une méthode pour créer un point d'arrêt de méthode dans la méthode sélectionnée.
Par défaut, un point d'arrêt de méthode n'interrompt l'exécution qu'en cas d'entrée dans une méthode. Vous pouvez utiliser la sous-fenêtre de détails de point d'arrêt ou la boîte de dialogue Propriétés du point d'arrêt pour configurer le point d'arrêt afin d'interrompre l'exécution à la sortie. Les points d'arrêt de méthode prennent aussi en charge les conditions.
|
| Unités d'exécution et moniteurs |
Le débogueur Java peut afficher les informations du moniteur dans la vue Débogage. L'action Afficher les moniteurs du menu déroulant de la vue Débogage vous permet d'afficher les unités d'exécution détenant des verrous ainsi que celles attendant d'en acquérir. Les unités d'exécution bloquées sont signalées en rouge.
|
| Filtres de progression | Ces filtres empêchent le débogueur
de s'interrompre dans certaines classes et packages lors de l'avance d'un pas
avec entrée dans le code. Les filtres de progression sont établis avec la page
des préférences
Java > Déboguer > Filtrage de progression.
Lorsque l'option Utiliser les filtres de progression est activée
(dans le menu et la barre d'outils de débogage), les filtres de progression sont
appliqués à toutes les actions de progression. Dans la vue Débogage, le package ou le type de déclaration du cadre de pile
sélectionné peut être rapidement ajouté à la liste des filtres en
sélectionnant Filtrer les types ou Filtrer les packages dans le
menu contextuel du cadre de pile. |
| Utilisation du testeur de code |
Si vous souhaitez expérimenter l'API ou tester un nouvel algorithme, il
est souvent plus facile d'utiliser une page de testeur de code Java que de
créer une classe.
Une page de testeur de code est un conteneur pour les
fragments de code aléatoires que vous pouvez exécuter à tout moment sans
contexte. Pour créer une page de testeur de code, créez
un fichier avec l'extension .jpage (ou utilisez
l'assistant
Nouvelle page de testeur de code).
Entrez le code à exécuter, puis sélectionnez-le. Il existe trois façons d'exécuter votre code :
Ces actions se trouvent dans la barre d'outils du plan de travail et également dans le menu contextuel de la page du testeur de code. |
| Edition de configuration de lancement |
Maintenez enfoncée la touche Ctrl et sélectionnez Exécuter ou Déboguer dans le menu déroulant pour ouvrir la configuration de lancement associée pour l'édition. La configuration de lancement peut être également ouverte à partir du menu contextuel associé à un élément de la vue Débogage. |
| Configurations de lancement préférées | Les configurations de lancement apparaissent dans les menus déroulants Exécution/Débogage dans l'ordre lancé le plus récemment. Cependant, il est possible de forcer une configuration de lancement à toujours apparaître sur le dessus des menus déroulants en l'ajoutant aux favoris. L'action Organiser les favoris... du menu déroulant approprié permet de configurer vos configurations de lancement favorites. |
| Modules de formatage des détails |
Dans les vues Variables & Expressions, la sous-fenêtre
de détails affiche une représentation développée de la variable sélectionnée. Par défaut, cette représentation développée est le résultat de l'appel de
toString() sur l'objet sélectionné, mais vous pouvez créer un module de
formatage des détails personnalisé qui sera utilisé à la place, en
sélectionnant Nouveau module de formatage des détails dans le menu
contextuel de la variable. Ce module de formatage des détails sera utilisé
pour tous les objets du même type. Vous pouvez visualiser et modifier tous
les modules de formatage des détails dans la page des préférences
Java
> Déboguer > Modules de formatage des détails.
|
| Exécution du code avec des erreurs de compilation |
Vous pouvez exécuter et déboguer du code qui ne s'est pas compilé
correctement. La seule différence entre l'exécution de code avec et sans erreur de compilation est que si une ligne de code comportant une erreur de compilation est exécutée, vous pouvez vous trouver dans l'un des deux cas suivants :
Il est important d'insister que le fait que tant que le chemin d'exécution évite les lignes de code comportant des erreurs de compilation, vous pouvez procéder à l'exécution et au débogage normalement. |
| Renvoi à la ligne dans la vue Variables | La zone de détails des vues Variables
et Expressions du débogueur prend en charge la fonction de renvoi à la
ligne, disponible à partir du menu déroulant de la vue.
|
| Assistant de code dans le débogueur |
L'assistant de code est disponible dans de nombreux contextes, au-delà de l'écriture de code dans l'éditeur Java :
|
| Détails de la ligne de commande | Vous pouvez toujours voir la ligne de
commande exacte utilisée pour lancer un programme en mode d'exécution ou
débogage en sélectionnant Propriétés dans le menu contextuel d'un
processus ou d'une cible de débogage, même si le lancement est terminé.
|
| Hyperliens de trace de pile |
Les traces de pile Java de la console apparaissent sous forme
d'hyperliens. Lorsque vous placez le pointeur de la souris sur une ligne de
trace de pile, le pointeur se transforme en main.
Cliquez sur le bouton de la souris pour ouvrir le fichier source
Java associé et placez le curseur sur la ligne correspondante. Si vous cliquez sur le nom
de l'exception qui se trouve au sommet de la trace de pile, un point d'arrêt d'exception
est créé.
|
| Débogage dans la perspective Java |
Vous pouvez exécuter des opérations de débogage dans la perspective Java en configurant les préférences Exécution/Débogage > Gestion des vues. Sélectionnez les perspectives dans lesquelles vous voulez effectuer des opérations de débogage.
Activez la préférence d'activation de la vue de débogage lorsqu'un point d'arrêt est atteint (via la page des préférences Exécution/Débogage de premier niveau).
Vous pouvez désactiver l'invite de changement de perspective dans la page des préférences Exécution/Débogage > Perspectives. Avec ces paramètres, la vue de débogage s'ouvre automatiquement dans la perspective Java lorsqu'un point d'arrêt est atteint.
Placez la vue de débogage sur la perspective et redimensionnez sa hauteur en fonction de la taille de l'élément pour que la vue affiche une présentation de l'élément de navigation. Cette opération permet de réduire l'espace qu'occupe la vue sur l'écran.
|