Exemple 2 : Calcul la somme des diviseurs de 100

Java
C est un langage populaire
C++ est une extension du langage
C qui est plus populaire
que C. Ses nouveautés rendent plus agréable le C et
permettent aussi de faire la programmation orientée objet
(POO).
JAVA
(IFT 1810, IFT 1170, IFT 1176) utilise surtout la
C++.
syntaxe du
orienté objet.
De plus, Java est un langage purement
Dans le cours IFT 1810, on introduit à la programmation
orientée objet (POO), à l’aperçu du langage JAVA sans aller
dans les détails. Le but de ce résumé est de vous permettre
de saisir des explications en classe au lieu de copier des
programmes écrits au tableau. Les exemples expliqués en
classe et disponibles sur le site Web du cours utilisent
l’environnement JCreator.
A) Quelques mots sur la POO :
Dans notre vie quotidienne, on travaille très souvent avec
des objets :
Un tableau est un objet. Il dispose de champs
d’informations (des attributs) : materiel, couleur,
largeur, hauteur :
On peut fabriquer (construire, instancier) un tableau par
plusieurs manières :
matériel : en bois, en métal, en plastique dur, . . .
couleur : noire, blanche, . . .
largeur : 4.2 mètre, 3.8 mètre, . . .
hauteur : 2.3 mètre, 1.90 mètre, . . .
Il faut que le tableau existe (soit construit, instancié)
avant de parler comment travailler avec un tableau.
Que peut-on faire avec un tableau ?
En français, on est habitude avec l’action :
-
écrire au tableau
effacer le tableau
laver le tableau
-
etc …
En POO, on écrit souvent sous la forme :
tableau.écrire(. . .)
appliquer la méthode écrire
sur l’objet tableau
tableau.effacer(. . .) appliquer la méthode effacer
sur l’objet tableau
etc . . .
Une porte est un autre objet.
On peut construire une porte par plusieurs manières :
en bois, en métal, en pailles, . . .
Que peut-on faire avec une porte ?
- ouvrir la porte
- fermer la porte
- etc …
C’est la même chose en programmation orientée objet (POO) :
Quelles sont les caractéristiques (champs, attributs) d’un
objet ? Comment construire un objet ? Quelles sont les
méthodes qu’on peut appliquer sur l’objet ?
Une classe en POO est une unité comportant très souvent :
des champs d’informations, des méthodes spéciales
s’appelant constructeurs pour construire (instancier) des
objets de la classe, des méthodes pour appliquer sur ses
objets, des clauses d’accès (privée, publique), etc . . .
Exemple : Concevoir la classe cercle en sachant qu’un
cercle est déterminé par son champ rayon. On peut calculer
la surface, le périmètre d’un cercle, etc …
Réponse :
class Cercle
{
// l’accès au champ rayon est privé, dans le corps
// de la classe Cercle seulement
private double rayon;
// un constructeur
public Cercle(double r)
{
rayon = r;
}
// un autre constructeur
public Cercle()
{
rayon = 1.234;
}
// méthode calculante et retournant le périmètre
// d’un cercle où périmètre = 2 x PI x rayon
// et en Java, Math.PI fournit le champ PI valant
// 3.14159
public double perimetre()
{
return 2 * Math.PI * rayon;
}
// méthode calculante la surface
public double surface()
{
return Math.PI * rayon * rayon;
}
. . . etc . . .
} // fin de la classe Cercle
On apprendra plus tard, les détails de la conception d’une
classe. Par contre, on utilisera assez tôt, quelques
classes du langage Java :
String : classe des chaînes de caractères
Integer : classe associée au type int
Double : classe associée au type double
( Le type double est aussi pour les réels mais plus de
chiffres significatifs que le type float ).
Affichage à l’écran : appliquer la méthode printf sur
l’objet out du System (l’objet sortie du System est
l’écran).
System.out.printf(" messages ");
System.out.printf(" messages + code format ", etc . . .);
Premier exemple d'introduction :
(explications : en classe, au premier cours de la partie POO avec Java)
Réaliser
un projet en Java permettant de déclarer,
d’initialiser les informations suivantes de l’étudiante
Lise Charbonneau qui a le code permanent "CHAL12599305"
(elle est née le 12 septembre 1993
 2013 – 1993 = 20 ans à 2013
 le ministère de l’éducation a ajouté 50 au mois de
naissance d’une étudiante : 50 + 9 = 59)
Le projet permet de :
- afficher le nom et prénom tel quel, en tous majuscules,
en tous minuscules
- déterminer le sexe (féminin ou masculin)
- calculer l’âge brut à l’année 2013
L’exécution du projet donne, par exemple, ce qui suit :
--------------------Configuration: <Default>-------------------Le nom et prénom tel quel : Charbonneau Lise
Le nom et prénom en tous majuscules : CHARBONNEAU LISE
Le nom et prénom en tous minuscules : charbonneau lise
Sexe : féminin
L'âge à 2013 est 20 ans
Quelques réfléxions sur le problème à programmer :
En langage C, on a déjà travaillé avec certains types de
base habituels : int pour les entiers, char pour les
caractères, float ou double pour les réels. Les
identificateurs de ces types sont en tous minuscules.
Il n’y a pas beaucoup de manipulations possibles avec des
informations de ces types.
Une classe est une sorte de type élargi, on parle souvent :
age est une variable de type int
taille est une variable de type double
nomPre est un objet de la classe String
des opérations sur des types de base :
age1 + age2 : somme des deux âges
age1 * age2 : produit des deux âges
etc ...
des méthodes appliquées sur un objet d’une classe :
String nomPre = "Charbonneau Lise";
 nomPre est un objet de la classe String
 nomPre.toUpperCase() vaut "CHARBONNEAU LISE"
on applique la méthode toUpperCase() pour
convertir une chaîne en tous majuscules
 nomPre.toLowerCase() vaut "charbonneau lise"
on applique la méthode toLowerCase() pour
convertir une chaîne en tous minuscules
 nomPre.charAt(0) vaut ‘C’
le caractère à l’indice 0 du nom et prénom est la
lettre ‘C’
 nomPre.charAt(2) vaut ‘a’
le caractère à l’indice 2 du nom et prénom est la
lettre ‘a’
 nomPre.substring(2,7) vaut "arbon"
la sous-chaîne entre l’indice 2 inclu et l’indice
7 exclu du nom et prénom est la chaîne de
caractères "arbon"
 etc . . .
 Integer.parseInt("93") vaut 93
On utilise la méthode de conversion d’une chaîne
numérique en valeur entière de la classe Integer.
 etc . . .
On rentre alors dans le monde de la programmation orientée
objet dont on parle constamment des objets d’une classe,
des méthodes appliquées sur un objet, des méthodes d’une
classe!
De plus, le Java utilise une partie de syntaxe du C++, une
extension du langage C. On retrouvera une partie du C en
Java avec quelques nouveautés du C++ dans la plupart des
exemples vus en IFT 1810 :
- commentaires en ligne avec
// commentaire . . .
- flexibilité des déclarations
mélanger les déclarations et les traitements
- etc . . .
Le programme suivant sera expliqué en détails en classe.
/* Fichier Introd1.java
public class Introd1
{
public static void main(String[] args)
{
final int ANNEE_COURANTE = 2013;
String nomPre = "Charbonneau Lise",
codePerm = "CHAL07539305";
System.out.printf("Le nom et prénom tel quel : %s\n", nomPre);
System.out.printf("Le nom et prénom en tous majuscules : %s\n",
nomPre.toUpperCase());
System.out.printf("Le nom et prénom en tous minuscules : %s\n",
nomPre.toLowerCase());
if (codePerm.charAt(6) >= '5')
System.out.printf("Sexe : féminin\n");
else
System.out.printf("Sexe : masculin\n\n");
int anneeNais = 1900 + Integer.parseInt( codePerm.substring(8, 10))
;
System.out.printf("L'âge à %d est %d ans\n\n", ANNEE_COURANTE,
ANNEE_COURANTE - anneeNais);
}
}
Observations et commentaires du programme :
Aux pages 3 et 4, on a déjà parlé un peu de la POO et du
Java pour une partie du programme. Les explications
suivantes sont destinées surtout aux étudiants qui
connaissent le C mais pas encore du Java, ni de la
programmation orientée objet (POO).
1. L’identificateur String se commence par une lettre
majuscule. Ce n’est pas un type, c’est le nom d’une
classe, une terminologie fréquemment utilisée en POO.
2. Le Java vu dans IFT 1810 utilise souvent des classes
prédéfinies (String, Integer, . . .) et leurs méthodes.
3. Le Java utilise certaines conventions pour les
identificateurs (constantes en lettres majuscules,
variables, méthodes : premier mot en minuscules, début
d’un nouveau mot en majuscule :
nbPieds, nbLivres, toUpperCase(), etc).
4. La déclaration en Java :
final int ANNEE_COURANTE = 2013;
est équivalente à celle-ci du C :
const int ANNEE_COURANTE = 2013;
ANNEE_COURANTE est de type int et sa valeur est "finale"
(inchangée => c’est une constante).
5. La déclaration en Java :
String nomPre = "Charbonneau Lise",
codePermanent = "CHAL12599001";
déclare et initialise 2 objets nomPre et codePermanent
de la classe String qu’on pourra appliquer plusieurs
méthodes existantes sur ces deux objets.
6. Les clauses de visibilité public, static seront
expliqués plus tard.
Trois formes d’accès en Java :
1. forme 1 (très fréquente : 80 % des cas) :
objet.méthode (……..)
Appliquer une méthode sur l’objet
Exemples :
"Bonsoir".length() retourne 7 (longueur de la chaîne)
"Bonsoir".charAt(0) retourne ‘B’ (le caractère à
l’indice 0 est la lettre ‘B’)
"Bonsoir".indexOf(‘n’) retourne 2 (on trouve la lettre ‘n’ à
l’indice 2
"Bonsoir".substring(1, 3) retourne "on" (la sous-chaîne
délimitée entre l’indice 1 inclus et
l’indice 3 exclu)
2. forme 2 (moins fréquente : 15 % des cas) :
classe.méthode static(……..)
Utiliser une méthode static d’une classe
Exemples :
Integer.parseInt("17") retourne 17 (valeur entière)
Math.sqrt(16.0) retourne la racine carrée de 16.0 qui vaut 4.0
3. forme 3 (peu fréquente : 5 % des cas) :
classe.champ static
Accès à un champ (attribut) static d’une classe
Exemples :
Math.PI vaut 3.14159… (valeur PI de la classe Math)
Integer.MAX_VALUE retourne 231-1 (l’entier le plus grand)
B)
Notions de base de Java vs C
:
if, switch, do … while, while, for : comme le C
(plus tard, on verra une autre forme de for en
Java).
Des opérateurs : pareils en C
Pour les réels : Dans IFT 1810, en Java, on
couramment le type double au lieu du type float.
(double pour réel en double précision).
utilise
Commentaire en ligne : une des nouveautés en Java
// contenu du commentaire
Exemple :
final double TAUX_TPS = 0.05; // 5 % pour taxe TPS
( TAUX_TPS est de type réel, sa valeur est 0.05 et cette
valeur est finale, on ne change plus, ne modifie plus.
C’est une constante ).
Flexibilité
de
déclaration :
on
peut
mélanger
des
déclarations avec des instructions.
Exemples : for(int n = 1; n <= 5; n++)
System.out.printf("Bonjour!\n");
int somme = 0;
for (int n = 1; n <= 5; n += 2)
somme += n ;
Autres nouveautés : à venir
C)Exemples simples :
Exemple1 : Allure d’un programme très simple en Java
Écrire un programme Java permettant de déclarer +
d’initialiser quelques informations d’une étudiante
du nom Lachance Pascale. On affiche ses informations
ainsi que quelques messages de souhait.
// Fichier Ex0.java
public class Ex0 {
public static void main(String[] args) {
String nomPre = "Lachance Pascale" ;
int age = 21 , nbCafe = 2 ; // 2 tasses de café par jour
double taille = 1.67, poids = 65.4;
System.out.printf("Bienvenue au Java et à la POO\n");
System.out.printf("\nInformations de cette étudiante : \n");
System.out.printf("Nom et prénom : %s\n", nomPre);
System.out.printf("Age
: %d an(s)\n", age);
System.out.printf("Café
: %d tasse(s)par jour\n",
nbCafe);
System.out.printf("Sa taille
: %.2f mètre\n", taille);
System.out.printf("Son poids
: %.1f kg\n", poids);
System.out.printf("\nBon succès en Java!\n\n");
}
}
/* Exécution :
---------------Configuration: <Default>-------------------Bienvenue au Java et à la POO
Informations de
Nom et prénom :
Age
:
Café
:
Sa taille
:
Son poids
:
cette étudiante :
Lachance Pascale
21 an(s)
2 tasse(s)par jour
1,67 mètre
65,4 kg
Bon succès en Java!
Process completed.
*/
Exemple2 : Allure d’un programme très simple en Java
Écrire un programme Java permettant de déterminer et
d’afficher les diviseurs de 6, de 20 puis de 17 selon le
format suivant :
Pour ce programme, on n’utilise pas de sous-programmes
autres que main (un sous-programme est une fonction en C,
une méthode en Java) :
Les diviseurs de 6 sont :
1)
1
2)
2
3)
3
4)
6
Les diviseurs de 20 sont :
1)
1
2)
2
3)
4
4)
5
5)
10
6)
20
Les diviseurs de 17 sont :
1)
1
2)
17
// Fichier Ex1.java
public class Ex1 {
public static void main(String[] args) {
// declaration de 3 constantes
final int NOMBRE1 = 6,
NOMBRE2 = 20,
NOMBRE3 = 17;
int rang;
// afficher les diviseurs de 6 :
rang = 0;
System.out.printf("Les diviseurs de %d sont : \n", NOMBRE1);
for(int candidat = 1 ; candidat <= NOMBRE1 ; candidat++)
if (NOMBRE1 % candidat == 0)
{
rang++;
System.out.printf("%3d) %8d\n", rang, candidat);
}
System.out.printf("\n");
// afficher les diviseurs de 20 :
rang = 0;
System.out.printf("Les diviseurs de %d sont : \n", NOMBRE2);
for(int candidat = 1 ; candidat <= NOMBRE2 ; candidat++)
if (NOMBRE2 % candidat == 0)
{
rang++;
System.out.printf("%3d) %8d\n", rang, candidat);
}
System.out.printf("\n");
// afficher les diviseurs de 17
rang = 0;
System.out.printf("Les diviseurs de %d sont : \n", NOMBRE3);
for(int candidat = 1 ; candidat <= NOMBRE3 ; candidat++)
if (NOMBRE3 % candidat == 0)
{
rang++;
System.out.printf("%3d) %8d\n", rang, candidat);
}
System.out.printf("\n");
}
}
Veuillez noter que les 5 lignes du genre :
if (NOMBRE1 % candidat == 0)
{
rang++;
System.out.printf("%3d) %8d\n", rang, candidat);
}
peuvent se remplacer par les 2 lignes comme suit :
if (NOMBRE1 % candidat == 0)
System.out.printf("%3d) %8d\n", ++rang, candidat);
/* Exécution :
-------------Configuration: <Default>-------------Les diviseurs de 6 sont :
1)
1
2)
2
3)
3
4)
6
Les diviseurs de 20 sont :
1)
2)
3)
4)
5)
6)
1
2
4
5
10
20
Les diviseurs de 17 sont :
1)
1
2)
17
Process completed.
*/
Exemple 3 : Allure d’un programme en Java
Refaites l’exemple 1 en écrivant un programme Java avec
méthode d’une classe :
En-tête :
static . . . ( . . . )
Appel
:
Classe.méthode static ( . . . )
Ou
méthode static ( . . . )
si la méthode est écrite dans la classe
// Fichier Ex3.java
public class Ex2
{
// méthode static de la classe Ex2 permettant
// d’afficher les diviseurs d’un nombre donné
static void afficherDiv(int nombre)
{
int rang = 0;
System.out.printf("Les diviseurs de %d sont : \n",
nombre);
for(int candidat = 1 ; candidat <= nombre ;
candidat++)
if (nombre % candidat == 0)
System.out.printf("%3d) %8d\n", ++rang,
candidat);
System.out.printf("\n");
}
public static void main(String[] args) {
final int NOMBRE1 = 6,
NOMBRE2 = 20,
NOMBRE3 = 17;
Ex2.afficherDiv(NOMBRE1);
Ex2.afficherDiv(NOMBRE2);
Ex2.afficherDiv(NOMBRE3);
}
} // fin de classe Ex2
/* Exécution :
----------------Configuration: <Default>----------------Les diviseurs de 6 sont :
1)
1
2)
2
3)
3
4)
6
Les diviseurs de 20 sont :
1)
1
2)
2
3)
4
4)
5
5)
10
6)
20
Les diviseurs de 17 sont :
1)
1
2)
17
Process completed.
*/
D)
Convention des identificateurs en Java
Pour le nom d’une classe :
Début de chaque mot en majuscule.
Exemples :
Cercle, Ex0, Ex1, Integer, Double, String,
StringTokenizer, etc …
Pour le nom d’une constante : tous en majuscules.
Exemples :
final int MAX_AGE = 132 ;
final double BAR_FINAL = 0.40; // 40 % pour le final
:
Pour le nom d’une variable, d’un objet, d’une méthode :
Le 1er mot en tous minuscules, début d’un nouveau mot
en majuscule
Exemples :
static void afficherDiv(int nombre)
. . .
int age, cafe, nbPieds, nbPouces;
Cercle c1, c2;
String nomPre = “Tremblay Nicole”,
codePerm = “TREN12619407”;
Type:
int age ;
float taille, poids ;
char sexe ;
int estCelibataire ;
etc .
Constante:
#define MAX_PERS 50
OU const double TAUX_TPS = 0.07 ;
Type:
int age ;
float taille, poids ;
char sexe ;
boolean estCelibataire ;// existe en JAVA
etc .
Constante:
// final pour dire la valeur est "finale"
final double TAUX_TPS = 0.07;
Opérateurs arithmétiques (pour les calculs) Opérateurs arithmétiques (pour les calculs)
+ , - , * (multiplication)
+ , - , * (multiplication)
10 / 4 vaut 2 mais 10.0 / 4 vaut 2.5
10 / 4 vaut 2 mais 10.0 / 4 vaut 2.5
(un seul opérateur de division)
(un seul opérateur de division)
12 % 10 vaut 2 (le modulo)
12 % 10 vaut 2 (le modulo)
Opérateurs relationnels (comparaison) :
==
!=
<
est égale à est différent de plus petit que
<=
>
>=
plus petit ou égale plus grand
pg ou égale
Opérateurs relationnels (comparaison) :
==
!=
<
est égale à est différent de plus petit que
<=
>
>=
plus petit ou égale plus grand
pg ou égale
Affectation:
Affectation:
age = 23 ;
age = 23 ;
Quelques remarques:
Quelques remarques:
1. point virgule (souvent) à la fin
2. majuscule vs minuscule :
TP1 est différent de Tp1
3. liste d'informations de même type :
double taille, poids ;
4. = (affectation) vs = = (égalité)
5. un seul opérateur de division : /
6. programmer le type booléen avec int
7. un seul caractère (char) vs chaîne de
caractères (tableau des caractères, ...)
8. int age = 17.89 ; // permis (vaut 17)
1. point virgule (souvent) à la fin
2. majuscule vs minuscule :
TP1 est différent de Tp1
3. liste d'informations de même type :
double taille, poids ;
4. = (affectation) vs = = (égalité)
5. un seul opérateur de division : /
6. existence du type boolean
7. un seul caractère (char) vs chaîne de
caractères (String nomPrenom ;)
8. int age = 17.89 ; // invalide
La sélection simple avec if :
if ( condition )
instruction A
else
instruction B
Style 1 (sans else):
if ( mois = = 1 )
nbJours = 31 ;
if ( age ) // si age est non nul
printf("age = %d\n", age);
Style 1 (sans else):
if (mois = = 1)
nbJours = 31 ;
if ( age != 0 ) // condition explicite
System.out.println("age = " + age);
Style 2 (avec else):
if ( valeur1 > valeur2 )
maximum = valeur1 ;
else
maximum = valeur 2 ;
Style 2 (avec else):
if (valeur1 > valeur2)
maximum = valeur1 ;
else
maximum = valeur 2 ;
Style 3 (if imbriqué):
if ( jour >= 2 && jour <= 5)
nbCafe = 5 ;
else
if ( jour = = 6 )
nbCafe = 3 ;
else
nbCafe = 1 ;
Style 3 (if imbriqué):
if ( jour >= 2 && jour <= 5)
nbCafe = 5 ;
else
if ( jour = = 6 )
nbCafe = 3 ;
else
nbCafe = 1 ;
Style 4 (instruction composée):
if ( age >= 12 && age < 18 )
{ printf("Adolescent");
nbAdo++;
}
else
printf("Pas un ado");
Style 4 (instruction composée):
if ( age >= 12 && age < 18 )
{ System.out.printf("Adolescent");
nbAdo++;
}
else
System.out.printf ("Pas un ado");
Fonctionnement
Si la condition vaut vraie, on exécute les instructions sous if.
Dans le cas contraire (sinon), et, si la clause else se présente,
on effectue les instructions sous else.
La sélection multiple avec
switch ...
switch ( expression )
{ case cte1 : instructions 1;
case cte2 : instructions 2;
...
case ctek : instructions k;
default : instructions ;
}
Pour quitter le suivant que (switch), la dernière
instruction de "l'instructions n" est souvent l'instruction
"break" (voir exemples). L'instructions n peut être vide.
Exemple avec Java :
switch ( rang )
{ // du lundi à jeudi :
case 2 :
case 3 :
case 4 :
case 5 : System.out.printlf"On travaille très fort\n");
break;
// cas de vendredi
case 6 : System.out.printf ("Fin de semaine s'en vient\n ");
break;
// cas de samedi ou dimanche
case 1 :
case 7 : System.out.printf ("Youppi! C'est la fin de semaine\n");
break;
default: System.out.printf ("Rang erroné!\n");
// break ; n'est pas nécessaire
}
Boucle de répétition avec tant que (while):
while ( condition )
instruction
Cas d'instruction simple:
while ( n > 0 )
n = n / 10 ;
Cas d'instruction composée:
while ( n ) // n different de zéro
{ som = som + n % 10;
n = n / 10 ;
}
Cas d'instruction simple:
while ( n > 0 )
n = n / 10 ;
Cas d'instruction composée:
while ( n != 0 )
{ som = som + n % 10;
n = n / 10 ;
}
Fonctionnement :
Étape 1 : vérifier d'abord la condition
Étape 2 : si la condition vaut vraie alors
a) on effectue les instructions à répéter
b) on revient à l'étape 1
si non, on quitte la boucle
Il faut assurer que la condition soit bien définie avant d'exécuter
la boucle while. La condition est une expression booléenne en Java
(pas une expression entière comme en C, C++).
Exemple simple: Calcul de
S = 5 + 15 +… + 105
final int BORNE1 = 5, BORNE2 = 105, LE_PAS = 10 ;
int somme = 0, valeur = BORNE1;
while (valeur <= BORNE2) {
somme += valeur ;
valeur += LE_PAS;
}
System.out.printf("somme = %d\n", somme);
Boucle de répétition avec pour (for . . .) :
for ( exp1 ; exp2; exp3 )
instruction
Exemple 1
for ( i = 1 ; i <= 5 ; i++)
printf("Bonjour\n");
Exemple 2
for ( val = 1 ; val <= 21; val += 5)
{ som = som + val ;
pro = pro * val ;
}
Exemple 1
for (int i = 1 ; i <= 5 ; i++)
System.out.printf("Bonjour\n");
Exemple 2
for ( val = 1 ; val <= 21; val += 5)
{ som = som + val ;
pro = pro * val ;
}
Fonctionnement classique:
Initialiser la variable de contrôle de la boucle:
variable = valeur de départ
Tant que Variable <= valeur d'arrivée Faire
- effectuer les instructions à répéter
- ajuster la valeur de la variable de contrôle
variable = variable + lePas
Domaines d'utilisation:
On utilise la boucle for quand on sait à l'avance le nombre de
fois qu'on répète le même traitement. C'est le cas des valeurs
dont le pas est une constante entre deux bornes données. On
l'utilise également pour parcourir les indices d'un tableau.
Calcul de S = 10 + 15 + 20 + 25 + … + 150
int somme = 0 ;
for ( int valeur = 10 ; valeur <= 150; valeur += 5)
somme += valeur ;
System.out.printf("S = %d\n", somme);
OU
int somme = 0 ;
for ( int valeur = 150 ; valeur >= 10; valeur -= 5)
somme += valeur ;
System.out.printf("S = %d\n", somme);
Boucle de répétition avec do . . . while
do
instruction
while ( condition pour continuer ) ;
Exemple:
do
{ somme = somme + n % 10;
n = n / 10 ;
}
while (n > 0);
Exemple 1 : Calcul de
Solution :
do
{ somme = somme + n % 10;
n = n / 10 ;
}
while ( n > 0 );
P = 10 * 15 * 20 * … * 45
int produit = 1, valeur = 10;
do {
produit *= valeur ;
valeur += 5 ;
} while (valeur <= 45);
System.out.printf("P = %d", produit) ;
Exemple 2 : Calcul la somme des diviseurs de 100
final int NOMBRE = 100;
int somDivi = 0, candidat = 1 ;
do { if (NOMBRE % candidat == 0)
somDivi += candidat ;
candidat++;
} while (candidat <= NOMBRE);
System.out.printf("somme des diviseurs de %d est %d",
NOMBRE, somDivi);
E) Exercices :
Exercice 1 :
Écrire un programme Java permettant d’utiliser de méthodes static
permettant de déterminer puis afficher les 3 lignes suivantes :
Les 4 diviseurs de 6 sont : 1 2 3 6
Les 6 diviseurs de 20 sont : 1 2 4 5 10 20
Les 2 diviseurs de 17 sont : 1 17
Solution :
// Fichier Exercice1.java (page 17, document java_01.doc)
public class Exercice1
{
// méthode static de la classe Exercice1 comptant et retournant
// le nombre de diviseurs d’un entier nombre > 0
static int nbDiv(int nombre)
{
int n = 0;
for(int candidat = 1 ; candidat <= nombre ; candidat++)
if (nombre % candidat == 0)
n++;
return n;
}
static void afficherDiv(int nombre)
{
System.out.printf("Les %d diviseurs de %2d sont : ",
nbDiv(nombre),nombre);
for(int candidat = 1 ; candidat <= nombre ; candidat++)
if (nombre % candidat == 0)
System.out.printf("%3d ", candidat);
System.out.printf("\n");
}
public static void main(String[] args) {
final int NOMBRE1 = 6,
NOMBRE2 = 20,
NOMBRE3 = 17;
Exercice1.afficherDiv(NOMBRE1);
afficherDiv(NOMBRE2);
afficherDiv(NOMBRE3);
}
} // fin de la classe Exercice1
/* Exécution :
--------------------Configuration: <Default>-------------------Les 4 diviseurs de 6 sont : 1 2 3 6
Les 6 diviseurs de 20 sont : 1 2 4 5 10 20
Les 2 diviseurs de 17 sont : 1 17
Process completed.
*/
Exercice 2 : solution sur demande!
Écrire un programme Java permettant d’utiliser de méthodes static
permettant de déterminer puis afficher les 2 blocs de lignes suivantes :
13579
1357
135
13
1
135
13
1
Solution :
// Fichier Exercice2.java (page 18, document java_01.doc)
public class Exercice2 {
static void afficher(int nombre)
{
for(int fin = nombre ; fin >= 1 ; fin -= 2)
{
for(int debut = 1; debut <= fin ; debut += 2)
System.out.printf("%3d ", debut);
System.out.printf("\n");
}
System.out.printf("\n");
}
public static void main(String[] args) {
final int NOMBRE1 = 9,
NOMBRE2 = 5;
afficher(NOMBRE1);
afficher(NOMBRE2);
}
}
/* Exécution :
--------------------Configuration: <Default>-------------------1 3 5 7 9
1 3 5 7
1 3 5
1 3
1
1 3 5
1 3
1
Process completed.
*/
Déclarer le tableau des tailles et initialiser les
8 premières valeurs :
double[] taille = { 1.76, 1.68, 1.89, 1.72, 1.54,
1.78, 1.34, 1.78 };
int nbPers = taille.length ; // vaut 8 ici
taille est un tableau de 8 éléments, chacun est une
variable de type double.
On peut illustrer le tableau des tailles par le schéma
suivant :
taille
1.76
1.68
1.89
1.72
1.54
1.78
1.34
1.78
1. L'indice commence par 0 (zéro)
2. La boucle for est largement utilisée pour traiter
les tableaux.
3. Sur l'en-tête d'une fonction : une manière simple :
static void afficher( double[] taille, int nbPers)
etc . . .
Exemple : déterminer la taille la plus petite :
double plusPetiteTaille = Double.MAX_VALUE ;
for (int i = 0 ; i < taille.length ; i++)
if ( taille[i] < plusPetiteTaille)
plusPetiteTaille = taille[i];
Conversion d’un programme C en Java :
En classe, on a expliqué et tapé le programme Fonct5.c
suivant :
/*
Fichier Fonct5.c
Auteurs Tremblay Julie IFT 1810 C Gr. 1
Choquette Alain IFT 1810 C Gr. 1
Ce programme permet de .... (voir exécution)
*/
#include <stdio.h>
float moyenne(float tab[], int nbElem)
{
float somme = 0.0;
int i ;
for(i = 0; i < nbElem; i++)
somme += tab[i];
return somme / nbElem;
}
int nombre(float tableau[], int nbElem, float borne)
{
int n = 0, i;
for(i = 0; i < nbElem; i++)
if (tableau[i] > borne)
n++;
return n;
}
int combien(char sexeVoulu, char sexe[], int nbPers)
{
int n = 0, i;
for(i = 0; i < nbPers; i++)
if (sexe[i] == sexeVoulu)
n++;
return n;
}
void afficher(float taille[], float poids[], char sexe[],
int nbPers)
{ int i;
printf("Contenu des 3 tableaux :\n\n");
printf("indice taille
poids
sexe\n");
for(i = 0; i < nbPers; i++)
printf("%3d %8.2f %7.1f
%5c\n", i, taille[i],
poids[i], sexe[i])
;
printf("\n\n")
;
}
int main()
{
const float BORNE1 = 1.75,
BORNE2 = 60.0;
float taille[] = {1.72, 1.86, 1.58, 1.76, 1.70},
poids[] = { 65.4, 76.1, 59.9, 73.4, 81.5};
char sexe[] = { 'F', 'M', 'F', 'F', 'M'}
;
int nbPers = sizeof(taille)
/ sizeof(float);
afficher(taille, poids, sexe, nbPers);
printf("Le nombre de personnes dont :\n");
printf(" - la taille depasse %.2f metre est %d\n",
BORNE1, nombre(taille, nbPers, BORNE1));
printf(" - le poids depasse %.2f kg
est %d\n",
BORNE2, nombre(poids, nbPers, BORNE2));
printf("Le nombre de femmes : %d\n", combien('F', sexe, nbPers))
;
printf("Le nb. d'hommes
: %d\n", combien('M', sexe, nbPers));
printf("La taille moyen : %.2f metre\n",
moyenne(taille,nbPers))
printf("Le poids moyen : %.1f kg\n",
moyenne(poids, nbPers));
return 0;
}
/* Execution :
Contenu des 3 tableaux :
indice taille
poids
0
1.72
65.4
1
1.86
76.1
2
1.58
59.9
3
1.76
73.4
4
1.70
81.5
sexe
F
M
F
F
M
;
Le
Le
Le
nombre de personnes dont :
la taille depasse 1.75 metre est 2
le poids depasse 60.00 kg
est 4
nombre de femmes : 3
nb. d'hommes
: 2
-------------------------------Process exited after 0.02253 seconds with return value 0
Appuyez sur une touche pour continuer...
*/
Faites toutes les étapes pour convertir ce programme en
Java.
Solution :
démontrée en classe
Quelques étapes :
À partir d’un programme quasi-vide en Java nommé, par
exemple, Methode5.java
1. Copier les fonctions écrites en C dans l’espace
entre class Methode1 et l’en-tête de la méthode main
2. Copier le corps de int main du C (sauf return 0 ;)
dans la méthode main
3. Avec les options Edit, Find and Repace, Replace
Remplacez tous :
a) printf par System.out.printf
b) const par final
c) float par double
d) tableau[] par [] tableau etc …
Enlevez les déclarations locales int i ;
mettez for(int i = 0 ; etc …
Ajoutez la clause static devant les en-têtes des
Méthodes
4. Jetez un coup d’œil et finalisez l’adaptation
Ce processus sera démontré en classe.
Finalement, vous obtenez la version Java suivant :
public class Methode5 {
static double moyenne(double[] tab, int nbElem)
{
double somme = 0.0;
for(int i = 0; i < nbElem; i++)
somme += tab[i];
return somme / nbElem;
}
static int nombre(double[] tableau, int nbElem, double borne)
{
int n = 0;
for(int i = 0; i < nbElem; i++)
if (tableau[i] > borne)
n++;
return n;
}
static int combien(char sexeVoulu, char [] sexe, int nbPers)
{
int n = 0;
for(int i = 0; i < nbPers; i++)
if (sexe[i] == sexeVoulu)
n++;
return n;
}
static void afficher(double [] taille, double[] poids, char [] sexe,
int nbPers)
{
System.out.printf("Contenu des 3 tableaux :\n\n");
System.out.printf("indice taille
poids
sexe\n");
for(int i = 0; i < nbPers; i++)
System.out.printf("%3d %8.2f %7.1f
poids[i], sexe[i])
System.out.printf("\n\n")
%5c\n", i, taille[i],
;
;
}
public static void main(String[] args) {
final double BORNE1 = 1.75,
BORNE2 = 60.0;
double [] taille = {1.72, 1.86, 1.58, 1.76, 1.70},
poids = { 65.4, 76.1, 59.9, 73.4, 81.5};
char [] sexe = { 'F', 'M', 'F', 'F', 'M'}
;
int nbPers = taille.length;
afficher(taille, poids, sexe, nbPers);
System.out.printf("Le nombre de personnes dont :\n");
System.out.printf(" - la taille depasse %.2f metre est %d\n",
BORNE1, nombre(taille, nbPers, BORNE1));
System.out.printf(" - le poids depasse %.2f kg
est %d\n",
BORNE2, nombre(poids, nbPers, BORNE2));
System.out.printf("Le nombre de femmes : %d\n",
combien('F', sexe, nbPers)) ;
System.out.printf("Le nb. d'hommes
: %d\n",
combien('M', sexe, nbPers));
System.out.printf("La taille moyen : %.2f metre\n",
moyenne(taille,nbPers))
System.out.printf("Le poids moyen : %.1f kg\n",
;
moyenne(poids, nbPers));
}
}
/* Exécution :
--------------------Configuration: <Default>-------------------Contenu des 3 tableaux :
indice
0
1
2
3
4
Le
Le
Le
La
Le
taille
1,72
1,86
1,58
1,76
1,70
poids
65,4
76,1
59,9
73,4
81,5
sexe
F
M
F
F
M
nombre de personnes dont :
la taille depasse 1,75 metre est 2
le poids depasse 60,00 kg
est 4
nombre de femmes : 3
nb. d'hommes
: 2
taille moyen : 1,72 metre
poids moyen : 71,3 kg
Process completed.
*/
Integer.MAX_VALUE : l’entier le plus grand
Integer.MIN_VALUE : l’entier le plus petit
Integer.parseInt("1234") retourne 1234
etc . . .
Double.MAX_VALUE : le réel le plus grand
Double.MIN_VALUE : le réel le plus petit
Etc . . .
Math.PI
valeur PI de la classe Math qui vaut 3.14159
Math.sqrt(16.0) racine carrée de 16.0 est 4.0
(square root : racine carrée)
Etc . . .
C’est une classe existence du langage Java. Elle offre
plusieurs méthodes pertinentes pour manipuler des chaînes
de caractères.
Soit la déclaration :
String nomPre = "Charbonneau Pascale",
codePerm = "CHAP17549403" ;// née le 17 avril 1994
(on ajoute 50 au mois de naissance pour une étudiante)
Notez les indices des caractères du code permanent :
0123456789
"CHAP17549403"
Pour IFT 1810, on se limite à ces méthodes suivantes :
codePerm.length() retourne 12 (nombre de caractères)
codePerm.charAt(0) retourne le caractère ‘C’
( le caractère à l’indice 0 )
codePerm.charAt(6) retourne le caractère ‘5’
codePerm.substring(0, 4) retourne "CHAP"
(la sous-chaîne entre l’indice 0 inclus, l’indice 4 exclu)
codePerm.substring(6, 8) retourne "54"
codePerm.substring(4) retourne "17549403"
(la sous-chaîne à partir de l’indice 4 jusqu’à la fin de la
chaîne)
codePerm.indexOf(‘C’) retourne 0
codePerm.indexOf(‘1’) retourne 4
codePerm.indexOf(‘4’) retourne 7 (malgré les deux 4)
codePerm.indexOf(‘z’) retourne -1 (la lettre ‘z’ est
introuvable)
codePerm.indexOf("CHA") retourne 0
codePerm.indexOf("94") retourne 8
codePerm.indexOf("Bonjour") retourne -1
nomPre.toUpperCase() retourne "CHARBONNEAU PASCALE"
nomPre.toLowerCase() retourne "charbonneau pascale"
Exemple 1 : (voir l’exécution pour comprendre l’exemple.
Attention au changement de ligne sous Word) :
/* Fichier Ex1String : exemple sur les chaînes de caractères
*
*/
public class Ex1String {
public static void main(String[] args) {
String codePermanent = "TREP23119006" ;
// Tremblay Pierre né le 23 novembre 1990
System.out.printf("Le marqueur pour indices:
012345678901234567890123456789\n");
System.out.printf("La chaîne telle quelle : %s\n",
codePermanent);
System.out.printf("La chaîne en MAJUSCULEs : %s\n",
codePermanent.toUpperCase());
System.out.printf("La chaîne en minuscules : %s\n",
codePermanent.toLowerCase());
System.out.printf("La longueur : %d caractères\n\n",
codePermanent.length());
System.out.printf("Le caractère à l'indice 3 : %c\n",
codePermanent.charAt(3));
System.out.printf("La sous-chaîne codePermanent.substring(0, 3)
vaut %s\n", codePermanent.substring(0, 3));
System.out.printf("La sous-chaîne codePermanent.substring(8)
vaut: %s\n", codePermanent.substring(8));
int anneeNaissance = 1900 +
Integer.parseInt( codePermanent.substring(8,10));
System.out.printf("L'année de naissance : %d\n",
anneeNaissance);
int k = codePermanent.indexOf('R');
System.out.printf("On trouve la lettre R à l'indice %d\n", k);
k = codePermanent.indexOf('Z');
if (k == -1)
System.out.printf("On ne trouve pas la lettre Z : indice
vaut %d\n", k);
k = codePermanent.indexOf("P2311");
if ( k >= 0)
System.out.printf("On trouve la sous-chaîne P2311 à l'indice
%d\n", k);
k = codePermanent.indexOf("777");
if (k == -1)
System.out.printf("On ne trouve pas la sous-chaîne 777 et
l'indice vaut %d\n", k);
} // fin de main
} // fin de Ex1String
/*
--------------------Configuration: <Default>-------------------Le marqueur pour indices: 012345678901234567890123456789
La chaîne telle quelle : TREP23119006
La chaîne en MAJUSCULEs : TREP23119006
La chaîne en minuscules : trep23119006
La longueur : 12 caractères
Le caractère à l'indice 3 : P
La sous-chaîne codePermanent.substring(0, 3) vaut TRE
La sous-chaîne codePermanent.substring(8) vaut: 9006
L'année de naissance : 1990
On trouve la lettre R à l'indice 1
On ne trouve pas la lettre Z : indice vaut -1
On trouve la sous-chaîne P2311 à l'indice 3
On ne trouve pas la sous-chaîne 777 et l'indice vaut -1
Process completed.
*/
Exemple 2 : (voir l’exécution pour comprendre l’exemple.
Attention au changement de ligne sous Word) :
/* Fichier Ex2String : exemple sur les chaînes de
caractères
*/
public class Ex2String {
// méthode qui compte et retourne le nombre de voyelles
// dans une phrase déjà transformée en majuscules
static int nbVoy(String phrase)
{
int n = 0;
for(int i = 0; i < phrase.length();i++)
switch ( phrase.charAt(i))
{ case 'A' : case 'E' : case 'I' :
case 'O' : case 'U' : case 'Y' : n++;
}
return n;
}
// méthode qui compte et retourne le nombre de voyelles
// dans une phrase : une autre manière de travail
static int nb2Voy(String phrase)
{
int n = 0;
String voyelles = "AaEeIiOoUuYy";
for(int i = 0; i < phrase.length();i++)
if ( voyelles.indexOf( phrase.charAt(i)) >= 0)
n++;
return n;
}
public static void main(String[] args) {
String ch = "Bonjour tout le monde!";
System.out.printf("Le marqueur pour indices:
012345678901234567890123456789\n");
System.out.printf("La chaîne telle quelle : %s\n", ch);
System.out.printf("La chaîne en MAJUSCULEs : %s\n",
ch.toUpperCase());
System.out.printf("La chaîne en minuscules : %s\n",
ch.toLowerCase());
System.out.printf("La longueur : %d caractères\n\n",
ch.length());
System.out.printf("Le caractère à l'indice 3 : %c\n",
ch.charAt(3));
System.out.printf("La sous-chaîne ch.substring(0, 3) vaut %s\n",
ch.substring(0, 3));
System.out.printf("La sous-chaîne ch.substring(8) vaut: %s\n",
ch.substring(8));
System.out.printf("Le nombre de voyelles : %d\n",
nbVoy(ch.toUpperCase()));
System.out.printf("Le nombre de voyelles (solution 2): %d\n\n",
nb2Voy(ch));
System.out.printf("La recherche d'un caractère dans la chaîne :
%d\n", ch.indexOf('j'));
System.out.printf("La recherche d'un caractère dans la chaîne :
%d\n\n", ch.indexOf('w'));
System.out.printf("La recherche de la sous chaîne mon: %d\n",
ch.indexOf("mon"));
System.out.printf("La recherche de tremblay: %d\n\n",
ch.indexOf("tremblay"));
}
}
/*
-------------------Configuration: <Default>-------------------Le marqueur pour indices: 012345678901234567890123456789
La chaîne telle quelle : Bonjour tout le monde!
La chaîne en MAJUSCULEs : BONJOUR TOUT LE MONDE!
La chaîne en minuscules : bonjour tout le monde!
La longueur : 22 caractères
Le
La
La
Le
Le
caractère à l'indice 3 : j
sous-chaîne ch.substring(0, 3) vaut Bon
sous-chaîne ch.substring(8) vaut: tout le monde!
nombre de voyelles : 8
nombre de voyelles (solution 2): 8
La recherche d'un caractère dans la chaîne : 3
La recherche d'un caractère dans la chaîne : -1
La recherche de mon: 16
La recherche de tremblay: -1
Process completed.
*/
Exemple 3 : (voir l’exécution pour comprendre l’exemple.
Attention au changement de ligne sous Word) :
public class Ex3String {
// affichier EXPLICITEMENT le nom du mois de naissance
static void afficherMois(String leMois)
{
String[] mois = { "Janvier", "Fevrier", "Mars", "Avril",
"Mai", "Juin", "Juillet", "Aout",
"Septembre", "Octobre", "Novembre", "Decembre" };
int rangMois = Integer.parseInt(leMois) % 50 -1;
System.out.printf("Né(e) au mois de %s\n", mois[rangMois]);
}
public static void main(String[] args) {
String nomPre = "Leblanc Nicole",
codePerm = "LEBN27539005"; // code permanent
System.out.printf("Nom et prenom :\n");
System.out.printf("
- tel quel
:%s\n", nomPre);
System.out.printf("
- en majuscules
:%s\n", nomPre.toUpperCase());
System.out.printf("
- en minuscules
:%s\n\n", nomPre.toLowerCase());
// Integer.parseInt("75"), par exemple, return 75
int anneeNais = 1900 + Integer.parseInt( codePerm.substring(8, 10));
System.out.printf("L'annee de naissance : %d\n", anneeNais);
// opérateur conditionnel
String sexe = codePerm.charAt(6) >= '5' ? "feminin" : "masculin";
System.out.printf("Le sexe %s\n", sexe);
afficherMois(codePerm.substring(6,8));
}
}
/* Compilation et Exécution:
--------------------Configuration: <Default>-------------------Nom et prenom :
- tel quel
:Leblanc Nicole
- en majuscules
:LEBLANC NICOLE
- en minuscules
:leblanc nicole
L'annee de naissance : 1990
Le sexe feminin
Né(e) au mois de Mars
Process completed.
*/
Exemple 4 : (voir l’exécution pour comprendre l’exemple.
Attention au changement de ligne sous Word) :
/* Fichier Telephone.java
* expliqué en classe
*
* Utile pour le numéro C du TP3 et pour une question au final
*/
public class Telephone {
// Cette fonction affiche les chiffres impairs dans un numéro de tél.
static void afficherImpairs(String telephone, String nom)
{
System.out.printf("Les chiffres impairs dans %10s : ",nom);
for(char c = '1' ; c <= '9'; c+=2)
if (telephone.indexOf(c) >= 0)
System.out.printf("%c ", c);
System.out.printf("\n");
}
static char maxi(String telephone)
{
char plusGrandChif = '0' ;
for(int i = 0; i < telephone.length(); i++)
if (telephone.charAt(i) > plusGrandChif)
plusGrandChif = telephone.charAt(i);
return plusGrandChif;
}
public static void main(String[] args) {
String telUDM = "5143436111", telJean = "4501234567";
afficherImpairs(telUDM, "telUDM");
afficherImpairs(telJean, "telJean");
System.out.printf("Le chiffre le plus grand dans le numero %s
est %c\n", telUDM, maxi(telUDM));
System.out.printf("Le chiffre le plus grand dans le numero %s
est %c\n", telJean, maxi(telJean));
//System.out.printf("Bienvenue au Java et à la POO\n");
}
}
/* Exécution :
--------------------Configuration: <Default>-------------------Les chiffres impairs dans
telUDM : 1 3 5
Les chiffres impairs dans
telJean : 1 3 5 7
Le chiffre le plus grand dans le numero 5143436111 est 6
Le chiffre le plus grand dans le numero 4501234567 est 7
Process completed.
*/
Dans le cours on introduit à la programmation orientée
objet (POO) utilisant le langage JAVA sans aller dans les
détails.
Dans notre vie quotidienne, on travaille très souvent avec
des objets :
Un tableau est un objet.
On peut fabriquer (construire, instancier) un tableau par
plusieurs manières :
- Fabriquer un tableau de couleur noir, en bois,
de largeur 3.25 mètre, de hauteur 1.50 mètre
- Fabriquer un tableau de couleur blanche, en plastique
dur, de largeur 2.75 mètre, de hauteur 2.15 mètre
- etc . . .
Il faut que le tableau existe avant de parler comment
travailler avec un tableau.
Que peut-on faire avec un tableau ?
- écrire au tableau
- laver le tableau
- effacer le tableau
- etc …
La POO est une nouvelle méthode de programmation basant sur
trois concepts :
L’encapsulation :
Fusionner les champs de données (les attributs) et les
méthodes pour manipuler ces données dans la même capsule
qui s’appelle une classe. On ajoute aussi des clauses
d’accès : champs souvent privés, méthodes souvent
publiques.
Pour IFT 1810, on travaille seulement à ce concept.
L’héritage :
Construire de nouvelles classes étendues de classes
existences qui hérite de données et de méthodes de
celles-ci. De plus on peut ajouter de nouveaux champs, de
nouvelles méthodes. On étudiera ce concept dans les cours
après IFT 1810 (comme IFT 1170, IFT 1166, etc . . .).
Le polymorphisme :
La capacité de se présenter sous plusieurs formes.
Ce concept sera présenté dans les cours suivants de
IFT 1810 .
Dans le document Java_02.doc on a étudié la classe String
et plusieurs de ses méthodes. Dans ce document, on apprend
comment concevoir une classe et manipuler ses objets.
Ce document est utile pour le numéro C du TP3 ainsi pour
quelques questions du final.
Exemple 1 :
Concevoir la classe Cercle. Instancier (construire)
quelques cercles puis afficher leurs informations.
On explique en classe cet exemple.
Solution (attention au saut de ligne sous Word)
/* Fichier Ex1_Cercle
* expliqué en classe
* Voir aussi Ex2_Cercle
*/
class Cercle
{
// privé => accessible SEULEMENT dans la classe Cercle
private double rayon ;
// un constructeur pour construire (instancier) 1 cercle
public Cercle(double r)
{
rayon = r ;
}
// un autre constructeur pour construire (instancier) 1
// cercle
public Cercle()
{
rayon = 1.3; // par défaut
}
// Math.PI : le champ "static" PI de la classe Math(ématique)
public double perimetre()
{
// 2 x PI x rayon
return 2 * Math.PI * rayon;
}
// PI x (rayon au carré)
public double surface()
{
return Math.PI * rayon * rayon;
}
public void afficher(String message)
{
// exemple : Infos du cercle ... :
System.out.printf("Infos du %s\n",
System.out.printf(" - rayon
:
System.out.printf(" - périmètre :
System.out.printf(" - surface
:
}
rayon, perimetre puis surface
message);
%6.2f\n", rayon);
%6.2f\n", perimetre());
%6.2f\n\n", surface());
} // fin de classe Cercle
public class Ex1_Cercle {
public static void main(String[] args) {
Cercle c1 = new Cercle(5.7),
c2 = new Cercle() , // par défaut 1.3
c3 = new Cercle(6.1);
// forme d'accès #1 :
c1.afficher("cercle c1");
c2.afficher("deuxième cercle");
c3.afficher("cercle c3");
} // fin de main
}// fin de Ex1_Cercle
/* Compilation et Exécution:
--------------------Configuration: <Default>--------------Infos du cercle c1
- rayon
:
5,70
- périmètre : 35,81
- surface
: 102,07
Infos du deuxième cercle
- rayon
- périmètre
- surface
:
:
:
1,30
8,17
5,31
Infos du cercle c3
- rayon
:
6,10
- périmètre : 38,33
- surface
: 116,90
Process completed.
*/
Explications :
private double rayon ;
rayon est le seul champ d’information de la classe Cercle.
L’accès est privé : dans la classe Cercle, on a le droit
d’accéder au champ rayon. En dehors de la classe Cercle, on
n’a pas le droit d’accéder au champ rayon.
Très souvent, surtout pour IFT 1810, l’accès à un champ
d’information est privé.
Constructeur :
C’est une méthode de la classe permettant de construire
(instancier, fabriquer) un objet de la classe. Cette
méthode porte le même nom de la classe. Son but est de
déterminer les champs d’informations.
Une classe peut avoir, aucune, une ou quelques
constructeurs.
L’instruction :
Cercle c1 = new Cercle(5.7) ;
permet d’appeler le constructeur à 1 seul paramètre afin d’instancier
l’objet c1 de la classe Cercle ayant le rayon 5.7
L’instruction :
c2 = new Cercle(); // par défaut 1.3
permet d’appeler le constructeur à aucun paramètre afin d’instancier
l’objet c2 de la classe Cercle ayant le rayon 1.3 par défaut.
Les méthodes perimetre, surface et afficher sont des méthodes
permettant d’appliquer sur un objet de la classe Cercle.
Dans main, on peut afficher le périmètre du cercle c1 :
System.out.printf("Le périmètre du cercle c1 : %.2f\n",
c1.perimetre());
L’accès c1.perimetre() fonctionne car la méthode perimetre() est
publique. C’est la même chose pour la méthode publique surface :
System.out.printf("La surface du cercle c2 : %.2f\n",
c2.surface());
On expliquera en détails en classe.
Par contre, l’affichage suivante dans main :
System.out.printf("Le rayon du cercle c1 : %.2f\n",
c1.rayon);
est invalide car le champ rayon est privé : on n’a pas le droit
d’accéder à ce champ en dehors de la classe Cercle.
Méthode d’accès :
Pour afficher, par exemple, le rayon du cercle c1, on
peut écrire d’abord la méthode d’accès dans la classe Cercle :
public double getRayon()
{
return rayon;
}
Dans main, par exemple, on peut afficher le rayon du cercle
c1 comme suit :
System.out.printf("Le rayon du cercle c1 : %.2f\n",
c1.getRayon());
Soit la classe Etudiant avec le champ codepermanent . . . :
class Etudiant
{ private codePerm; // exemple "LAFL12549007"
// née le 12 avril 1990
etc . . .
public char getSexe()
{
if ( codeperm.charAt(6) >= ‘5’)
Return ‘F’;
else return ‘M’;
}
etc . . .
}
Dans ce cas-ci, on accède à une partie du champ codePerm :
le sexe de l’étudiant.
Méthode de modification :
Pour doubler le rayon du cercle c2, l’instruction suivante dans main :
c2.rayon *= 2;
est invalide car le champ rayon est privé.
Dans un tel cas, il suffit d’ajouter la méthode de modification
suivante à la classe Cercle :
public void setRayon( double nouvRayon )
{
Rayon = nouveauRayon;
}
Ainsi, pour double le rayon du cercle c2, ont peut écrire dans main :
c2.setRayon ( 2 * c2.getRayon() );
Pour ajouter 1.2 au rayon du cercle c1 :
c1.setRayon(c1.getRayon() + 1.2);
Exemple 2 :
Attention au saut de ligne en Word
/* Fichier Ex2_Cercle.java
* class Cercle avec constructeurs et quelques méthodes
* Exemple d'un tableau des cercles, méthodes
* d'accès et de modification. Le tri du tableau
* des cercles.
*
*
*/
class Cercle
{
// champ privé : rayon
private double rayon;
// un constructeur
public Cercle(double r)
{
rayon = r;
}
// un autre constructeur
public Cercle()
{
rayon = 12.345; // par
}
défaut
// calcul du périmètre d'un cercle
public double perimetre()
{
return 2 * Math.PI * rayon;
}
// calcul de la surface d'un cercle
public double surface()
{
return Math.PI * rayon * rayon;
}
// afficher les informations d'un cercle
public void afficher(String message)
{
System.out.printf("%s : %7.1f %10.2f %8.2f\n",
message, rayon, perimetre(), surface());
}
// méthode d'accès
public double getRayon()
{
return rayon;
}
// méthode de modification
public void setRayon(double nouvRayon)
{
rayon = nouvRayon;
}
}
public class Ex2_Cercle {
// afficher le contenu du tableau des cercles
static void afficher(Cercle[] cer, int nbCercles, String message)
{
System.out.printf("\n\nContenu du tableau de %d cercles %s :\n",
nbCercles, message);
System.out.printf(" Rayon Périmètre
Surface\n");
for ( int i = 0 ; i < nbCercles; i++)
System.out.printf("%6.2f %8.2f %10.2f\n", cer[i].getRayon(),
cer[i].perimetre(),cer[i].surface());
System.out.printf("\n\n");
}
// une manière de trier un tableau des cercles
// (tri par sélection vu avant l'intra)
static void trier(Cercle[] cer, int nbCercles)
{
for (int i = 0; i < nbCercles-1; i++)
{ int indMin = i;
for (int j = i+1; j < nbCercles; j++)
if ( cer[j].getRayon() < cer[indMin].getRayon() )
indMin = j;
if (indMin != i)
{
double tempo = cer[i].getRayon();
cer[i].setRayon ( cer[indMin].getRayon());
cer[indMin].setRayon(tempo);
}
}
}
// déterminer puis afficher le cercle ayant le rayon le plus grand
static void chercherPlusGrandRayon(Cercle[] cer, int nbCercles)
{
int indMax = 0 ;
for(int i = 1 ; i < nbCercles; i++)
if ( cer[i].getRayon() > cer[indMax].getRayon())
indMax = i;
cer[indMax].afficher("Cercle ayant le rayon le plus grand");
}
public static void main(String[] args) {
// instancier 3 cercles
Cercle c1 = new Cercle(5.3),
c2 = new Cercle(1.7), c3 = new Cercle();
c3.afficher("Infos du cercle c3");
System.out.printf("Le perimetre du cercle c2 : %.2f\n\n",
c2.perimetre());
System.out.printf("La surface du cercle c1 : %.2f\n\n",
c1.surface());
// exemple d'un petit tableau des cercles :
Cercle[] cer = { new Cercle(5.3), new Cercle(4.7),
new Cercle(), new Cercle(10.4),
new Cercle(5.2) } ;
int nbCercles = cer.length;
cer[1].afficher("Infos de cer[1] ");
// doubler le rayon du 2ième cercle
cer[1].setRayon( 2 * cer[1].getRayon());
cer[1].afficher("Infos de cer[1] après avoir doublé son rayon
");
// forme 2 : Classe.méthode "static"
Ex2_Cercle.afficher(cer, nbCercles, "avant le tri") ;
// Ex2_Cercle. est optionnel
// quel est le cercle ayant le plus grand rayon
chercherPlusGrandRayon(cer, nbCercles);
trier(cer, nbCercles);
afficher(cer, nbCercles, "apres le tri selon les rayons") ;
}
}
/* Compilation et Exécution:
--------------------Configuration: <Default>-------------------Infos du cercle c3 :
12,3
77,57
478,78
Le perimetre du cercle c2 : 10,68
La surface du cercle c1 : 88,25
Infos de cer[1] :
4,7
29,53
69,40
Infos de cer[1] après avoir doublé son rayon :
277,59
9,4
59,06
Contenu du tableau de 5 cercles avant le tri :
Rayon Périmètre
Surface
5,30
33,30
88,25
9,40
59,06
277,59
12,35
77,57
478,78
10,40
65,35
339,79
5,20
32,67
84,95
Cercle ayant le rayon le plus grand :
12,3
77,57
478,78
Contenu du tableau de 5 cercles apres le tri selon les rayons :
Rayon Périmètre
Surface
5,20
32,67
84,95
5,30
33,30
88,25
9,40
59,06
277,59
10,40
65,35
339,79
12,35
77,57
478,78
Process completed.
*/
Trois formes d’accès en Java :
4. forme 1 (très fréquence) :
objet.méthode (……..)
Appliquer une méthode sur l’objet
Exemples :
"Bonsoir".length() retourne 7 (longueur de la chaîne)
"Bonsoir".charAt(0) retourne ‘B’ (le caractère à
l’indice 0 est la lettre ‘B’)
"Bonsoir".indexOf(‘n’) retourne 2 (on trouve la lettre ‘n’ à
l’indice 2
"Bonsoir".substring(1, 3) retourne "on" (la sous-chaîne
délimitée entre l’indice 1 inclus et
l’indice 3 exclu)
5. forme 2 (assez fréquence) :
classe.méthode static(……..)
Utiliser une méthode static d’une classe
Exemples :
Integer.parseInt("17") retourne 17 (valeur entière)
Math.sqrt(16.0) retourne la racine carrée de 16.0 qui vaut 4.0
6. forme 3 (peu fréquence) :
classe.champ static
Accès à un champ (attribut) static d’une classe
Exemples :
Math.PI vaut 3.14159… (valeur PI de la classe Math)
Integer.MAX_VALUE retourne 231-1 (l’entier le plus grand)
Les points 1. et 2. s’adressent à ceux qui veulent procéder au téléchargement et à l’installation de
JCreator, si vous voulez travaillez chez vous sur le même environnement que celui de la DESI.
1. Téléchargement
Veuillez procéder comme suit :
I.
l’adresse de xinox software : http://jcreator.com/download.htm
II.
l’IDE JCreator LE
III.
la JDK (Kit de développement Java)
Ce qui va vous ramenez sur la page suivante dans laquelle vous devez procéder par III.2 et III.3 : (si votre
machine tourne sur lunix ou vista III.3 ne s’applique pas, voir un peu plus bas de la page, pour sélectionner
le système approprié).
2. Installation
A cette étape vous disposez de deux fichiers :
- jdk-6u3-windows-i586-p.exe (JDK)
- jcrea450_setup.exe (JCreator)
2.a. Installation de JDK
Notez bien le chemin : vous devez le mentionner dans l’installation de JCreator
2.b. Installation de JCreator
Lancez jcrea450_setup.exe est suivez les instructions, jusqu’à avoir la fenêtre suivante, où, pour JDK
Home Directory, vous devez indiquer le chemin noté dans la précédente étape (1.a)
3. Notre Premier pas en JAVA
Si tout s’est bien passé, vous devrez avoir JCreator LE accessible à partir du menu
3.a. Lancez
JCreator LE,
Remarque 1 : si vous avez raté l’indication du chemin de JDK dans l’étape (1.b), vous pouvez toujours le
faire à partir du menu Configure comme suit ;
Remarque 2 : Typiquement, on travaille avec une collection de fichiers (.java) ce qu’on appelle un projet.
Cependant en IFT1810, on va se contenter de travailler avec un fichier à la fois pour le moment.
Remarque 3 : Le processus est le même que pour d’autres langages (compilation, exécution).
3.b. Mon premier PAS en JAVA,
1.
2.
3.
choisir FILE > New > File, et nommez votre fichier Allure.java ;
Sélectionnez Java Classes puis Main Class comme type de fichier
Entrez le code suivant ;
4.
5.
6.
7.
public class Allure {
public static void main(String[] args) {
System.out.println ("Bienvenue à JAVA");
}
}
Cliquez sur Build > Compile File
Cliquez sur Build > Execute File
Remarquez la fenêtre d’exécution General Output affiche "Bienvenue à JAVA".
Compléter l’entête et les commentaires
/*
+++++++++++++++++++++++++++++++++++++++++++++++++++++ +
+ IFT 1810 CD, automne 2007, TP # x
+
+++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Auteur(s) :
, section C +
+
, section D +
+++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Ce programme permet de :
+
+ . . .
+
+++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Dernière mise à jour : jeudi le xx Novembre 2007 +
+++++++++++++++++++++++++++++++++++++++++++++++++++++++
*/
public class Allure {
// mon code commence ici…
public static void main(String[] args) {
System.out.println ("Bienvenue à JAVA");
}
}
/* Exécution
Bienvenue à JAVA
*/