A › 14 - Classes

De l'unicité ...

On crée une "particule" représentée par un disque, dont la position est soumise à des variations aléatoires.

float x = 100;

float y = 100;

void setup() {

  size(200,200);

  frameRate(15);

  noStroke();

}

void draw() {

  background(200);

  fill(200, 100, 100);

  ellipse(x,y,20,20);

  x = x+random(-5,+5);

  y = y+random(-5,+5);

}

... à la multiplicité

Comment procéder si l'on souhaite créer deux, dix, cent "particules" de ce type, chacune ayant son propore mouvement ?

Recopier autant de fois toutes les lignes qui permettent de définir, d'afficher et de modifier la position de chaque particule devient vite peu raisonnable. Le code devient inutilement long, difficile à lire et encore plus à modifier.

L'idée consiste à définir une "classe" (un type d'objets) en précisant tous les éléments qui la caractérisent (ses attributs) ainsi que les fonctions qui sont en lien avec les objets de cette classe.

Dans l'exemple des particules, on définit une classe nommée "particule" :

class Particule { // l'usage veut que les classes aient des noms débutant par une majuscule

  float x,y ; // les attributs de chaque "particule" sont ici ses coordonnées

  Particule () { // le "constructeur" est une fonction qui "créera" une particule, en initialisant x et y, à chaque fois qu'un objet de classe Particule sera instancié.

    x = 100 ; // toutes les particules créées auront une abscisse initiale de 100

    y = 100 ;

  }

  void dessine () { // fonction qui permet de tracer une particule

    fill(200, 100, 100) // toutes les particules créées auront la même couleur

    ellipse(x,y,20,20) // toutes les particules créées auront le même diamètre

  }

  void bouge () { // fonction qui permet de modifier la position de la particule

    x = x +random (-5 , 5);

    y = y +random (-5 , 5);

  }

} // fin de la classe


Cette partie de code a permis de définir une "classe" particule. Pour créer concrètement une particule, on utilise la même instruction que pour les tableaux :

Particule particuleUn = new Particule () ; // la particule créée s'appelle particuleUn

Ensuite on peut appliquer à particuleUn les fonctions bouge et dessine avec la syntaxe : particuleUn.dessine() et particuleUn.bouge()

On peut alors créer autant de particules que l'on souhaite... Commençons par 2 :

Le code complet contient la déclaration de deux particules nommées particuleUn et particuleDeux. Le setup() est identique à l'animation qui ne concernait qu'une seule particule.

Le draw () est devenu :

void draw() {

  background(200);

  particuleUn.dessine();

  particuleUn.bouge();

  particuleDeux.dessine();

  particuleDeux.bouge();

}

L'intégralité du code définissant la classe Particule est placé en fin de programme.

Pour lire le code complet, cliquer sur "source code" dans l'animation.

Cette façon de déclarer une à une chaque particule admet aussi ses limites : on renonce vite à l'idée de déclarer cent particules, de les afficher et de les animer...

On va procéder comme lorsqu'on a souhaité manipuler un grand nombre de variables de même type : on crée un tableau !

On déclare un tableau de 100 particules par l'instruction : Particule[] tabParticule = new Particule[100];

Il restera à utiliser une boucle pour "créer" (instancier) chaque particule :

for (int i=0;i< tabParticule.length;i++) {

  tabParticule[i] = new Particule();

}

Et c'est encore avec une boucle que chaque particule sera dessinée et animée dans le draw():

for (int i=0;i< tabParticule.length;i++) {

  tabParticule[i].dessine();

  tabParticule[i].bouge();

}


Pour lire le code complet, cliquer sur "source code" dans l'animation.

Pour aller plus loin

Voici quelques variations sur le même thème...

Le constructeur d'une classe peut également accepter des paramètres, ce qui permet de spécifier des propriétes pour chaque particule.

Observer les différentes animations et lire leur code ...