Aggrégats de données

images/whitebelt.png

Bien que cela ne soit pas utilisé de manière fréquente en Java on peut regrouper des données pour créer un data object c’est à dire un amalgame de données. L’organisation de ces données suit un plan défini par un type composite créé dans un but de gestion commune.

La notion de classe , plus générale, est utilisée en Java pour définir un modèle utilisé pour créer de simples data objects (objets composites).

Une classe simplifiée pour définir des data objects

public class Versement {
   double valeur ;  // "variable membre" ou "champ"
   String monnaie ;
   // l'heure est souvent conservée sous forme de long
   long heureOperation ;
}

Le code appelant du code précédent va être situé dans une autre classe.

Le "point d’entrée" (le code qui va être appelé au démarrage) se trouve dans une méthode avec un nom et une signature prédéfinie.

public static void main(String[] arg) {

Nous verrons ultérieurement les détails concernant cette méthode "magique".

public class TestVersement {
    public static void main(String[] args) {
        Versement op1 ;          // declaration
        op1 = new Versement() ;  // allocation
        op1.valeur=10.99 ;     // initialisations
        op1.monnaie="GBP";
        op1.heureOperation=System.currentTimeMillis();
        // d'autres instructions
       System.out.println(" valeur du virement : " + op1.valeur) ;
    }
}

Dans ce code nous créons à l’aide de new une donnée op1 qui est une instance d’une classe (Versement). Il pourrait y avoir plusieurs variables de ce type contenant différentes combinaisons de valeurs: on aurait plusieurs instances (on dit aussi "plusieurs objets").

Notez également l’importance de ces trois phases:

Nous verrons plus tard qu’il est souhaitable de combiner les opérations allocation/initialisations … ne serait-ce que pour éviter d’avoir en mémoire un emplacement incomplètement initialisé!

exercices

Les données en mémoire

images/orangebelt.png

Lorsqu’on écrit un ensemble d’instructions dans un code il y a des différences entre les types scalaires et les types objets en ce qui concerne l’allocation de la mémoire.

Mais d’abord regardons d’un peu plus près comment est gérée la mémoire d’un code qui s’exécute (un processus).

Manipulation de données, gestion de la mémoire

Chaque processus dispose d’une zone mémoire pour gérer ces données: comment est organisée la disposition des variables dans la mémoire?

zones variables

La zone statique

Ici sont allouées des variables qui auront la même durée de vie que le processus (variables globales, variables rémanentes).

Inconvénients: on ne peut pas allouer toutes les variables du programme de cette manière (place en mémoire, variables temporaires) et de plus il faut généralement pour les allouer passer par une phase d’assemblage de tous les codes constituant l’application (opération "d'édition de lien").

Java n’utilise pas cette possibilité (donc ici nous décrivons la zone statique du point de vue de la culture générale en informatique).

La (ou les) pile(s) d’exécution:: Le code est découpé en petites "fonctions" qui sont spécialisées dans une opération particulière.

+ Pour être réutilisables dans de nombreuses circonstances ces codes sont paramétrés.

+

 a = cosinus(y)
 b = cosinus(z)

+ De plus ils utilisent des variables internes qui ne sont utilisées que pendant que cette fonction s’exécute.

+ Chaque thread (fil?) d’exécution gère dynamiquement l’appel de ces fonctions.

+ pile

+ L’exécution d’une fonction se fait à l’emplacement du pointeur de pile. Les données (paramètres, variables locales) sont allouées par rapport à cet emplacement. Quand le calcul est terminé la place est récupérée.

Le tas:: Dans de nombreux langages de programmation on doit gérer le fait que certaines allocations ne sont connues qu’au moment de l’exécution:

+ A l’exécution on a un mécanisme d’allocation dynamique dans le tas.

+ Selon les langages on a des mécanismes gérés par le programmeur (langage C) ou automatiques (langages Java, Lisp, etc.).

+ Même si la nature de l’allocation est connue par Java dès la compilation il va allouer toutes vos demandes (par new) dans le tas.

+ Nous verrons ultérieurement comment java gère ces emplacements globalement (en particulier comment il se débarrasse des emplacements qui ne sont plus utilisés)

Valeurs scalaires dans la mémoire

schema: types primitifs

Une variable de type scalaire utilisée dans une méthode (paramètre, variable locale interne à la méthode) sera directement allouée sur la pile d’exécution.

Allocations des objets dans la mémoire

schema: objets

Un "objet" (créé par new) sera alloué dans le tas (certains optimiseurs peuvent envisager d’allouer certains objets sur la pile mais c’est pour le moment anecdotique).

La "référence" de l’emplacement mémoire sera, de manière transparente, allouée sur la pile (sauf pour les objets eux-mêmes référencés par d’autres objets! Ce qui est le cas de monnaie dans le croquis)