Les Objets en Programmation

Premier Objet JAVA

Source de Rectangle1.java

public class Rectangle1 { double x, y, largeur, hauteur; Rectangle1(double valX, double valY, double valL, double valH) { x = valX; y = valY; largeur = valL; hauteur = valH; } double perimetre() { return 2*(largeur + hauteur); } double surface() { return largeur * hauteur; } }

• Les lignes de la classe :
  • les attribut(s) sont x, y (position du coin haut-gauche du rectangle dans le plan), largeur et hauteur
  • un constructeur spécifiant les initialisations
  • déclaration de méthodes perimetre et surface
• La classe rectangle définit les caractéristiques de tous les objets rectangles :
  • des attributs : les valeurs caractéristiques de l'objet
  • des méthodes : les traitements possibles sur l'objet
  • des constructeurs : les initialisation/traitements à effectuer au moment de la création de l'objet

un programme utilisant les objets

Source de Prog30.java

public class Prog30 { public static void main (String arg[]) { Rectangle1 r1, r2; r1 = new Rectangle1(0,0,10,20); r2 = new Rectangle1(0,10,10,10); System.out.println("r1 : largeur = "+r1.largeur +" hauteur = "+r1.hauteur); double p = r1.perimetre(); System.out.println("perimetre de r1 : "+p +"\nsurface de r2 : "+r2.surface()); } }

• EXECUTION

  r1 : largeur = 10.0 hauteur = 20.0 perimetre de r1 : 60.0 surface de r2 : 100.0

• Les lignes du programme :
  • déclaration de 2 variables de type Rectangle1
  • instanciation (création) d'un objet Rectangle1 : appel du constructeur
  • r1 et r2 sont des références aux objets
  • envoie d'un message perimetre à l'objet référencé par r1, ce qui provoque l'exécution de la méthode
    

Nos amis les chiens comme objet

Source de Chien1.java

public class Chien1 { String nom; int nombrePuce; Chien1(String s, int i) { nom = s; nombrePuce = i; System.out.println("un nouvel ami ! " + nom); } int getNombrePuce() { return nombrePuce; } String getNom() { return nom; } void setNombrePuce(int p) { nombrePuce = p; } void seGratte(int fois) { nombrePuce = nombrePuce -2*fois; if (nombrePuce <0) nombrePuce = 0; } boolean aPlusPuceQue(Chien1 autre) { return this.nombrePuce>autre.nombrePuce; } }

• Les lignes de la classe :
  déclaration d'une classe Chien1 :
  • attributs nom et nombrePuce
  • 1 constructeur à 2 paramètres
  • 5 autres méthodes
    • getNombrePuce
    • getNom
    • setNombrePuce
    • seGratte
    • aPlusPuceQue
• this désigne l'objet en cours : içi, this pouvait être omis

Source de Prog40.java

public class Prog40 { public static void main (String args[]) { Chien1 milou, medor; milou = new Chien1("milou", 34); medor = new Chien1("medor", 17); System.out.println(milou.getNombrePuce() + " puces sur milou"); milou.setNombrePuce(19); System.out.println(milou.getNombrePuce() + " puces sur milou"); milou.seGratte(3); System.out.println(milou.getNombrePuce() + " puces sur milou"); System.out.println("milou a plus de " + "puces que medor = " + milou.aPlusPuceQue(medor)); } }

• EXECUTION

  un nouvel ami ! milou un nouvel ami ! medor 34 puces sur milou 19 puces sur milou 13 puces sur milou milou a plus de puces que medor = false

• Les lignes du programme :
• déclaration de 2 variables de type Chien1
• puis création de 2 objets/instances de la classe Chien1
• medor et milou sont des références sur chacun de ces 2 objets

déclaration de classe

• classe = modéle/type pour des objets, qui précise les attributs (états de l'objet) et méthodes (comportements)
• Syntaxe :
  [<modificateurs d'accès>] class <nomClasse>
{
  <attributs>
  <constructeurs>
   <méthodes>
}
• modificateurs d'accès = visibilité, .... (par exemple, public)
• les attributs sont les champs/caractéristiques
• les méthodes sont les messages/fonctions/actions applicables.
• les constructeurs sonr des méthodes spécialisées dans l'instanciataion d'un objet de la classe

objet

• Création d'un objet : new
  Syntaxe:
  [<nomClasse>] <variable>
           = new <nomClasse>(<paramètres>);
• l'opérateur new crée une instance d'une classe en faisant appel à une méthode constructeur s'il y a, et renvoie une référence sur l'objet instancié
• instanciation = créer un objet à partir d'une classe
• objet = instance de classe qui posséde une "copie" des attributs et méthodes de la classe
• accès aux variables et méthodes d'un objet :
  • <nomObjet>.<variable> pour accéder à un attribut sous réserve de visibilité et des modificateurs
  • <nomObjet>.<méthode>([<paramètres effectifs>]) pour envoyer un message à cet objet ou encore appeler/exécuter une méthode sur l'objet désigné.
• destruction d'un objet :
  • automatique dès que l'objet n'est plus référencé par aucune variable ou aucun autre objet.
  • la méthode finalise() est appelée avant la destruction de l'objet : elle peut être redéfinie.

attribut

• définit une caractéristique (propriété) de l'objet :
  par exemple couleur de la classe Chien
• Chaque objet posséde une instance de cette caractéristique
  En Java, cela s'appelle une variable d'instance.
• Syntaxe :
  [<modificateurs>] <type> <nomVariable> [= <valeur>];
  où modificateur peut être final, public, private,....
• Il existe une autre sorte d'attribut : les variables de classe :

méthode

• définit un comportement de l'objet, un traitement (comme une procédure ou une fonction) qui ne peut être déclanché qu'en envoyant un message à un objet de la classe
• s'appelle en Java : une méthode d'instance
• Syntaxe :
  [<modificateur>] <type> <nomMéthode> ([<paramètres formels>])
{ <corps de la méthode> }
• le type de la valeur renvoyé peut-être void, un type simple ou une référence d'objet. Sauf pour void, la valeur est renvoyé par une instruction return <valeur> ; dans le corps de la méthode
• Il existe aussi des méthodes de classe

constructeur

• une méthode constructeur est une méthode appelée au moment de la création d'une instance par l'opérateur new.
• Le nom du constructeur est celui de sa classe.
• Syntaxe :
  [<modificateur>] <nomClasse> ([<paramètres formels>]) { <corps de la méthode constructeur> }
  où les modificateurs peuvent être public, private, protected, ou sans.
• Un constructeur ne retourne pas de valeur
• Un constructeur ne peut pas être appelé sauf par l'opérateur new.
• Par défaut (s'il n'existe aucune définition de constructeur dans la classe), il existe un constructeur implicite, c'est à dire non défini : il initialise alors seulement les attributs.

exercices

• Reprendre le Prog40.java ci-dessus pour résoudre le problème suivant :
  • après avoir crée milou et medor,
  • créer le chien de nom "sacapuce" sans aucune puce initialement,
  • enlever les puces de milou et medor et les mettre sur sacapuce,
  • faire se gratter 6 fois sacapuce
  • afficher enfin la réponse à notre question : combien reste-il de puces sur sacapuce ?
  • Correction
• Créer une classe De qui modélise un dé à jouer :
  • voici une programme d'utilisation de la classe De Prog105.java
    

    Joueur A: de = 5 de = 2 de = 3 Joueur B: de = 1 de = 4 de = 6 JoueurB gagne

  • les objets De auront au moins :
    • 2 constructeurs : un
      • un constructeur sans paramètre qui construira un dé à 6 faces
      • un constructeur avec un paramètre qui précisera le nombre de faces
    • 2 méthodes :
      • getFace qui donne le numéro de face actuelle
      • lancer qui "lance" le dé aléatoirement et retourne le numéro de face obtenu
  • Correction
• Compléter la classe Complexe qui modèlise les nombres complexes :
  • les attributs re et im sont respectivement la partie réelle du nombre complexe et la partie imaginaire : en Maths, le nombre complexe s'écrit re + i im
  • Ecrire un constructeur permettant d'initialiser les deux attributs lors de l'instanciation.
  • Ecrire une méthode norme retournant la valeur de la norme du complexe.
    Rappel. Si a + îb est un complexe, sa norme est racine carrée de a au carré plus b au carré, par exemple : norme de 2 -1i = 2.23
  • Ecrire une méthode multiplieParScalaire qui permet de multiplier le complexe par un réel, par exemple : 3* (2 -1i) = 6-3i
  • Ecrire une méthode ajoute permettant d'ajouter au complexe un autre complexe.
    Rappel. Si a + ib et c + id sont deux complexes, leur somme vaut (a+c) + i(b+d), par exemple : (2 -1i) + (1.5+2.3i) = 3.5+1.3i
  • Ecrire un programme qui
    • saisit un complexe c1,
    • affiche ce complexe,
    • définit un complexe c2 de valeur i,
    • affiche la norme du complexe c1,
    • multiplie c1 par 5.2,
    • ajoute c2 à c1 et affiche c2,
    • définit un complexe c3 de valeur 3.5 - 2i,
    • Plus difficile et optionnel :
      • afficher la somme de c1 et c3 en ne les modifiant pas,
  • Correction
• Ecrire une classe MaDate1 qui modélise des objets dates comme la classe Calendar de JAVA, en beaucoup plus modeste !
  • les variables d'instances sont jour, mois, année
    • l'année varie de 0 à la fin du monde en 9999
  • un constructeur à 3 paramètres entier : jour, mois, année
  • plusieures méthodes :
    • getJour(), getMois() et getAnnée() qui retourne le numéro de jour, mois, année demandé.
    • toString() retourne la date sous la forme JJ/MM/AAAA
  • Correction
  • Ecrire un programme qui réalise l'exécution ci-dessous :
    • saisit un numéro de jour, de mois et d'année d'une date.
    • puis affiche la date ainsi que le résultat de getMois
    • Correction