Les méthodes.
Les méthodes sont ce qu'on appelle fonctions ou procédures dans d'autres langages.
Les méthodes permettent de rendre d'écrire du code qu'à un seul endroit.
Les différentes méthodes de la classe String.
Voici quelques méthodes de la classe String :
Opération | Méhode |
|---|---|
Calcul le nombre de caractère de la chaîne. | length() |
Recherche si le caractère placé à la position spécifié en paramètre. | charAt() |
Extrait une sous chaîne d'un mot. | substring() |
Transforme en minuscule la chaîne. | toLowerCase() |
Compare la valeur de deux mots. | equals() |
//
String chaine = new String("COUCOU TOUT LE MONDE !"), chaine2 = new String();
chaine2 = chaine.toLowerCase(); //Donne "coucou tout le monde !"
String chaine = new String("coucou coucou"), chaine2 = new String();
chaine2 = chaine.toUpperCase(); //Donne "COUCOU COUCOU"
String chaine = new String("coucou ! ");
int longueur = 0;
longueur = chaine.length(); //Renvoie 9
String str1 = new String("coucou"), str2 = new String("toutou");
if (!str1.equals(str2))
System.out.println("Les deux chaînes sont différentes !");
else
System.out.println("Les deux chaînes sont identiques !");
String nbre = new String("1234567");
char carac = nbre.charAt(4); //Renverra ici le caractère 5
String chaine = new String("la paix niche"), chaine2 = new String();
chaine2 = chaine.substring(3,13); //Permet d'extraire "paix niche"
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
Remarque : La classe Math.
Il existe d'autres classes, exemple la classe Math :
double X = 0.0;
X = Math.random();
//Retourne un nombre aléatoire
//compris entre 0 et 1, comme 0.0001385746329371058
double sin = Math.sin(120); //La fonction sinus
double cos = Math.cos(120); //La fonction cosinus
double tan = Math.tan(120); //La fonction tangente
double abs = Math.abs(-120.25); //La fonction valeur absolue (retourne le nombre sans le signe)
double d = 2;
double exp = Math.pow(d, 2); //La fonction exposant
//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
Notre propre méthode.
Nous avons déjà vu une méthode à nous :
public static double arrondi(double A, int B) {
return (double) ( (int) (A * Math.pow(10, B) + .5)) / Math.pow(10, B);
}
public : c'est la portée, nous verrons plus tard.
static : nous verrons plus tard.
double : c'est le type retourné par la méthode.
arrondi ; c'est le nom que nous avons donné à la méthode.
(double A, int B) : c'est les arguments passés à la méthode.
return : c'est l'instruction qui renvoie la valeur.
Remarque :
Le nombre de paramètres n'est pas limité.
Trois types de méthodes :
Les méthode qui ne renvoient rien.
Pas de return.
Type void.
Les méthodes qui renvoient des types primitifs.
int, double, char, etc ...
Une instruction return.
Les méthodes qui renvoient des objets.
Par exemple String.
Une instruction return.
Remarque :
Vos méthodes s'écrivent entre les accolades de votre classe.
Pas dans les accolades de la classe main.
Exemple :
Écrire une méthode qui va :
Prendre un tableau en paramètre.
Parcourir le tableau à notre place .
Effectuer tous les System.out.println() nécessaires .
Ne rien renvoyer.
public class MaMethode
{
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);
}
}
A peu près la même chose avec renvoi de valeur :
public class MaMethode
{
public static void main(String[] args)
{
String[] tab = {"toto", "tata", "titi", "tete"};
parcourirTableau(tab);
System.out.println(toString(tab));
}
static void parcourirTableau(String[] tabBis)
{
for(String str : tabBis)
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;
}
}
Surcharge.
La surcharge de méthode consiste à garder le nom d'une méthode (donc un type de traitement à faire) et à changer la liste ou le type de ses paramètres.
Exemple :
Parcourir divers tableau :
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);
}
// Tableau double dimension
static void parcourirTableau(String[][] tab)
{
for(String tab2[] : tab)
{
for(String str : tab2)
System.out.println(str);
}
}
// Tableau double dimension et deuxième paramètre
static void parcourirTableau(String[][] tab, int i)
{
for(String tab2[] : tab)
{
for(String str : tab2)
System.out.println(str);
}
}
String[] tabStr = {"toto", "titi", "tata"};
int[] tabInt = {1, 2, 3, 4};
String[][] tabStr2 = {{"1", "2", "3", "4"}, {"toto", "titi", "tata"}};
//La méthode avec un tableau de String sera invoquée
parcourirTableau(tabStr);
//La méthode avec un tableau d'int sera invoquée
parcourirTableau(tabInt);
//La méthode avec un tableau de String à deux dimensions sera invoquée
parcourirTableau(tabStr2);
Nouvelle syntaxe pour la boucle for.
for(String str : tab)
Ceci signifie qu'à chaque tour de boucle, la valeur courante du tableau est mise dans la variable str.
C'est particulièrement adapté aux parcours de tableaux.
