Les méthodes de classe


Les méthodes de classe
Ce chapitre aura pour but de vous faire découvrir ce qu'on appelle, en Java, des méthodes de classe (fonctions en C/C++), de base et très utiles.

Java est un langage 100 % objet. Ceci signifie que tout ce qui fait partie du langage est objet !
Nous approfondirons cette notion lorsque nous ferons de la POO (Programmation Orienté Objet).
Pour le moment, retenez juste que, dans chaque objet, il y a des méthodes qui font des traitements spécifiques. Il s'agit tout bonnement d'une portion de code réutilisable !

C'est ce que nous allons aborder ici.

Mais ce chapitre ne serait pas drôle si nous ne nous amusions pas à en créer une ou deux pour le plaisir...
Et là, vous aurez beaucoup de choses à retenir...
Sommaire du chapitre :
  • Quelques méthodes bien utiles !
  • Créer et utiliser sa propre méthode !
  • La surcharge de méthode

Quelques méthodes bien utiles !

Voici le moment de vous présenter quelques méthodes dont, j'en suis convaincu, vous ne pourrez plus vous passer...

toLowerCase()

Cette méthode permet de transformer toute saisie clavier de type caractère en minuscules. Elle n'a aucun effet sur les nombres, puisqu'ils ne sont pas assujettis à cette contrainte. Vous pouvez donc utiliser cette fonction sur une chaîne de caractères comportant des nombres.
Elle s'utilise comme ceci :

Code : Java 
1
2
 
String chaine = new String("COUCOU TOUT LE MONDE !"), chaine2 = new String();
chaine2 = chaine.toLowerCase();//donne "coucou tout le monde !"


toUpperCase()

Celle-là est facile, puisqu'il s'agit de l'opposée de la précédente. Elle transforme donc une chaîne de caractères en majuscules. Et s'utilise comme suit :

Code : Java 
1
2
 
String chaine = new String("coucou coucou"), chaine2 = new String();
chaine2 = chaine.toUpperCase();//donne "COUCOU COUCOU"

concat()
Très explicite, celle-là permet de concaténer deux chaînes de caractères.
Code : Java 
1
2
 
String str1 = new String("Coucou "), str2 = new String("toi !"), str3 = new String();
str3 = str1.concat(str2);//donne "Coucou toi !"

length()

Celle-là permet de donner la longueur d'une chaîne de caractères (en comptant les espaces blancs).
Code : Java 
1
2
3
 
String chaine = new String("coucou ! "); 
int longueur = 0;
longueur = chaine.length();//donne 9

equals()

Permet de voir si deux chaînes de caractères sont identiques. Donc, de faire des tests. C'est avec cette fonction que vous ferez vos tests de conditions, lorsqu'il y aura des String. Exemple concret :
Code : Java 
1
2
3
4
5
6
7
 
String str1 = new String("coucou"), str2 = new String("toutou");
 
if (str1.equals(str2))//Si les deux chaînes sont identiques
        System.out.println("Les deux chaines sont identiques !");
 
else
        System.out.println("Les deux chaînes sont différentes !");

Vous pouvez aussi demander la non vérification de l'égalité... Grâce à l'opérateur de négation... vous vous en souvenez ? Il s'agit de '!'

Ce qui nous donne :

Code : Java 
1
2
3
4
5
6
7
 
String str1 = new String("coucou"), str2 = new String("toutou");
 
if (!str1.equals(str2))//Si les deux chaînes sont différentes
        System.out.println("Les deux chaines sont différentes !");
 
else
        System.out.println("Les deux chaînes sont identiques !");

Le principe de ce genre de condition fonctionne de la même façon pour les boucles. Et dans l'absolu, cette fonction retourne un booléen. C'est pourquoi nous pouvons utiliser cette fonction dans les tests de condition.

Code : Java 
1
2
 
String str1 = new String("coucou"), str2 = new String("toutou");
boolean Bok = str1.equals(str2);//ici Bok prendra la valeur false

charAt()

Le résultat de cette méthode sera un caractère, car il s'agit d'une méthode d'extraction de caractères, je dirais même d'UN caractère. Elle ne peut s'opérer que sur des String! Elle possède la même particularité que les tableaux, c'est-à-dire que, pour cette méthode, le premier caractère sera le numéro 0. Cette méthode prend un entier comme argument.

Code : Java 
1
2
3
 
String nbre = new String("1234567");
char carac = ' ';
carac = nbre.charAt(4);//renverra ici le caractère 5

substring()

Comme son nom l'indique, elle permet d'extraire une sous-chaîne de caractères d'une chaîne de caractères. Cette méthode prend 2 entiers comme arguments. Le premier définit le début de la sous-chaîne à extraire inclus, le deuxième correspond au dernier caractère à extraire exclus. Et le premier caractère est aussi le numéro 0.

Code : Java 
1
2
 
String chaine = new String("la paix niche"), chaine2 = new String();
chaine2 = chaine.substring(3,13);//permet d'extraire "paix niche"

indexOf()/lastIndexOf()

indexOf() permet d'explorer une chaîne de caractères depuis son début. lastIndexOf() depuis sa fin, mais renvoie l'index depuis le début de la chaine. Elle prend un caractère, ou une chaîne de caractères comme argument, et renvoie un int. Tout comme charAt() et substring(), le premier caractère est à la place 0. Je crois qu'ici un exemple s'impose, plus encore que pour les autres fonctions :
Code : Java 
1
2
3
4
5
6
7
8
 
String mot = new String("anticonstitutionnellement");
int n = 0;
 
n = mot.indexOf('t');      // n vaut 2
n = mot.lastIndexOf('t');        // n vaut 24
n = mot.indexOf("ti");    // n vaut 2
n = mot.lastIndexOf("ti");      // n vaut 12
n = mot.indexOf('x');      // n vaut -1

Des méthodes concernant les mathématiques

Ces méthodes utilisent la classe Math, présente dans java.lang. Cette classe fait donc partie des fondements du langage et, par conséquent, aucun import particulier n'est nécessaire pour utiliser la classe Math.

random()


Cette méthode permet de générer un nombre aléatoire, entre 0 et 1 (elle renvoie donc un double). Vous ne voyez pas l'utilité ? Eh bien... Vous vous en rendrez compte lors de notre prochain TP...

Code : Java  
1
2
 
double X = 0.0;
X = Math.random();//donne un nombre comme 0.0001385746329371058

Sinus, cosinus, tangente

Code : Java 
1
2
3
 
double sin = Math.sin(120);
double cos = Math.cos(120);
double tan = Math.tan(120);
Ces méthodes retournent un nombre de type double.

Valeur absolue

Code : Java 
1
 
double abs = Math.abs(-120.25);

Exposant

Code : Java 
1
2
3
4
5
 
double d = 2;
double exp = Math.pow(d, 2);
//Ici on initialise la variable exp avec la valeur de d élevée au carré
//La méthode pow() prend donc une valeur en premier paramètre 
//et un exposant en second

Je ne vais pas vous faire un récapitulatif de toutes les méthodes présentes dans Java, sinon, dans 1000 ans, je serais encore derrière mon clavier...
Toutes ces méthodes sont très utiles, croyez-moi. Mais les plus utiles sont encore celles que nous faisons ! C'est tellement mieux quand ça vient de nous...

Créer et utiliser sa propre méthode !

Reprenons la méthode que je vous avais donnée lors du premier TP. Pour mémoire :
Code : Java 
1
2
3
 
public static double arrondi(double A, int B) {
     return (double) ( (int) (A * Math.pow(10, B) + .5)) / Math.pow(10, B);
}

Décortiquons un peu ceci

  • Tout d' abord, il y a le mot clé public. C'est ce qui définit la portée de la méthode. Nous y reviendrons lorsque nous programmerons des objets.
  • Ensuite il y a static. Nous y reviendrons aussi.
  • Juste après, nous voyons double. Il s'agit du type de retour de la méthode. Pour faire simple, ici, notre méthode va renvoyer un double !
  • Il y a ensuite le nom de la méthode. C'est avec ce nom que nous l'appellerons.
  • Puis, il y a les arguments que la méthode prend. C'est en fait les paramètres dont la méthode a besoin pour travailler. Ici, nous demandons d'arrondir le double A avec B chiffres derrière la virgule !
  • Et vous pouvez voir, à l'intérieur de la méthode, une instruction return. C'est cette instruction qui effectue le renvoi de la valeur, ici, un double.
Dans ce chapitre, nous allons voir les différents types de renvois ainsi que les paramètres qu'une méthode peut prendre.

Vous devez savoir deux choses concernant les méthodes :
  • elles ne sont pas limitées en nombre de paramètres
  • il y a trois grands types de méthodes :
    • les méthodes qui ne renvoient rien. Elles sont de type void. Ces types de méthodes n'ont pas d'instruction return !
    • les méthodes qui retournent des types primitifs (double, int...). Elles sont de type double, int, char... Celles-ci ont une instruction return.
    • des méthodes qui retournent des objets. Par exemple, une méthode qui retourne un objet de type String. Celles-ci aussi ont une instruction return.
Pour le moment, nous ne faisions que des programmes comportant une classe. Celle-ci ne comportant qu'une méthode : la méthode main.
Le moment est donc venu de créer vos propres méthodes. Que vous ayez utilisé la méthode arrondi dans votre TP ou non, vous avez du voir que celle-ci se place à l'extérieur de la méthode main, mais dans votre classe !

Pour rappel, voici le screen qu'il y avait dans le TP 1 :


Si vous placez une de vos méthodes à l'intérieur de la méthode main ou à l'extérieur de votre classe : LE PROGRAMME NE COMPILERA PAS ! !
Bon, d'accord ! C'est enregistré. Mais concrètement... À quoi vont nous servir ces méthodes ?

Dites-vous bien qu'un développeur est de nature assez feignante... Sans déconner. Il s'est vite aperçu qu'il y avait du code redondant dans ses programmes... Des morceaux de code qui faisaient toujours la même chose et qui n'avaient, comme seule différence, la (ou les) variable(s) qu'ils traitaient.

Vu que nous venons de voir les tableaux, nous allons donc faire des méthodes concernant ces derniers !
Vous devez certainement vous rappeler de la façon de parcourir un tableau...
Et si nous faisions une méthode qui permette d'afficher le contenu d'un tableau sans que nous soyons obligés de retaper la portion de code contenant la boucle ? Je me doute que vous n'en voyez pas l'intérêt maintenant car, mis à part les plus courageux d'entre vous, vous n'avez fait qu'un ou deux tableaux de votre main lors de la partie précédente. Et si je vous demande de déclarer 22 tableaux, si je vous dis : "Allez, bande de ZérOs ! Parcourez-moi tout ça !"

Vous n'allez tout de même pas faire 22 boucles for ! De toute façon, je vous l'interdis ! Nous allons faire une méthode. Celle-ci va :
  • prendre notre tableau en paramètre (ben oui... c'est lui que nous voulons parcourir),
  • parcourir notre tableau à notre place,
  • faire tous les System.out.println(),
  • ne rien renvoyer.
Avec ce que nous avons défini, nous savons donc que notre méthode sera de type void, qu'elle prendra un tableau en paramètre (pour le moment, on travaillera avec des tableaux de String) et le contenu vous vous doutez de ce que ça va être... Une boucle. Cette fameuse boucle que nous ne serons plus obligés de répéter autant de fois que de tableaux de String !

Ce qui va nous donner :

Code : Java 
1
2
3
4
5
 
static void parcourirTableau(String[] tab)
    {
      for(String str : tab)
        System.out.println(str);
    }

Et voici un exemple de code entier :
Code : Java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
 
public class Sdz1
{
   public static void main(String[] args)
   {
      String[] tab = {"toto", "tata", "titi", "tete"};
      parcourirTableau(tab);
 
   }
 
   static void parcourirTableau(String[] tabBis)
    {
      for(String str : tabBis)
        System.out.println(str);
    }
}
Je sais que ça vous trouble encore, mais sachez que les méthodes ajoutées dans la classe main doivent être déclarées static ! Fin du mystère lors de la programmation orientée objet !

Bon. Vous voyez que la méthode parcourt le tableau passé en paramètre. Si vous créez plusieurs tableaux et appelez la méthode avec ces derniers, vous vous apercevrez que la méthode affiche le contenu de chaque tableau !

Voici une méthode au même effet que la méthode parcourirTableau, à la différence que celle-ci retourne une valeur. Ici, une chaîne de caractères !

Code : Java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
 
static String toString(String[] tab)
{
  System.out.println("Méthode toString() ! ! !\n---------------------------");
   String retour = "";
   
   for(String str : tab)
       retour += str + "\n"; 
   
   return retour;
}
Et voici un code complet :
Code : Java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
public class Sdz1 {
 
        public static void main(String[] args)
           {
              String[] tab = {"toto", "tata", "titi", "tete"};
              parcourirTableau(tab);
              System.out.println(toString(tab));   
           }
 
           static void parcourirTableau(String[] tab)
            {
              for(String str : tab)
                System.out.println(str);
            }
           
           static String toString(String[] tab)
           {
                  System.out.println("Méthode toString() ! ! !\n---------------------------");
                   String retour = "";
                   
                   for(String str : tab)
                       retour += str + "\n"; 
                   
                   return retour;
           }
           
          
}

Vous voyez que la deuxième méthode retourne une chaîne de caractères que nous devons afficher à l'aide de l'instruction System.out.println(). Nous affichons la valeur renvoyée par la méthode toString(). Alors que la méthode parcourirTableau, elle, écrit au fur et à mesure le contenu du tableau dans la console !
Notez que j'ai ajouté une ligne d'écriture dans la console dans la méthode toString() afin de vous montrer où était appelée cette dernière.
L'instruction System.out.println() est très pratique pour déboguer vos programmes ! Dans une méthode, l'utilisation de cette instruction peut faire ressortir des erreurs de conception ou de développement !

Il nous reste un point important à aborder.
Imaginez un instant que vous ayez plusieurs types d'éléments à parcourir ! Des tableaux à une dimension, mais aussi d'autres à deux dimensions, et même des objets comme des ArrayList (nous les verrons, ne vous inquiétez pas...). Sans aller si loin. Vous n'allez pas donner un nom différent à la méthode parcourirTableau à chaque type primitif !

Vous avez dû remarquer que la méthode que nous avons créée ne prend qu'un tableau de String en paramètre ! Pas de tableau d'int ni de long.

Si seulement nous pouvions utiliser la même méthode pour différents types de tableaux !

C'est là qu'entre en jeu ce qu'on appelle : la surcharge.

La surcharge de méthode

Grâce à ceci, vous n'aurez plus à retenir 10 000 noms de méthodes qui font la même chose !

Le principe


La surcharge de méthode consiste à garder un nom de méthode (donc un type de traitement à faire, pour nous, lister un tableau) et de changer la liste ou le type de ses paramètres.

Dans le cas qui nous intéresse, nous voulons que notre méthode parcourirTableau puisse parcourir n'importe quel type de tableau.
Comment faire ?
Nous allons surcharger notre méthode afin qu'elle puisse travailler avec des int par exemple :
Code : Java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
 
static void parcourirTableau(String[] tab)
  {
     for(String str : tab)
        System.out.println(str);
  }
        
static void parcourirTableau(int[] tab)
  {
     for(int str : tab)
        System.out.println(str);
  }

Avec ces méthodes, vous pourrez parcourir de la même manière :
  • les tableaux d'entiers
  • les tableaux de chaînes de caractères.

Mais vous pouvez aussi faire de même avec les tableaux à 2 dimensions.
Voici à quoi pourrait ressembler son code (je ne rappelle pas le code des deux méthodes ci-dessus) :
Code : Java 
1
2
3
4
5
6
7
8
 
static void parcourirTableau(String[][] tab)
  {
     for(String tab2[] : tab)
     {
        for(String str : tab2)
          System.out.println(str);
     }
  }

La surcharge de méthode fonctionne aussi en ajoutant des paramètres à la méthode.
Cette méthode est donc valide :
Code : Java 
1
2
3
4
5
6
7
8
 
static void parcourirTableau(String[][] tab, int i)
  {
     for(String tab2[] : tab)
     {
        for(String str : tab2)
          System.out.println(str);
     }
  }

Bon d'accord, nous ne nous servons pas de la variable i, mais c'était un exemple. Comme ça, vous avez vu les cas de surcharge de méthode !

Ce qu'il faut retenir de ce chapitre

  • Les méthodes se définissent dans une classe.
  • Les méthodes ne peuvent pas être imbriquées. Elles sont déclarées les unes après les autres.
  • Les méthodes peuvent être surchargées, en changeant le type de paramètres que celle-ci attend, le nombre de ses paramètres ou les deux !
  • Pour Java, le fait de surcharger une méthode lui indique qu'il s'agit de 2, 3 ou X méthodes différentes, car les paramètres d'appel sont différents. Par conséquent, Java ne se trompe jamais d'appel de méthode, puisqu'il se base sur les paramètres passés.
J'espère que vous aurez appris beaucoup de choses dans ce chapitre. En tout cas, je sais que vous en aurez besoin, et pas plus tard que pour la partie suivante !

Prêts pour la programmation orientée objet ? Here we go !



// // 0 comments //

0 comments to "Les méthodes de classe"

Post a Comment

About This Blog

Aller au debut de la page