Segment 7 : Java sans objet : conversions et méthodes

(3/5)

11 Concepts de base....................................................................................................................46
11.1 Expressions ........................................................................................................................46
11.1.1 Expressions sur les chaînes de caractères ..................................................................46
11.1.2 Conversions ...............................................................................................................47
12 Concepts avancés ...................................................................................................................49
12.1 Méthode .............................................................................................................................49
12.1.1 Définition...................................................................................................................49
12.1.2 Méthode récursive .....................................................................................................50
12.1.3 Variable locale ...........................................................................................................50
12.1.4 Passage des arguments...............................................................................................51
12.1.5 Surcharge des méthodes ............................................................................................51
12.1.6 Bibliothèque mathématique .......................................................................................51

Marc Tizzano (EMN) 45

11 Concepts de base

11.1 Expressions

11.1.1 Expressions sur les chaînes de caractères

L’opérateur le plus utilisé sur les chaînes de caractère est la concaténation dont le symbole
est identique à celui de l'addition.

Nom Effet Type opérandes

+ Concaténation Juxtaposition de 2 chaînes. Si une String x String : String
des opérandes n’est pas de type String x type : String
String, elle est transformée en type x String : String
String

Exemple Résultat
+ " Bon "+ " jour" " Bonjour"
" Jeudi " + 12 " Jeudi 12"

Pour comparer deux chaînes de caractères on utilise, l'instruction suivante (s1et s2 sont des
chaînes) :

if (s1.equals(s2)) ……

N'utilisez pas l'opérateur == pour comparer deux chaînes. En effet cet opérateur ne
compare pas le contenu des variables chaînes de caractère, mais quelque chose appelée
référence. Vous verrez ce concept plus tard. Pour l'instant retenez que String n'est pas un
type de base comme un autre et que la comparaison se fait avec equals().

La taille d'une chaîne de caractères est donnée par l'instruction suivante :

s1.length();

Pour extraire un caractère d'une chaîne on utilise :

s1.charAt(i);

Qui retourne le ième caractère de s1. Attention i doit être compris dans l'intervalle
[0,s1.length()[

Marc Tizzano (EMN) 46

 Pour extraire une sous-chaîne de s1, on utilisera :

s1.substring(i,j);

qui extrait la sous-chaîne compris dans l'intervalle [i,j[

"Bonjour".substring(3,6);

retourne "jou".

11.1.2 Conversions

Lors de l'évaluation des expressions, des conversions automatiques sont effectuées.

Prenons un exemple, si f est un float et i un entier, comment évaluer l'expression f + i ? Le
compilateur est face à deux possibilités :
1) il convertit f en entier et effectue une addition entre 2 entiers.
2) il convertit i en flottant et effectue une addition entre 2 flottants.
Quelle est la meilleure solution ? Réfléchissez quelques secondes.. Pour fixer les idées
supposons que f est égal à 3.456 et i à 5.
1) dans le premier cas l'opération réellement effectuée est 3 (partie entière de 3.456) + 5 ,
le résultat est 8.
2) dans le second cas l'opération est 3.456 + 5.0, dont le résultat est 8.456.
La seconde solution est bien évidemment la meilleura et confronté à l'expression f + i, le
compilateur va convertir i en float avant d'effectuer l'addition. C'est une conversion
implicite ou une promotion. Si le programmeur préfère la première solution, il doit
l'indiquer au compilateur en écrivant (int)f +i . L'opération de transformation de f en entier
est appelée une conversion explicite ou coercition ou transtypage (en anglais cast).

Les conversions implicites sont fixées de la façon suivante :

• Lors de l'évaluation d'une expression arithmétique avec 2 opérandes les conversions

implicites sont effectuées selon les règles qui suivent :
1. Si un des opérandes est de type double l'autre est converti en double,
2. sinon si un des opérandes est de type float l'autre est converti en float,
3. sinon si un des opérandes est de type long l'autre est converti en long,
4. sinon les deux sont converti en int.

• lors d'une affectation (ou d'une initialisation) l'expression à droite du symbole

d'affectation, est convertie selon les règles résumées par le tableau suivant (les
conversions se font dans le sens de la flèche) :

byteàshortàintàlongàdouble
intàfloatàdouble
charàint

Les autres conversions peuvent se faire par coercition, la syntaxe est alors :
(type) expression

Marc Tizzano (EMN) 47

Soient les déclarations suivantes :

int a=1;
byte b=2;
double d=3.0;

Ces affectations sont licites :

a = b;
d = a;
d = b;

Ces affectations nécessitent une conversion explicite :

b = (byte) a;
a = (int) d;
b = (byte) d;

Le programme suivant :

short a =1;
short b =2;
short c =a+b;

provoque l'erreur :

Essai.java:24: possible loss of precision

found : int
required: short
short c =(a+b);
^
1 error

qui est corrigée par une conversion implicite :

short c = (short)(a+b);

Marc Tizzano (EMN) 48

12 Concepts avancés

12.1 Méthode

12.1.1 Définition

L’écriture de programme de taille importante, nécessite de découper le programme en

petites unités. Le concept de méthode est une de ces unités. Une méthode s’apparente à la
procédure ou à la fonction en PASCAL.

afficheChaine("Une chaine");

Représente l’appel de la méthode AfficheChaine avec une "Une chaine"en paramètre.

Sa déclaration se fait de la façon suivante :

static void afficheChaine(String s) {

System.out.println(s);
}

Elle prend en argument s et l’affiche.

Notez que
1) Cette méthode est déclarée static.
2) Après le nom de la méthode on a indiqué la liste des paramètres et leur type.
3) Cette méthode ne retourne aucune valeur. C’est pour cela que l’on a utilisé le mot clef
void.

Autre exemple :

static int carre (int x) {

return x*x;
}

Cette méthode retourne le carré du nombre passé en argument. L’argument est un entier
(car on a écrit int x), le résultat est lui- même entier (car on a écrit int avant carre).

INFO07EXE01
Ecrire une méthode qui retourne le maximum de 2 entiers.

Marc Tizzano (EMN) 49

 INFO07EXE02
Ecrire une méthode qui retourne la valeur en majuscule, d'un caractère passé en paramètre.
par exemple :
System.out.println(majuscule('a'));
affiche
A

12.1.2 Méthode récursive

Dans le corps d’une méthode, on peut faire appel à la même méthode. On dit que cette
méthode est récursive. La méthode suivante :

static long factorielle(long n) {

if (n<=1) {
return 1;
} else {
return n*factorielle(n-1);
}
}

Retourne n!.

INFO07EXE03
Suite de Fibonacci

La suite de Fibonacci est définie comme suit :

Fibonacci(0) = 0
Fibonacci(1) = 1
…..
Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2)
Autrement dit à partir du 3iéme nombre, tout nombre est la somme des 2 nombres
précédents.
Ecrire une méthode qui affiche la suite de Fibonacci.

12.1.3 Variable locale

Les variables déclarées à l’intérieur d’une méthode ne sont pas visibles de l’extérieur.

Par exemple le programme suivant :

…
1 static void calcul(int i) {
2 int x = 0;
3 …
4 }
5 static public void main(String arg[]) {
6 int x=1;

Marc Tizzano (EMN) 50

 7 calcul(456);
8 System.out.println(x);
…

Imprime 1. Car c’est la variable x définie dans la méthode main qui est utilisée. Si la ligne
6 est supprimée, le code ne compile plus (essayez !).

12.1.4 Passage des arguments

En Java les arguments sont passés par valeur. Cela implique que leur valeur n’est pas
modifiée après l’appel de la méthode.

static void m(int i) {

i=i+1;
}
…
static public void main(String arg[]) {
int ii = 345;
m(ii);
System.out.println(ii);
…

Affiche 345 à l’écran, bien que la variable i soit modifiée dans la méthode m.

12.1.5 Surcharge des méthodes

Java permet d’utiliser le même nom pour plusieurs méthodes, à condition que le type de
leurs paramètres soit différent.

static int carre(int i) {…};

static float carre(float f) {…};

static int multiplication(int x, int y);

static int multiplication(int x, int y, int z);

Ces deux premières méthodes définissent le calcul du carré d’un entier et du carré d’un
flottant.

12.1.6 Bibliothèque mathématique

La bibliothèque mathématique de Java définit des méthodes permettant les calculs

mathématiques usuels. Elles s’utilisent comme suit :

double x;
x=Math.sqrt(567);//Racine carrée de 567

Notez la syntaxe Math.OpérationMathématique(..)

Marc Tizzano (EMN) 51

Les opérations possibles sont les suivantes :

Opération Signification
Math.abs(x) Valeur absolue
Math.ceil(x) Arrondi au plus petit entier (sous forme
de double) supérieur ou égal.
Math.ceil(9.2) à 10.0
Math.cos(x) Cosinus
Math.exp(x) Exponentielle
Math.floor(x) Arrondi au plus grand entier (sous
forme de double) inférieur ou égal.
Math.floor(9.9) à 9.0
Math.log(x) Logarithme naturel
Math.max(x,y) Plus grande valeur
Math.min(x,y) Plus petite valeur
Math.pow(x,y) Elévation de x à la puissance de y
Math.sin(x) Sinus de x
Math.sqrt(x) Racine carrée de x
Math.tan(x) Tangente de x

Toutes ces opérations retournent une valeur.

INFO07EXE04
Définissez une méthode qui retourne l'entier (sous forme de double) le plus proche d'un
réel.
Par exemple arrondit(3.4) à 3, arrondit(3.6) à 4

Marc Tizzano (EMN) 52