OOP tutorial de programmation en processing
	Oeuvre du groupe "art orienté objet"

 

Programmation orienté objet (OOP)

La programmation orientée objet (OOP) est un concept qui est soutenu par la plupart des langages de programmations (actionScript, Pure Data,C++, Java bien sure...) Programmer par objet n'est pas forcement plus raide ni plus court, mais souvent plus lisible. C'est un autre façon de penser la programmation.

Le centre de OOP est, comme son nom indique, l'objet. Au lieu de travailler uniquement avec des variables et des méthodes, le OOP encapsule un nombre des propriétés et méthodes pour les traiter comme un objet. Ces objets peuvent être très complexe. Chaque objet est définit par une class qui définit ses propriétés et méthodes

Propriété et méthode

L'OOP a emprunté son langage de la réalité. Ainsi on peut dire que chaque objet a des propriétés (couleur, forme, matière,...) et ses comportements (ça bouge, ça aboie..)ce qui est à la class les propriétés et les méthodes.

Notre ballon est rouge, mesure ~20cm, est en plastique, peut voler, éclater...

les classes et les objets

Une classe est une structure abstrait auquel on peut associer des propriétés et méthodes. La classe ballon à toujours une propriété taille, comme tous les ballons ont une taille. Une objet est la concrétisation de cette class, comme notre ballon en haut et une concrétisation du typologie 'ballon'. On peut évidement imaginer d'autres ballon à partir de la class ballon ou bien du typologie ballon, en bleu, en cuire....

D'une manière structurelle, la classe Ballon a des propriétés suivantes:

• Taille
• couleur
• Matière

Et chaque ballon, chaque objet à des propriétés précises, notre ballon est:

• Taille: 20 cm
• couleur: rouge
• Matière: plastique

Syntaxe de OOP

D'abord on va aborder la programmation de notre ballon par la méthode

void setup() {
  drawShapeBallon();
}
void drawShapeBallon() {
  ellipse(50,50, 40,40);
}


Ballon monBallon;
monBallon =new Ballon(); 
void setup(){
monBallon.drawShape();
}

class Ballon{
void drawShape(){// la méthode propre à la classe de Ballon: 
ellipse(20,50,10,10); 
}
}

Dans cette exemple, nous avons définit une classe Ballon. Attention le nom de la class est écrit en majuscule par convention. Ensuite les méthodes de la class (dans notre exemple une seule: void drawShape( ) ) sont entouré d'accolades de la class. Ceci est notre structure abstraite.

class Ballon{
...
}

Ensuite nous voulons créer un ballon concret, pour cela nous créerons l' objet (le nom en minuscule) de type Ballon avec l'operateur "new"

Ballon monBallon=new Ballon();

Maintenant qu'on a une objet monBallon, on peut appeler la méthode de la classe Ballon avec la "Notation-point"(en anglais dot syntaxe)

monBallon.drawShape( );

Et enfin nous avons notre ballon dans la fenêtre. Résumons:

1. Définition de la class
2. Création d'un objet de la classe (Instanciation)
3. Utilisation de l'objet à travers ses méthodes et propriété...

Propriété de la classe

Les classe peuvent avoir aussi des propriétés. On les écrit directement dans la class au début. Ils sont comparable aux variables que j'écrit avant le setup(), ils ont un scoop globale, c'est à dire qu'ils sont valable partout dans la classe aussi dans ces méthodes, contrairement aux variables définis dans les méthodes.

class Ballon {
  int x;
  int y;
  int taille; 
  color c;

  void drawShape() {
    ellipse(20,50,10,10);
  }
}

Pour ensuite modifier les valeurs des propriétés on accède aussi par la "dot syntax"

Ballon monBallon = new Ballon();
monBallon.x=50;
monBallon.y=mouseY;
monBallon.c= color (255,0,0);
monBallon.taille=30;

Et on peut également utiliser les propriétés dans la class

class Ballon {
  int x;
  int y;
  int taille; 
  color c;
  void drawShape() {
    fill(c);
    ellipse(x,y,taille,taille);
  }
}

 

Propriétés prédéfinits et ses changements

Il est bien sure possible de prédéfinir les propriétés pour qu'ils sont par défaut pareil pour tous les objets.

class Ballon {
  int x 50;
  int y 50;
  int taille=30; 
  color c = color (255,0,0);
  void drawShape() {
    fill(c);
    ellipse(x,y,taille,taille);
  }
}
void setup() { 
  Ballon monBallon = new Ballon(); 
  monBallon.drawShape( );
  Ballon monGrandBallon = new Ballon();
  monGrandBallon.taille=80;
  monGrandBallon.x=20;
  monGrandBallon.drawShape( );
}

Je peux alors changer les propriétés par la 'dot syntax' mais également par les méthodes. Par exemple:

class Ballon{
... 
void bouge(){
x = x+2;
} 
}

Constructeur

Quand on crée un objet avec le mot clé new, on le construit. On effet, Processing (Java) fait appel à une méthode particulier qui s'appelle constructeur (constructor). Si on ne le définit pas, java le crée à notre place (mais elle reste invisible). Mais on peut définir nous même le constructeur. Il porte toujours exactement le même nom que la class.

class Ballon {
  int x ;
  int y ;
  int taille; 
  color c;

  Ballon() {// le constructeur 
    x=50;
    y=50;
    taille=30;
    c=color (255,0,0);
  }

  void drawShape() {
    fill(c);
    ellipse(x,y,taille,taille);
  }
} 

Cette méthode 'le constructeur' est un peu spéciale. Il est alors appelé au moment de la construction de l'objet (monBallon= new Ballon( ) ). Comme on a dit avant, si nous avons pas définit une constructeur, Java définit un constructeur à notre place.
C'est entre les accolades du constructeur qu'on définit des choses qu'il faut exécuter au début, comparable au void setup() dans notre programme principale. Le constructeur à l'option, comme les méthodes, de prendre des arguments, et ceci est très pratique, car ainsi on peut définir au moment de la construction de l'objet ses aspects initiales.

class Ballon {
  int x ;
  int y ;
  int taille; 
  color c;
  int vitesse;
  Ballon(int _x, int _y, color _c) {
    x=_x;
    y=_y;
    c=_c;
  }
  void drawShape() {
    fill(c);
    ellipse(x,y,taille,taille);
  }
  void bouge(int _vitesse) {
    vitesse=_vitesse;
    x = x+vitesse;
  }
}
}

Ainsi on peut ou moment de la construction de l'objet définir sa couleur est son point de départ, et ceci pour mes différents objets de la même classe ballon.
Les nom des variables dans les parenthèses sont quasi les mêmes que les propriétés de la classe mais pour les distinguer, j'ai rajouté le"_" devant. Ensuite je passe son valeur à la 'variable propriété' (x=_x), car les variables dans le constructeur sont des variable local. Si je veux que la variable _x affecte la propriété x (int x), il faut que je passe la valeur de _x à x, cad x=_x;

Ensuite je rentre pendant l'instanciation de mon objet
Ballon monBallonBleu=new Ballon ( random(width),height/2,bleu);
ses valeurs initiale entre ses parenthèses.

color bleu=color (0,0,255);
color rouge=color (255,0,0);
Ballon monBallonBleu;
Ballon monBallonRouge;
void setup() { 
  Ballon monBallonBleu=new Ballon ( random(width),height/2,bleu); 
  Ballon monBallonRouge=new Ballon ( random(width),height/3,rouge); 

  void draw() {
    monBallonBleu.drawShape();
    monBallonRouge.drawShape();
    monBallonBleu.bouge(2);
    monBallonRouge.bouge(3);
  }

Cela fait beaucoup de 'route' pour une variable, et au début on a l'impression que ça complique la vie (et c'est vrai) mais on verra plus tard qu'il est indispensable de maîtriser l'OOP.

Objets multiples avec array

Une fois on a définit notre class, on peut traiter les objets de la class quasi comme des variables, donc de les stocker dans des listes. Si je veux maintenant produire plusieurs ballons, je le fais avec un liste et un boucle.

Ballon mesBallons[]=new Ballon[10];// un liste de type Ballon avec 10 emplacement 
color couleurHasard[]=new color[10];// un liste de type couleur avec 10 emplacement

void setup() {
  for (int i=0; i<10; i++) {// initialisation mes couleurs et construis des objets 
    couleurHasard[i]=color(random(255),random(255),random(255));
    mesBallons[i]=new Ballon(int (random(width)),int(random(height)),couleurHasard[i]);
    mesBallons[i].vitesse=int(random(-2,2));
  }
}
void draw() {
  background(0);
  for (int i=0; i<10;i++) { // je donne un forme à mesBallons et je le mets en route! 
    mesBallons[i].drawShape(); 
    mesBallons[i].bouge(mesBallons[i].vitesse);
  }
}

-