Algorithmique-Programmation Orientée Objet Semestre 2 ST

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