Discussion :

[xeron33]

Bonjour à tous,
Je suis débutant sur Java/Eclipse et j'ai des questionsconcernant le Débug :
Quelle est la définition de Variables et Expressions ou quelle est la différence entre les deux ?
Concernant Breakpoints je me doute ce sont les points de débug (marquage) mais j'aimerais savoir à quoi correspond les
Trigger Point
Hit count ... qui s'affichent quand on clique dessus
Si quelqu'un a des infos dessus Merci

[joel.drigo]

Salut,

Quelle est la définition de Variables et Expressions ou quelle est la différence entre les deux ?

L'onglet Variables affiche les variables et paramètres accessibles dans la portée de la ligne en cours de débogage, permettant de connaître leur valeur.
L'onglet Expression permet d'afficher des résultats d'expression, évaluable dans la même portée :

1. des calculs sur des variables
2. des appels de méthodes

Dans le menu contextuel de l'éditeur en mode debug, tu as un menu Watch : si tu sélectionnes une partie de ligne de code qui correspond à une expression évaluable, elle va aller se placer dans cet onglet et tu pourras y voir la valeur évaluée de cette expression.

Par exemple, si tu débogue une méthode qui fait un traitement de List, tu peux vouloir savoir comment cette liste évolue.

Par exemple, on débogue ce programme :

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
import java.util.ArrayList;
import java.util.List;
 
public class Fibo {
 
	public static void main(String[] args) {
 
		System.out.println(fibo(10));
 
	}
 
	private static List<Integer> fibo(int n) {
		List<Integer> list = new ArrayList<>(n);
		for(int i=0; i<n; i++) {
			list.add(fibo(list,i));
		}
		return list;
	}
 
	private static int fibo(List<Integer> list, int n) {
		int fibo;
		switch(n) {
		case 0:
			fibo = 1;
			break;
		case 1:
			fibo = 2;
			break;
		default:
			fibo = list.get(n-1)+list.get(n-2);
		}
		return fibo;
	}
 
}

Avec un breakpoint sur la ligne 30 fibo = list.get(n-1)+list.get(n-2);, on peut connaître par l'onglet Variables les valeurs de :

• n
• fibo
• list

On va pouvoir connaître les valeurs des expressions qui nous permettront de comprendre plus facilement qu'avec les valeurs de ces variables, ce qu'il se passe dans l'exécution :

Hit count ... qui s'affichent quand on clique dessus

Un breakpoint est un point d'arrêt : lors de l'exécution en debug, le programme s'arrête sur le breakpoint, ce qui permet de connaître à ce moment d'exécution l'état du programme (la valeur des variables en résumé, l'endroit où on se trouve, la pile d'invocation, etc).
Hit count permet d'indiquer le nombre de fois qu'il faut passer par le breakpoint avant de s'arrêter. Par exemple, si on met un breakpoint sur une ligne dans une boucle de 1 à 10000, et qu'on veut voir ce qu'il se passe à la 7000^ème itération, c'est bien pratique de mettre un hitcount de 7000 sinon on va devoir cliquer sur "Resume" 6999 fois...

Concernant Breakpoints je me doute ce sont les points de débug (marquage) mais j'aimerais savoir à quoi correspond les
Trigger Point

Il y a aussi Conditionnal qui permet d'indiquer un test sur des états du programme qui conditionne l'arrêt. Si le nombre de passages par une ligne ne permet pas de savoir qu'il faut s'arrêter l'expression conditionnelle sur une variable peut permettre de facilement s'arrête au moment qui nous intéresse. Par exemple, dans l'exemple précédent, on peut tester l'indice de boucle : i==7000, ou si on sait qu'on a un problème de traitement d'une liste de String quand la valeur est null, on peut mettre la condition list.get(i)==null.

Parfois, on veut pouvoir s'arrêter lorsque on est passé par plein d'endroits, avec différentes conditions. Trigger point permet de marquer un breakpoint comme point de passage obligatoire avant que le programme s'arrête sur un autre type de breakpoint.

Par exemple :

Code :

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

1
2
3
4
5
for(Machin machin : listeDeMachins) {
    machin = traitement1(machin);
    machin = traitement2(machin);
    machin = traitement3(machin);
}

On met un hitcount de 10 et un conditionnal breakpoint lorsque machin.getNom().equals("Truc") sur la ligne 2 et , et on met un breakpoint normal sur ligne 4. Ainsi, le programme s'arrêtera sur la ligne 4 seulement lorsqu'on aura traité 10 fois un machin de nom Truc, sans avoir à se taper 150 arrêts avant.
Ceci est particulièrement utile dans le débogage de boucles, de méthodes récursives, de processus de GUI ou de multithread, lorsqu'on veut pouvoir observer ce qu'il se passe après plein de conditions vérifiées à plein d'endroits et après un grand nombre de passages par certaines lignes/méthodes, sans avoir à se peler 3000 clics sur "Resume".

[xeron33]

Dans le menu contextuel de l'éditeur en mode debug, tu as un menu Watch : si tu sélectionnes une partie de ligne de code qui correspond à une expression évaluable, elle va aller se placer dans cet onglet et tu pourras y voir la valeur évaluée de cette expression.

Bonjour et un grand merci pour ta réponse bien détaillée !!!
Tout d'abord avant d'aller plus loin : voilà la version d'Eclipse que j'utilise et le Windows aussi

Eclipse IDE for Java Developers
Version: Oxygen.3a Release (4.7.3a)
Build id: 20180405-1200
OS: Windows 7, v.6.1, x86_64 / win32

Je ne vois ce menu Watch voilà ce que j'ai comme menu en contextuel mode débug

Impossible de faire de capture d'écran désolé j'ai été obligé de photographier mon écran d'ou ces 3 photos te montrant bien le menu que j'ai pour bien qu'on soit en phase
Merci à +

[joel.drigo]

C'est le menu contextuel de l'éditeur (il faut donc donner le focus à l'éditeur). Il faut sélectionner l'expression que tu veux ajouter :



Tu peux aussi utiliser l'option "Add new expression" dans la vue Expressions :

[xeron33]

C'est le menu contextuel de l'éditeur (il faut donc donner le focus à l'éditeur). Il faut sélectionner l'expression que tu veux ajouter :
Tu peux aussi utiliser l'option "Add new expression" dans la vue Expressions :

Merci pour ton aide, je n'ai pas le même menu contextuel que toi mais effectivement on peut ajouter des expressions dans la vue Expressions, j'ai pigé je pense dans l'ensemble le fonctionnement du débug.
Une question encore sur le débug :
Dans la Vue Variable en déboguant j'ai ceci :

Peux tu me dire que veux dire id=508 pour ArrayList<E> ? son adresse mémoire ?
Je voudrais savoir aussi niveau JAVA pour les ArrayList quand on en crée une, le paramètre <E> d'après ce que j'ai compris est un itérateur permettant de parcourir la liste soit ici :

Code :

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

1
2
3
4
5
6
7
8
 
private static List<Integer> fibo(int n) {
		List<Integer> list = new ArrayList<>(n);
		for(int i=0; i<n; i++) {
			list.add(fibo(list,i));
		}
		return list;
	}

on crée une liste avec un itérateur de type Integer soit <Integer> ?
D'autre part le constructeur de la classe est bien cette méthode ?
De type :d'après l'aide de JAVA :

/*public ArrayList​(Collection<? extends E> c)

Constructs a list containing the elements of the specified collection, in the order they are returned by the collection's iterator.

Parameters:
c - the collection whose elements are to be placed into this list
Throws:
NullPointerException - if the specified collection is null */

Ou ici le List<Integer> est la collection et int n est le paramètre "c"

C'est bien ça ?
MErci encore pour ton aide précieuse
A+

[joel.drigo]

Peux tu me dire que veux dire id=508 pour ArrayList<E> ? son adresse mémoire ?

Même si au final tout est stocké en mémoire et, donc, a une adresse mémoire, en Java, on ne s'en sert jamais, ça n'a pas vraiment d'intérêt. Il est même compliqué de l'obtenir (il y a bien la classe sun.misc.Unsafe, ou l'équivalent dans d'autres JVM que celle de Sun/Oracle, mais il ne faut pas s'en servir, et en paramétrage JavaSE tu n'y auras pas accès sous Eclipse). En Java, on parle plutôt de référence, et si dans certaines conditions, on peut les manipuler (les comparer par exemple par ==, ou s'en servir de clef de map dans une IdentityHashMap), on y accède non plus jamais, ça n'a pas d'intérêt au niveau programmation. Le debugger toutefois génère une liste de valeurs qui permet de facilement reconnaître que deux instances soient les mêmes (ou soient différentes) : c'est ce qui s'appelle id dans le debugger. Donc ça ressemble à une adresse, mais ça n'a pas de rapport avec une adresse mémoire, ni même avec le stockage en mémoire des références d'instances et ne doit pas être considéré comme tel (surtout que ça n'a aucun intérêt). C'est un numéro généré par le debugger et il n'est seulement garanti que ça soit le même pour une même instance au cours d'un run.

Je voudrais savoir aussi niveau JAVA pour les ArrayList quand on en crée une, le paramètre <E> d'après ce que j'ai compris est un itérateur permettant de parcourir la liste soit ici :

Code :

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

1
2
3
4
5
6
7
8
 
private static List<Integer> fibo(int n) {
		List<Integer> list = new ArrayList<>(n);
		for(int i=0; i<n; i++) {
			list.add(fibo(list,i));
		}
		return list;
	}

C'est ce qu'on appelle un type paramétré. On parle aussi de générique.

Un itérateur c'est quelque chose qui permet d'itérer, donc de parcourir les éléments d'une instance qui en contient plusieurs (une collection). Plus précisément, en Java, un itérateur est modélisé par une classe qui implémente l'interface Iterator.

Le type paramétré permet juste d'indiquer au compilateur qu'on définit une classe qui va manipuler un type qu'on ne connait pas forcément à l'avance (on peut en connaître certaines caractéristiques en revanche).

Cette notion est apparue en Java 5. Pour la List, il permet de paramétrer le type d'éléments dans la liste.

Avant, quand on créait une List par exemple, on écrivait :

Code :

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

List list = new ArrayList();

Et on pouvait mettre n'importe quoi dedans (enfin que des objets, pas des primitifs, parce que le autoboxing/unboxing n'existait pas non plus mais c'est un autre sujet), le compilateur s'en foutait :

Code :

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

1
2
3
list.add(new Integer(0));
list.add("machintruc");
list.add(new JFrame());

Le souci, c'est qu'au traitement de lecture :

1. il fallait éventuellement tester la classe de l'élément à un index donné
2. caster systématiquement, même quand on savait qu'on stockait que des instances d'un type spécifique et c'était plutôt lourd

En plus, quand on voulait faire des classes dont le code était commun à plusieurs types héritant d'un seul, donc avec les mêmes méthodes d'une part, et des méthodes spécifiques d'autres parts, il fallait souvent devoir faire plein de tests du type instanceof et de cast pour appeler les méthodes spécifiques. Bref, ça compliquait le code. Le paramétrage n'est pas obligatoire et on peut continuer à faire des classes non paramétrées, y compris des Collection, List, Map etc, mais le cas le plus fréquent est simplifié et on bénéficie de contrôles à la compilation (et l'écriture du code dans les IDE) qu'on ne pouvait avoir qu'à l'exécution avant.

L'introduction du type paramétré a permis de simplifier beaucoup d'écritures de codes utilisés fréquemment. Il permet aussi de contrôler que le développeur manipule les bons types à la compilation (et facilite donc la complétion, puisque ça utilise aussi ces informations). Il ne permet pas d'empêcher de le faire, mais le développeur qui le fait contournera volontairement ce système et ne devra pas s'étonner des dysfonctionnements à l'exécution.

Enfin, ça n'a rien à voir avec Iterator, puis qu'on peut paramétrer n'importe quelle classe, y compris qui n'a pas de notion d'itérateur et n'est pas une collection d'instances d'ailleurs.

Code :

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

1
2
3
4
5
6
public class MachinTruc<T> {
    private final T variable;
    public MachinTruc(T variable) {
          this.variable=variable;
    }
}

Ou ici le List<Integer> est la collection et int n est le paramètre "c"

1. List<Integer> c'est le type de collection, le paramètre Integer indiquant qu'on veut stocker des Integer dans cette liste.
   A noter que si List est une Collection, l'inverse est faux. Précisément, en terme d'objet, Une Collection est une série d'objets dont on connait le nombre (la taille de la Collection). List est une Collection qui permet d’accéder à chaque élément par un indice. Pour traiter les éléments d'une Collection, on ne peut utiliser que son Iterator, ou la convertir en tableau éventuellement.
2. Le constructeur dont tu montres la javadoc, public ArrayList(Collection<? extends E> c), est un constructeur qui prend une Collection en paramètre, qui doit contenir des éléments de même type que l'ArrayList qu'on est en train de créer, ou de type étendant celui-là (dans une ArrayList<Number> on peut mettre une Collection<Integer>) et qui va être initialisée comme stockant l'ensemble des éléments de cette Collection.
3. Dans mon code, en revanche, j'utilise le constructeur public ArrayList(int n). Une ArrayList est une implémentation de List qui utilise un tableau en interne pour stocker les éléments. Le principe c'est que lorsqu'on créé une ArrayList, un tableau d'une certaine taille est créé (en Java les tableaux ne sont pas de taille variable), et on peut ajouter autant d'éléments qu'on veut (pas tout à fait, parce qu'il y a des limites mais c'est pour le principe), le tableau étant modifié de façon à pouvoir stocker ces éléments.
   
   Le principe en gros, c'est qu'au début, un tableau relativement petit est créé et sa référence est stockée dans une variable interne de ArrayList. Lorsqu'on ajoute un élément, et qu'il n'y a plus de place dans le tableau, un nouveau tableau plus grand est créé, tous les éléments se trouvant dans l'ancien sont copiés vers le nouveau, on met la référence du nouveau tableau dans la variable interne de ArrayList, et ça ça prend du temps). Le paramètre int ici pour les ArrayList permet de dimensionner le tableau avec cette valeur. Lorsqu'on sait le nombre d'éléments à l'avance, ça permet de gagner du temps que d'indiquer dès le début quelle est la taille qu'on veut pour le tableau. Cela peut servir à d'autres choses également : par exemple, s'il n'y a pas assez de mémoire, le tableau ne pourra pas être créé et la méthode plantera tout de suite sans avoir à attendre que tous les calculs précédents soient faits.

[xeron33]

Bonsoir et encore merci pour toutes ces infos, si j'ai bien compris ton constructeur est donc celui-ci :

public ArrayList​(int initialCapacity)

Constructs an empty list with the specified initial capacity.

Parameters:
initialCapacity - the initial capacity of the list
********************************************

[joel.drigo]

Exact.