Surcharge, signature
et variable de classe

variable de classe et plusieurs constructeurs

Source de Rectangle2.java

public class Rectangle2 { double x, y, largeur, hauteur; static final double DIMDEFAUT = 100; Rectangle2() { x = 0; y = 0; largeur = DIMDEFAUT; hauteur = DIMDEFAUT; } Rectangle2(double valX, double valY, double valL, double valH) { x = valX; y = valY; largeur = valL; hauteur = valH; } Rectangle2(double valX, double valY) { x = valX; y = valY; largeur = DIMDEFAUT; hauteur = DIMDEFAUT; } double surface() { return largeur * hauteur; } void doubler() { largeur = 2 * largeur; hauteur = 2 * hauteur; } }

• les lignes de la classe :
  • x, y ... sont des variables d'instance (attribut propre à chaque objet de la classe)
  • dimDefaut variable de classe donc valeur commune à toute la classe à cause du modificateur static ,
  • final signifie valeur constante
    • par convention, les variables final sont en majuscules.
  • le constructeur est surchargé car il possède 3 déclarations du constructeur de la classe avec des paramètres différents.

Source de Prog32.java

public class Prog32 { public static void main (String args[]) { Rectangle2 r1, r2; r1 = new Rectangle2(40,40,50,100); r2 = new Rectangle2(50,50); System.out.println("surface de r1 : " +r1.surface()+"\nsurface de r2 : " +r2.surface()); r1.doubler(); System.out.println("surface de r1 " +"apres doubler: "+r1.surface()); } }

• EXECUTION

  surface de r1 : 1500.0 surface de r2 : 10000.0 surface de r1 apres doubler: 6000.0

• les lignes du programme :
  • il n'y a pas d'ambiguité sur le constructeur appelé.

méthode de classe et surcharge de méthode

Source de Rectangle3.java

public class Rectangle3 { double x, y, largeur, hauteur; static double dimDefaut = 100; static void setDimDefaut(double valDim){ dimDefaut = valDim; } Rectangle3() { x = 0; y = 0; largeur = dimDefaut; hauteur = dimDefaut; } Rectangle3(double valX, double valY) { x = valX; y = valY; largeur = dimDefaut; hauteur = dimDefaut; } double surface() { return largeur * hauteur; } void doubler() { largeur = 2 * largeur; hauteur = 2 * hauteur; } void doubler(boolean doublerLargeur, boolean doublerHauteur) { if (doublerLargeur) largeur = 2 * largeur; if (doublerHauteur) hauteur = 2 * hauteur; } }

• les lignes de la classe :
  • setDimDefaut est une méthode de classe (à cause du "modifieur" static) qui s'applique à la classe toute entière (donc aux variables de classe)
  • doubler est une méthode surchargée : il y a 2 définitions de la méthode, de même nom, mais de signature différente au niveau des paramètres
  • la signature d'une méthode est constituée du nom de la méthode, du nombre et du type de ses paramètres, et du type qu'elle renvoie.

Source de Prog33.java

public class Prog33 { public static void main (String args[]) { Rectangle3 r1, r2; Rectangle3.setDimDefaut(20); r1 = new Rectangle3(40,40); Rectangle3.setDimDefaut(10); r2 = new Rectangle3(50,50); System.out.println("surface de r1 : " +r1.surface()+"\nsurface de r2 : " +r2.surface()); r1.doubler(); System.out.println("surface de r1 "+ "apres doubler: "+r1.surface()); r2.doubler(true,false); System.out.println("surface de r2 apres" +" doubler(true,false): "+r2.surface()); } }

• EXECUTION

  surface de r1 : 400.0 surface de r2 : 100.0 surface de r1 apres doubler: 1600.0 surface de r2 apres doubler(true,false): 200.0

• les lignes du programme :
  • appel de la méthode de classe "sur" la classe, et non sur un objet.
  • grâce à la signature, la définition adéquate de "doubler" parmi les 2 existantes est appelée.

variable de classe et méthode de classe

• Les variables de classes et les méthodes de classes sont déclarées avec le modificateur static. On les appelle aussi variable static et méthode static.
• les variables static existent sans instance (objet).
• les méthodes static peuvent être appelées sans objet sur la classe elle-même.
• (Conséquense) elles ne peuvent qu'accéder à des variables static.
• final est un modificateur indiquant une constante non modifiable.
• Exemples :
  • Math.PI est une variable de classe
  • Math.sqrt(...) est une méthode de classe

surcharge et signature

• La surcharge de méthode et de constructeur permet pour un même identificateur de faire correspondre plusieurs définitions.
  Pour identifier la bonne définition, il faut comparer sa signature.
• La signature de méthode et de constructeur est composée :
  • du nom de la méthode,
  • de sa visibilité (modificateurs, ...)
  • du nombre et du type de ses paramètres,
  • du type qu'elle renvoie.
• La surcharge est une forme de polymorphisme.
• Exemples :
  • Vector() est un constructeur de vector (par défaut ou encore sans parametre)
  • Vector(int) est un constructeur de vector d'une taille initiale prédéfinie
    

constructeur par défaut

Source de Chien3.java

public class Chien3 { static String aboiementClassic="wouah!"; String nom, aboiement; int nombrePuce; Chien3() { nom = "indéfini"; nombrePuce = 0; aboiement = aboiementClassic; } Chien3(String s) { this(); nom = s; } Chien3(String s1, int i, String s2) { nom = s1; nombrePuce = i; aboiement = s2; } static void nouvelleRace(String s) { aboiementClassic=s; } void aboie() { System.out.println(aboiement); } void aboie(int fois) { for (int i=1; i<fois; i++) System.out.print(aboiement); System.out.println(aboiement); } }

• Un constructeur sans paramètre est le constructeur par défaut explicite
• Si aucun constructeur par défaut n'est défini, alors le constructeur vide (implicite) est celui par défaut : il ne fait qu'initialiser les variables d'instances (attributs)
  • voici un exemple de programme Prog103.java avec une classe avec constructeur par défaut implicite

    class Phrase { String phrase=""; } public class Prog103 { public static void main (String args[]) { Phrase p; p = new Phrase(); System.out.println("phrase : "+ p.phrase); p.phrase = "Du haut de ces pyramides, 40 siècles vous comtemplent"; System.out.println("phrase : "+ p.phrase); } }

    
    EXECUTION :
phrase :
phrase : Du haut de ces pyramides, 40 siècles vous comtemplent

• un constructeur peut faire appel au constructeur par défaut en le nommant this MAIS en le placant comme première instruction
• Mettez, si possible, un constructeur sans paramêtre pour éviter des PBs lors de l'héritage

exercices

• Ecrire une variante de la classe De : De2, où vous surchargerez la méthode lancer par une signature avec un paramètre nombreFois :
  • elle "lancera" nombreFois le dé, retournera la somme des faces obtenues et la face "visible" sera celle du dernier lancé.
  • Correction
• Ecrire une classe MaDate2 qui modélise des objets dates comme la classe MaDate1 :
  • 2 constructeurs :
    • celui par défaut initialise à la date minimale 01/01/1970, le 0 milliseconde du monde Unix !
    • un constructeur à 3 paramètres entier : jour, mois, année
  • au moins 1 variable de classe :
    • le tableau des noms de mois
  • 2 méthodes de classe :
    • isBissectile(annee) dont voiçi le code :
      

      if (an % 4 == 0) if (an % 100 == 0) if (an % 400 == 0) return true; else return false; else return true; else return false;

    • estValide(jour, mois, annee) retourne un booléen indiquant si une telle date est valide
  • plusieurs nouvelles méthodes :
    • toString(String séparateur) retourne la date sous la forme JJséparateurMMséparateurAAAA
    • enFrancais() la retourne avec le mois en toutes lettres
    • demain() la transforme en demain si possible.
  • Correction
  • Ecrire un programme de test

    $java Prog122 constructeur sans parametre md1 = 01/01/1970 md2 = MaDate2(13,4,2006) : 13/04/2006 ou 13 avril 2006 MaDate2.estValide(13,4,2006) =true MaDate2.estValide(29,2,2005) =false md2.demain() =14/04/2006 2006 isBissectile : false 2004 isBissectile : true

    Correction