TP 10:Introduction aux classes et objets

Notion de classe et d'objet

Jusqu'à présent nous avons vu l'idée importante de fonction qui nous permet de découper un programme en unités ou modules, nous permettant une mise au point plus facile de notre programme

La notion de classe et d'objet nous permet d'avoir une vision d'ensemble qui structure notre programme, que l'on soit programmeur concepteur ou utilisateur

Nous pouvons voir un programme comme le script d'un film mettant en jeu plusieurs personnages ou objets

Par exemple imaginons que l'on veuille créer un programme où évoluent à l'écran, plusieurs vaisseaux spatiaux et des astéroïdes

Les vaisseaux spatiaux sont différents en tant qu'objets mais partagent les même caractéristiques et donc proviennent d'une même classe, de même pour les astéroïdes

Il semble judicieux de caractériser un vaisseau par sa position à l'écran en x et en y, ses vitesses, vx et vy, sa direction d, sa quantité de vie, ses munitions

Ce sera donc les variables de la classe Vaisseau

Mais cela ne suffit pas pour faire "vivre" le personnage Vaisseau dans l'histoire, il lui faut des fonctions ou méthodes pour le faire afficher à l'écran, le faire tourner, le faire accélérer dans sa direction, lui faire tirer des missiles, le faire exploser s'il est touché par un astéroide, etc...

Chaque nuance dans l'évolution du personnage Vaisseau correspond donc à une méthode donnée

Une classe apparaît comme un moule ou un prototype à partir duquel on va créer plusieurs objets avec l'instruction new

Par conséquent pour la mise au point de notre programme nous avons donc une méthode supplémentaire:

1. Quels sont les objets qui évoluent dans le programme-histoire ?
2. Quelles sont les variables d'un objet ?
3. Quelles sont les méthodes d'un objet?

Exemple

• Balle rebondissante

  On reprend le TP de la balle rebondissante (voir mini-projet du TP ....)

  On crée une classe Balle avec les variables x,y,vx et vy et diametre

  Les fonctions sont les mêmes mais elles sont des méthodes de la classe

  
  class Balle{
    //Variables
    int x;
    int y;
    int diametre = 40;
    int vx;
    int vy;
    
    //Constructeur
    Balle(int a,int b,int va,int vb){
      x = a;
      y = b;
      vx = va;
      vy = vb;
    }
    //constructeur par défaut
    Balle(){
      x = width/2;
      y = height/2;
      vx = 0;
      vy = 0;
    }
    //-----------Methodes-----------------------------------------
    void dessineBalle(){
      ellipse(x,y,diametre,diametre);
    }
    //-------------------------------------------------------------
    //-------------------------------------------------------------
  //Initialise les coordonnées du vecteur vitesse de la balle de manière aléatoire
  //les valeurs doivent être de l'ordre de l'unité pour que la balle n'aille pas trop vite
  //vx doit être différent de 0, on ne veut pas que la balle se déplace verticalement
  
  void initialisationVitesse(){
    if(int(random(2)) == 0){
          vx = int(random(1,5));
    }
    else{
          vx = -int(random(1,5));
    }
    vy = int(random(-5,5));
  }
  //-------------------------------------------------------------
  //place le centre de la balle au centre de la fenêtre
  //initialise le vecteur vitesse
  
  void generationBalle(){
    x = width/2;
    y = height/2;
    initialisationVitesse();
  }
  //-------------------------------------------------------------
  //met à jour les coordonnées de la balle 
  //cette fonction sera appelée 60 fois par seconde dans draw()
  
  void miseAJourPosition(){
      x += vx;
      y += vy;
  }
  //------------------------------------------------------------- 
  //cette fonction retourne vrai si le bord de la balle touche un des bords de 
  //la fenêtre
  
  boolean toucheBord(){
      if((x < diametre/2) || (x > width - diametre/2)  || (y < diametre/2)
      || (y > height - diametre/2)){
               return true;
      }
       else{
               return false;
       }   
  }
  //-------------------------------------------------------------  
  void reflexion(){
    
    //si la balle touche un des bords verticaux de la fenêtre
    //la composante en x du vecteur vitesse de la balle est changé en son opposé
    
     if((x < diametre/2) || (x > width - diametre/2)){ 
           vx = -vx;
     }
     
     //si la balle touche un des bords horizontaux de la fenêtre
    //la composante en y du vecteur vitesse de la balle est changé en son opposé
    
     else if((y < diametre/2) || (y > height - diametre/2)){
           vy = -vy;
     }     
      
  }
  }
  //---------------------Fin de la classe Balle--------------------
  //---------------------Variables globales------------------------
  
  Balle balle1 = new Balle();
  Balle balle2 = new Balle();
  //------------------------setup()-------------------------------
  void setup(){
    
  //on crée une fenêtre de fond noir  
    size(600,400);
    background(0);
  
  
  //on génére la balle (position et vitesse) 
    balle1.generationBalle();
    balle2.generationBalle();
  
  balle1.dessineBalle();
  balle2.dessineBalle(); 
  }
  //-------------------------------------------------------------  
  void draw(){
    
    //60 fois par seconde
  
    //on repeint le fond de la fenêtre en noir
    background(0);
    
    //si la balle a touché le bord il faut changer le vecteur vitesse
    //avant de mettre à jour les coordonnées du centre de la balle
    if(balle1.toucheBord()){
          balle1.reflexion();
    }
    if(balle2.toucheBord()){
          balle2.reflexion();
    }
    
    //on met à jour les coordonnées du centre de la balle
   balle1.miseAJourPosition();
   balle2.miseAJourPosition(); 
    //on dessine la balle
   balle1.dessineBalle();
   balle2.dessineBalle(); 
    //on recommence en boucle...
  }
  
  

Problème: Comment faire pour gérer 10 balles par exemple ?

Un exemple d'utilisation d'une classe: la classe PImage

La semaine prochaine nous allons nous intéresser aux images numériques. Les langages de programmation fournissent en général une classe déjà toute faite avec des méthodes qui répondent aux principaux besoins du programmateur utilisateur

Là encore l'idée de classe nous aide dans l'utilisation de l'outil

Voir ici la documentation sur la classe PImage

Exercice

• Créer un fichier .pde appelé espace.pde
• Télécharger deux images ici et les mettre dans le répertoire espace:

  fonds_espace

  vaisseau spatial

• Faire un programme qui affiche l'image du fonds_espace dans toute la fenêtre 600x600 puis affiche le vaisseau spatial au centre de la fenêtre dans un carré de 80x80

Programmation collective

Nous allons créer une classe Complexe dont les variables sont :

1. re la partie réelle du nombre complexe
2. im la partie imaginaire du nombre complexe

les méthodes sont :

1. void affiche() affiche à l'écran le nombre complexe sous forme algébrique
2. Complexe somme(Complexe z) retourne la somme du nombre complexe avec un autre nombre complexe z
3. Complexe produit(Complexe z) retourne le produit du nombre complexe avec un autre nombre complexe z
4. float module() retourne le module du nombre complexe
5. float argument() retourne un argument du nombre complexe

Mini-projet personnel (avant J+7)

Créer une méthode void image() qui dessine dans une fenêtre graphique de 600 par 600 une image du nombre complexe

La fenêtre graphique sera xmin = -5, xmax = 5, ymin = -5 et ymax = 5

Il y a aura une conversion à faire entre les pixels et les nombres on utilisera pour cela la fonction map() de Processing

On testera la méthode sur les cinq nombres complexes suivants qui seront rangés dans un tableau:

$z_1= 4+i$,$z_2=-2+3i$,$z_3=4-i$,$z_4=3+2i$ et $z_5=-4-i$

On mettra les étiquettes A1, A2, A3 , A4 et A5 sur les points et on reliera l'origine aux points