la programmation orientée objet

Introduction
Approche fonctionnelle
Approche objet
JAVA

Approche fonctionnelle
Transformer un nombre (NB)
Valide (NB) Orthographier-F(NB) Orthographier-C(NB)
Orthographier-3 (N)
Orthographier-D(N) Orthographier-U (N)
PB : transformer un nombre numérique en son équivalent alphanumérique

Programmation procédurale
Les facilités de base offertes par les langages qui supportent ce style de
programmation sont les fonctions qui admettent des arguments et qui renvoient
des valeurs.
Comme exemple, considérons la fonction qui calcule le pgcd de deux entiers positifs
long pgcd(long x, long y)
{ unsigned long r ;
if (x < y) { r = x ; x = y ; y = x ; }
do { r = x % y // r est le reste de la division entière de x et y
x = y ; y = r } // réitérer ce processus en échangeant (x, y) par (y, r)
while (r != 0) ; // tant que le reste de la division entière x et y est non nul
return x ; // retourne le pgcd }
Une fois cette fonction donnée, il est possible à présent d'utiliser cette fonction dans
toute autre fonction.
void une_fonction(void) { ... x = pgcd(4356, y) ; ... }

Programmation modulaire (1)
Avec l'augmentation de la taille des programmes, la programmation procédurale atteint
ses limites ; la programmation modulaire voit alors le jour.
Ce style de programmation utilise les principes d'encapsulation des données.
L'ensemble des procédures ou fonctions dépendantes et les données qu'elles manipulent
sont regroupés dans un module. Un programme est alors constitué de plusieurs modules
et la communication inter-modules se fait à travers une interface ; les détails
d'implantation de chaque module sont cachés aux autres modules.
Imaginons qu'il faille réaliser un programme dans lequel on utilise des piles.
Un des modules de ce programme se charge de l'implantation d'une pile et les détails de
cette implantation devant être ignorés par les autres modules.
L'interface que fournit ce module est constituée d'un fichier (par exemple " pile.h ")
// Interface du module PILE de caractères (pile.h)
void empiler(char) ;
char depiler(void) ;
// Fin de l'interface

Programmation modulaire (2)
Les utilisateurs de ce module ignorent parfaitement les détails d'implantation de
cette pile. En particulier, s'agit-il d'un tableau ou d'une liste chaînée ? Seul le
programmeur de ce module le sait. L'utilisation de ce module par d'autres se fait
alors de la manière suivante :
// Module XXX utilisant une pile de caractère
#include "pile.h"
void une_fonction()
{ short c1, c2 ;
... empiler('a') ;
empiler('b') ;
... c1 = depiler() ;
if (c1 == ERREUR) erreur(" la pile est vide ") ;
c2 = depiler() ; if (c2 == ERREUR) erreur(" la pile est vide ") ;
... } // Fin du module XXX