Programmation Par Objets : Petite Introduction

Programmation avec les objets

Deux aspects

• Aspect conceptuel :
  
  • Objet = entité du monde réel (document, point de l'espace, article de commerce, fenêtre sur écran...)
• Aspect programmation (en génie logiciel) :
  
  • Objet = abstraction, qui permet de s'intéresser d'abord à l'essentiel d'abord. Notion de type abstrait de donnée.

Objet = entité du monde réel.

Exemples En Javascript

document.write(); 

où document est une  page Web en cours d'affichage (l'objet considéré). L'effet de cette fonction write() est écrire un message dans le document.

 document.getElementsByTagName( 'p' );

fonction qui retourne un objet paragraphe ( p ) dans un document HTML.

par = document.getElementsByTagName( 'p' );
par.setAttribute("style", "color:blue");

on peut ensuite lui attribuer avec setAttribute() une couleur bleu (color:blue)...

window.open("https://docs.oracle.com/javase/tutorial/");

on ouvre l'URI spécifié dans l'objet window, qui représente une fenêtre du navigateur.

window.moveTo(...)    déplace une fenêtre vers la position donnée

Exemples en Java

ecran.println("Hello, World"); 

• On imprime un message sur l'objet ecran.
• C'est un objet de classe (type) PrintStream , flux de sortie.
• La classe définit un ensemble d'objets de même nature.

Objet = données + opérations

OBJET = données + opérations  (dits aussi attributs et méthodes).

String	attributs :  length , ... méthodes : charAT(), concat(), indexOf(), ... usage :  i = s.indexOf('a');    -- le rang de a dans la chaîne s.
Point	p.setX(2);          -- affecte 2 à l’abscisse x du point p   a = p.getY();     -- accès à l’ordonnée y de p
Calendar	maintenant = Calendar.getInstance();   jour = maintenat.get (Calendar.DAY_OF_MONTH);

etc...

Objet = abstraction, qui permet de s'intéresser d'abord à l'essentiel.

• Exemple de problème:
  • Vérifier si une expression est bien parenthésée:
    ( ( ) )  ( )  ( ( ( ) ) )
  • Expression générale  bien parenthésée:
    ( [ ]  )  { }  ( { (< > ) } )-

Exemple d'une pile

• Utiliser une pile.
  Un Type Abstrait de Données : données définies uniquement par les opérations qu'on peut leur appliquer.
• Sur une pile, on peut empiler des choses, les dépiler, et on ne peut accéder qu'au dernier élément empilé, qui se trouve au sommet de la pile.

Algorithme

Pile p ← vide; 
Lire un caractère c
Tant que c défini { 
	si (c = <<une parenthèse ouvrante>>)
		p ← empiler(p, c) 
	sinon si (c <<est une parenthèse fermante>>) { 
		si (estVide(p)) retourner "ERREUR: parenthèse fermante en trop" 
		sinon si (sommet(p) <<est du même type que>> c) 
			p ← depiler(p) 
		sinon retourner "ERREUR: parenthèses de types différents"
              sinon continuer
        Lire un caractère c
	} 
} 
si (estVide(p)) retourner "OK" 
sinon retourner "ERREUR: il manque au moins une parenthèse fermante"

Programme en Java

• avec un objet p de classe Pile (définie par ailleurs, voir plus bas)

public class TestPileParenthese2 {
    static String s = "(())<[{}]#";
    static String ouvrante ="([{<";
    static String fermante =")]}>";
    
    static public void main(String args[]) {
        char c; int i=0; boolean ok = true;

        Pile p = new Pile();

        while ((c = s.charAt(i++)) != '#') {
            if (ouvrante.indexOf(c)!= -1)
                p.empiler(c);       // On empile un caractère ouvrant
            else if (fermante.indexOf(c) != -1)
                    if (p.estVide()) {  // !parenthèse fermante en trop
                        erreur ("ERREUR! parenthèse fermante en trop " + c );
                        ok = false; break;
                    }
                    else if (compare (c, p.sommet() )) // même type, on dépile.
                        p.depiler();
                    else {   // !parenthèses de types différents
                        erreur ("ERREUR! parenthèses de types différents: " + c);
                        ok = false; break;
                    }
            // Autrement c'est un autre caractère...
        }
        
        if (ok)
            if (p.estVide())
                System.out.println ("OK, bien parenthesee");
            else erreur ("ERREUR! parenthèse ouvrante en trop:" + p.sommet());
        else;
    }
    
    // Routines locales
    static boolean compare (char a, char b){
        return fermante.indexOf(a) == ouvrante.indexOf(b);
    }
    static void erreur(String s) {
        System.out.println (s);
    }
}

• source complet
• Comparer par rapport à un programme où on aurait utilisé un tableau t avec des manipulations comme t[top], t[i-j] ... l'algorithme serait moins facile à écrire, mettre au point et maintenir...

Avantages...

• Ce n'est pas l'application qui exécute les manipulations qu'elle désire sur les données d'un objet, mais l'objet lui-même.

L'application fait	L'objet  fait
p	char t[]; int top = -1;
p.empiler (c)	top++; t [top] = c;
p.dépiler	top--;
p.sommet()	return t [top];

• Plus encore, la partie objet (à droite) est cachée à l'application.
• Cet aspect est important. Encapsulation, Information-hiding.

Avantages

• Au niveau du programme d'application on ne se préoccupe pas de certains détails (e.g. comment un objet agit sur ses données, colonne de droite).
• Mise au point plus facile, erreurs localisées
• Modifications confinées (sic), ne dépassant généralement pas la portée d'une méthode.
• Changements dans les méthodes sans grandes conséquences sur le reste de l'application
• etc.

Mais Encore ...

Mais où sont donc programmées les données et les opérations sur un objet?

Dans un endroit séparé... La classe.

La Classe ...

Elle déclare les données d'un objet de la classe et les opérations qui lui sont applicables.

Les données (attributs)	char[] t; int top;
Les opérations (méthodes)	public void empiler(char c) {     t[++top] = c; }
	public char sommet() {     return t[top]; }
	public void depiler() {     top-- ; }
	public boolean estVide() {     return (top < 0);; }
	...

Une classe Pile est donc l'ensemble des objets ayant ces caractéristiques.

Le source complet en Java 

NB. Dans certains langages, on dit aussi Module, Type, Package, cluster...

La Classe

• Une classe définit donc un ensemble d'objets par les opérations qui leur sont applicables.
• On utilise un objet à travers ces opérations.

La Classe Point

Autre exemple : une classe qui définit un point de l'espace.

/**
 * Classe Point du plan avec ses cordonnées x et y
 */

 public class Point {
    protected int x, y;  
     
     public Point(){ 
	 this (0);
     }     
 
    public void setX(int p) {
        x = p;
    }

    public void setY(int p) {
        y = p;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }
 };

Usage de la classe Point

• Point p;  on déclare un objet p de classe Point
• p.setX (1); affecte 1 à l'abscisse de p
• p.setY (2); affecte 2 à l'ordonnée de p
• r = p.getX (); r recoit 1
• m = Math.sqrt ( p.getX()*p.getX() + p.getY()*p.getY() );
• ...

On n'a pas besoin de connaître les données (réelles) x et y définies pour un objet Point.

Encore moins de les manipuler directement ! (i.e. faire r = p.x; directement sans passer par la méthode appropriée.)

Les Classes

• Un programme est ainsi un ensemble d'objets qui s'échangent des messages.
• Une classe se formalise avec la notion de Type Abstrait de Donnée (TAD)
  
  • Voir cours-1 Programmation par les Objets
• Beaucoup d'avantages :
• Programmation par abstraction : se concentrer sur l'essentiel et reporter les détails à plus tard.
• Développement modulaires avec des classes compilables (et testables) séparément.

Les Classes Encore

• Les Classes qui définissent objets sont très biens, sinon très utiles.
• On peut en faire des extensions très intéressantes.
  
  • On peut varier les implémentations (données d'un objet et algorithmes des méthodes) sans nécessairement changer les programmes qui utilisent une classe.
  • A partir d'une classe générale donnée, on peut dériver de nouvelles classes plus spécifiques à un besoin particulier.

Versions de "programmes"

• Les objets ainsi définis se présentent comme des entités autonomes.
  • On peut les utiliser ailleurs (e.g. classe Rectangle qui utilise la classe Point),
  • ... les faire varier en plusieurs versions (e.g. Point en coordonnées cartésiennes ou polaires) etc... 
• Une classe peut donc servir dans plusieurs programmes.
• Eventuellement après quelques extensions ou adaptations.

... EXTENSIONS HORIZONTALES

Réutilisation de "programmes"

• On peut parfois raffiner un objet vers des sous types : par ajouts/modifications de champs ou méthodes.. (Un Rectangle ou un Cercle sont des spécialisations (sous-classes) particulières d'une classe générale FigureGéométrique)
• Commencer par une classe générale et introduire des objets plus spécialisés selon le besoins sans avoir à refaire ce qui est déjà fait.
• Notion d'héritage...

...EXTENSION VERTICALE