Algorithmique & Programmation Orientée Objet Semestre 2 ST Les types agrégés
| Problématique | Types agrégés en langage algorithmique | Types agrégés en langage Java |
| Initialisation automatique à la déclaration | Type agrégé dans un type agrégé | Affectation et test d'égalité entre types agrégés |
Cours | Exercices PDL | Exercices Java
Version PDF
Clavier.class - Ecran.class - Documentation
Problématique Fréquente association fonctionnelle des données manipulées dans le monde réel -> Association de ces données dans les programmes informatiques les modélisant Exemples Une date: Un numéro d'année, un numéro de mois et un numéro de jour Une heure: Un numéro d'heure, un numéro de minute et un numéro de seconde Une position dans un espace à 2 dimensions: Une abscisse et une ordonnée Une position dans un espace à 3 dimensions: 3 coordonnées usuellement nommées x, y et z Un nombre complexe: Une partie réelle et une partie imaginaire Une adresse: Un nom, un prénom, un numéro dans la rue, un nom de rue, un code postal, une ville et un pays Liaison de ces données en agrégats permettant de les manipuler en tant qu'une seule donnée (variable) composite -> Un bon moyen pour rendre plus aisé le développement: - Structuration du stockage de l'information - Manipulation en une seule variable de tout un lot d'informations - Lecture et compréhension plus aisées des programmes Solution: Les types agrégés Types agrégés en langage algorithmique Type agrégé: Type de définition de variable regroupant en fait plusieurs "champs" (sous-variables, variables membres) élémentaires accessibles individuellement Dénomination usuelle: "structure" Syntaxe:
structure nomStructure type champ1 type champ2 ... type champN fin structure
nomStructure: Le nom donné au type agrégé champ1, champ2, ..., champN: Les N noms des N champs définis au sein du type agrégé accompagnés individuellement d'un type spécifiant ce qu'ils sont à même de contenir (types éventuellement différents les uns des autres)
Définition d'une variable selon un type agrégé selon la même syntaxe que celle des types "classiques" (types prédéfinis):
nomStructure nomVariable
Syntaxe d'accès aux champs d'une variable de type agrégé:
nomVariable.champ1
nomVariable: Une variable de type agrégé champ1: Un des champs de ce type agrégé
Choix d'un nom de structure Lettres non accentuées et _ Chiffres (sauf premier caractère) Conventions Emploi exclusif de minuscules Si utilisation d'un nom composé, initiale en majuscule pour chaque composante à l'exception de la première Recommandation: Choix des noms des structures de manière explicite vis à vis des informations stockées Exemples: date, adressePostale Exemples de structures
structure date entier jour entier mois entier annee fin structure | structure heure entier h entier mn entier s fin structure
structure position2D reel abscisse reel ordonnee fin structure | structure position3D reel x reel y reel z fin structure
structure complexe reel partieReelle reel partieImaginaire fin structure | structure adressePostale chaine nom chaine prenom entier numero chaine rue entier zip chaine ville chaine pays fin structure
Exemple d'algorithme avec structures Problème: Calculer et afficher la distance entre deux positions du plan
{ Calcul de la distance entre deux positions du plan } { Type agrege de stockage d'une position du plan } structure position2D reel abscisse reel ordonnee fin structure { Programme principal } action principale() position2D p1 position2D p2 réel distance réel dx réel dy afficher("SVP, coordonnees point 1 ?") p1.abscisse <- saisir() p1.ordonnee <- saisir() afficher("SVP, coordonnees point 2 ?") p2.abscisse <- saisir() p2.ordonnee <- saisir() dx <- p2.abscisse-p1.abscisse dy <- p2.ordonnee-p1.ordonnee distance <- sqrt(dx*dx+dy*dy) afficher("Distance = ",distance) fin action
DistancePositions2D.lda
Types agrégés en langage Java Description dans la classe application avant (ou après) la fonction main Pas de définition dans le main Dénomination en langage Java: classe ou "class" Syntaxe:
static class NomType { type variable1; type variable2; ... type variableN; };
NomType: Nom du type déclaré variable1, variable2, ..., variableN: N sous-variables ("variable membre") définies selon les types spécifiés (éventuellement différents les uns des autres)
Pour le langage Java, syntaxe particulière lors de la déclaration d'une variable d'un type agrégé:
NomType nomVariable = new NomType();
Utilisation obligatoire du new à la déclaration de toute variable de type agrégé
Syntaxe d'accès aux champs d'une variable de type agrégé (identique à la syntaxe algorithmique):
nomVariable.variable1
nomVariable: Une variable de type agrégé variable1: Une des variables membres de ce type agrégé
Choix d'un nom de classe Lettres non accentuées Utilisation éventuelle de chiffres (sauf premier caractère) Conventions Minuscules avec initiale en majuscule Si utilisation d'un nom composé, initiale en majuscule pour chaque composante y compris la première -> Différentiation entre les noms des variables et les noms des types Recommandation: Choix des noms des classes de manière explicite vis à vis des informations stockées Exemples : Date, AdressePostale Exemples de classes
static class Date { int jour; int mois; int annee; }; | static class Heure { int h; int mn; int s; };
static class Position2D { float abscisse; float ordonnee; }; | static class Position3D { double x; double y; double z; };
static class Complexe { float partieReelle; float partieImaginaire; }; | static class AdressePostale { String nom; String prenom; int numero; String rue; int zip; String ville; String pays; };
Exemple de programme Java avec classes Problème: Calculer et afficher la distance entre deux positions du plan
/* Calcul de la distance entre 2 positions du plan */ public class DistancePositions2D { /* Type agrege de stockage d'une position du plan */ static class Position2D { double abscisse; double ordonnee; }; /* Programme principal */ public static void main(String [] args) { Position2D p1 = new Position2D(); Position2D p2 = new Position2D(); double distance; double dx; double dy; Ecran.afficherln("SVP, coordonnees point 1?"); p1.abscisse = Clavier.saisirDouble(); p1.ordonnee = Clavier.saisirDouble(); Ecran.afficherln("SVP, coordonnees point 2?"); p2.abscisse = Clavier.saisirDouble(); p2.ordonnee = Clavier.saisirDouble(); dx = p2.abscisse-p1.abscisse; dy = p2.ordonnee-p1.ordonnee; distance = Math.sqrt(dx*dx+dy*dy); Ecran.afficherln("Distance = ",distance); } }
DistancePositions2D.java - Exemple d'exécution
Initialisation automatique des champs Intérêt supplémentaire des types agrégés: Réalisation automatique d'une initialisation de leurs champs avec possibilité de choisir la valeur d'initialisation -> Initialisation implicitement réalisée donc certaine -> Moins de risque d'oubli -> Plus d'initialisation explicite à chaque déclaration de variable -> Economie de code Syntaxe
Langage algorithmique | Langage Java
structure nomStructure type champ1 <- valeur1 type champ2 <- valeur2 ... type champN <- valeurN fin structure | static class NomType { type variable1 = valeur1; type variable2 = valeur2; ... type variableN = valeurN; };
Exemples
structure position3D reel x <- 0.0 reel y <- 0.0 reel z <- 0.0 fin structure | static class Position3D { double x = 0.0; double y = 0.0; double z = 0.0; };
structure date entier jour <- 1 entier mois <- 1 entier annee <- 1901 fin structure | static class Date { int jour = 1; int mois = 1; int annee = 1901; };
structure adresse chaine nom <- "" chaine prenom <- "" entier numero <- 0 chaine rue <- "" entier zip <- 0 chaine ville <- "" chaine pays <- "" fin structure | static class Adresse { String nom = ""; String prenom = ""; int numero = 0; String rue = ""; int zip = 0; String ville = ""; String pays = ""; };
Recommandation Toujours faire une initialisation des champs des types agrégés En Java, si pas d'initialisation explicite, initialisation implicite à "0". Exemple de programme Java avec classe (type agrégé) avec initialisation des champs
/* Test de classes sans et avec initialisation */ public class TestInitialisationClasse { /* Stockage d'une date sans initialisation */ static class DateSansInit { int jour; int mois; int annee; }; /* Stockage d'une date avec initialisation */ static class DateAvecInit { int jour = 1; int mois = 1; int annee = 1901; }; /* Programme principal */ public static void main(String [] args) { DateSansInit d1 = new DateSansInit(); DateAvecInit d2 = new DateAvecInit(); Ecran.afficher("Date 1 : "); Ecran.afficherln(d1.jour,":", d1.mois,":", d1.annee); Ecran.afficher("Date 2 : "); Ecran.afficherln(d2.jour,":", d2.mois,":", d2.annee); } }
TestInitialisationClasse.java - Exemple d'exécution
Type agrégé dans un type agrégé Utilisation possible d'un type agrégé déjà déclaré, comme n'importe quel autre type, lors de la déclaration d'un autre type agrégé (pas de création de cycle) Attention: En langage java, dans la déclaration de type, initialisation par new obligatoire pour chaque variable membre de type agrégé Exemples
structure position2D x : reel <- 0.0 y : reel <- 0.0 fin structure structure cercle centre : position2D rayon : reel <- 1.0 fin structure | static class Position2D { double x = 0.0; double y = 0.0; }; static class Cercle { Position2D centre = new Position2D(); double rayon = 1.0; };
Exemple: Programme Java de manipulation d'un temps avec année, mois, jour, heure, minute et seconde
/* Type agrege constitue de types agreges */ public class TypeAgregeDeTypesAgreges { /* Stockage d'une date avec initialisation */ static class Date { int jour = 1; int mois = 1; int annee = 1901; }; /* Stockage d'une heure avec initialisation */ static class Heure { int seconde = 0; int minute = 0; int heure = 0; }; /* Stockage d'un temps compose */ /* d'une Date et d'une Heure */ /* Initialisation obligatoire */ /* des deux variables membres agregees */ static class Temps { Heure heure = new Heure(); Date date = new Date(); }; /* Programme principal */ public static void main(String [] args) { Temps temps = new Temps(); Ecran.afficherln(temps.date.annee,":", temps.date.mois,":", temps.date.jour,":", temps.heure.heure,":", temps.heure.minute,":", temps.heure.seconde); } }
TypeAgregeDeTypesAgreges.java - Exemple d'exécution
{ Stockage d'une date avec initialisation } structure typeDate entier jour <- 1 entier mois <- 1 entier annee <- 1901 fin structure { Stockage d'une heure avec initialisation } structure typeHeure entier seconde <- 0 entier minute <- 0 entier heure <- 0 fin structure { Stockage d'un temps compose } { d'un typeDate et d'un typeHeure } { Initialisation obligatoire } { des deux variables membres agregees } structure typeTemps typeHeure heure typeDate date fin structure
TypeAgregeDeTypesAgreges.lda
Affectation et test d'égalité entre variables de types agrégés identiques Affectation champ pour champ Opération d'affectation utilisable sur les variables de types agrégés identiques (signe <- en langage algorithmique, signe = en langage Java) ATTENTION, confusion totale et irréversible entre les deux variables après l'affectation -> Variable unique désignée par deux noms -> Toute modification apportée à l'une est apportée à l'autre. -> Dangereux Opération véritablement réalisée: Affectation à la variable à droite de l'adresse mémoire de la variable à gauche Affectation sans confusion à tout jamais avec affectation "champ pour champ": Programmation explicite de l'affectation champ pour champ
/* Affectation entre variable agregees */ public class AffectationVariablesAgregees { /* Stockage d'une position en 3 dimensions */ static class Position3D { double x = 0.0; double y = 0.0; double z = 0.0; }; /* Programme principal */ public static void main(String [] args) { Position3D p1 = new Position3D(); Position3D p2 = new Position3D(); Ecran.afficherln("Variables après déclaration"); Ecran.afficherln("P1 : ",p1.x," ",p1.y," ",p1.z); Ecran.afficherln("P2 : ",p2.x," ",p2.y," ",p2.z); Ecran.afficherln(); p2.x = 1.0; p2.y = 1.0; p2.z = 1.0; Ecran.afficher("Après affectations sur "); Ecran.afficherln("les variables membres de P2"); Ecran.afficherln("P1 : ",p1.x," ",p1.y," ",p1.z); Ecran.afficherln("P2 : ",p2.x," ",p2.y," ",p2.z); Ecran.afficherln(); p1 = p2; Ecran.afficherln("Après affectation de P2 à P1"); Ecran.afficherln("P1 : ",p1.x," ",p1.y," ",p1.z); Ecran.afficherln("P2 : ",p2.x," ",p2.y," ",p2.z); Ecran.afficherln(); p1.x = 4.0; p2.y = 2.0; Ecran.afficher("Après affectations sur les "); Ecran.afficherln("variables membres de P1 & P2"); Ecran.afficherln("P1 : ",p1.x," ",p1.y," ",p1.z); Ecran.afficherln("P2 : ",p2.x," ",p2.y," ",p2.z); Ecran.afficher("-> Il n'y a plus qu'une seule "); Ecran.afficherln("variable avec deux noms"); } }
AffectationVariablesAgregees.java - Exemple d'exécution
Test d'égalité champ pour champ (et test de différence) Opérations possibles (signe == pour le test d'égalité, signe != pour le test de différence) ATTENTION, ne marche pas comme on pourrait l'attendre c'est à dire par réalisation de tests champ pour champ Opérations véritablement réalisées: Tests sur les adresses mémoires des variables Solution pour faire un test "champ pour champ": Implanter explicitement un test champ pour champ
/* Tests d'egalite entre 2 Position2D */ public class TestEgalitePosition2D { /* Type agrege de stockage des informations */ /* relatives a une position en deux dimensions */ static class Position2D { double x = 0.0; double y = 0.0; }; /* Programme principal */ public static void main(String [] args) { Position2D p1 = new Position2D(); Position2D p2 = new Position2D(); boolean egal; Ecran.afficherln("Contenus des variables"); Ecran.afficherln("p1 : ",p1.x," ",p1.y); Ecran.afficherln("p2 : ",p2.x," ",p2.y); Ecran.sautDeLigne(); Ecran.afficherln("Adresses des variables"); Ecran.afficherln("p1 : ",p1); Ecran.afficherln("p2 : ",p2); Ecran.sautDeLigne(); egal = (p1 == p2); Ecran.afficherln("Test d'egalite direct : ",egal); egal = ( ( p1.x == p2.x ) && ( p1.y == p2.y ) ); Ecran.afficherln("Test d'egalite champ pour champ : ",egal); } }
TestEgalitePosition2D.java - Exemple d'exécution
Conclusion Nécessité absolue de structurer les données manipulées dans les programmes informatiques Ensemble des types créés: "Structure de données" utilisée pour le stockage des informations