Introduction à la Programmation
LANGAGE JAVA
Semestre 5 – LUS IWFS
2024-2025
Premier Programme
package [Link];
public class test {
public static void main(String[] args) {
[Link](« Bonjour a tous !");
}
}
Exécution en ligne de commande : java [Link]
Les variables et les opérateurs
Les variables de type numérique
- Le type byte (1 octet) peut contenir les entiers entre -128 et +127.
byte temperature;
temperature = 64;
- Le type short (2 octets) contient les entiers compris entre -32768 et +32767.
short vitesseMax;
vitesseMax = 32000;
- Le type int (4 octets) va de -2 × 109 à 2 × 109 (2 et 9 zéros derrière. . . ce qui fait déjà un joli nombre).
int temperatureSoleil;
temperatureSoleil = 15600000;
Les variables et les opérateurs (suite)
- Le type long (8 octets) peut aller de -9 × 1018 à 9 × 1018 (encore plus gros. . .).
long anneeLumiere;
anneeLumiere = 9460700000000000;
- Le type float (4 octets) est utilisé pour les nombres avec une virgule flottante.
float pi;
pi = 3.141592653f;
- Le type double (8 octets) est identique à float, si ce n'est qu'il contient plus de chiffres derrière la virgule et
qu'il n'a pas de suffixe.
double division;
division = 0.333333333333333333333333333333333333333333334;
Les variables et les opérateurs (suite)
variables stockant un caractère
- Le type char contient UN caractère stocké entre apostrophes ( ' '), comme ceci :
char caractere;
caractere = 'A';
- type booléen : Le type boolean, lui, ne peut contenir que deux valeurs : true (vrai) ou false (faux), sans guillemets.
boolean question;
question = true;
- le type String
Le type String permet de gérer les chaînes de caractères, c'est-à-dire le stockage de texte. Il s'agit d'une variable d'un
type plus complexe que l'on appelle objet. Vous verrez que celle-ci s'utilise un peu différemment des variables
précédentes :
String phrase;
phrase = « Bonjour a tous";
//Deuxième méthode de déclaration de type String
String str = new String();
str = "Une autre chaîne de caractères";
//La troisième
String string = "Une autre chaîne";
//Et une quatrième
String chaine = new String("Et une de plus !");
Les opérateurs arithmétiques
Ce sont ceux que l'on apprend à l'école primaire.
+ : permet d'additionner deux variables numériques (mais aussi de
concaténer des chaînes de caractères ! Ne vous inquiétez pas, on
aura l'occasion d'y revenir). Quelques exemples de calcul
int nbre1, nbre2, nbre3; //déclaration des variables
- : permet de soustraire deux variables numériques. nbre1 = 1 + 3; //nbre1 vaut 4
nbre2 = 2 * 6; //nbre2 vaut 12
nbre3 = nbre2 / nbre1; //nbre3 vaut 3
* : permet de multiplier deux variables numériques.
nbre1 = 5 % 2; //nbre1 vaut 1, car 5 = 2 * 2 + 1
nbre2 = 99 % 8; //nbre2 vaut 3, car 99 = 8 * 12 + 3
/ : permet de diviser deux variables numériques. nbre3 = 6 % 3; //là, nbre3 vaut 0, car il n'y a pas de reste
% : permet de renvoyer le reste de la division entière de deux
variables de type numérique ; cet opérateur s'appelle le modulo.
Les conversions, ou cast
D'un type int en type float :
int i = 123;
Ce type de conversion s'appelle une conversion
float j = (float)i;
d'ajustement, ou cast de variable.
D'un type int en double :
int i = 123;
double j = (double)i;
Et inversement :
double i = 1.23;
double j = 2.9999999;
int k = (int)i; //k vaut 1
k = (int)j; //k vaut 2
il est aussi possible de caster le résultat d'une opération mathématique en la mettant entre () et en
la précédant du type de cast souhaité. Donc :
double nbre1 = 10, nbre2 = 3;
int resultat = (int)(nbre1 / nbre2);
[Link]("Le résultat est = " + resultat);
Les conversions, ou cast (suite)
Transformer int en String
int i = 12;
String j = new String();
j = [Link](i); // j est donc une variable de type String contenant la chaîne de caractères 12
Transformer String en int
int i = 12;
String j = new String();
j = [Link](i);
int k = [Link](j).intValue(); // Maintenant, la variable k de type int contient le nombre 12.
Lire les entrées clavier
Pour lire au clavier, nous allons utiliser l'entrée standard [Link]. Donc, avant d'indiquer à Java qu'il faut lire ce
que nous allons taper au clavier
- nous devrons instancier un objet Scanner. Scanner sc = new Scanner([Link]);
Il ne faut oublier de faire un import : import [Link];
Récupérer ce que vous tapez au clavier :
Scanner sc = new Scanner([Link]);
[Link]("Veuillez saisir un mot :");
String str = [Link]();
[Link]("Vous avez saisi : " + str);
Vous savez maintenant que pour lire un int, vous devez utiliser nextInt(). De façon générale, dites-vous que pour
récupérer un type de variable, il vous sut d'appeler next<Type de variable>.
Scanner sc = new Scanner([Link]);
int i = [Link]();
double d = [Link]();
long l = [Link]();
byte b = [Link](); //Etc.
exercices
• Exemple n°1: Ecrire un programme qui calcule la somme de deux entiers et affiche le résultat.
• Exemple n°2: Ecrire un programme qui calcule la surface et le périmètre du rectangle, puis affiche
le résultat.
périmètre = (largeur + longueur)*2 et surface = largeur * longueur
• Exemple n°3: Ecrire un programme qui demande un temps T (entier) exprimé en secondes et qui
le convertit en heures, minutes et secondes.
Les conditions
La structure if... else
Les opérateurs logiques :
== : permet de tester l'égalité.
!= : permet de tester l'inégalité.
< : strictement inférieur.
<= : inférieur ou égal.
> : strictement supérieur.
>= : supérieur ou égal.
&&: l'opérateur et. Il permet de préciser une condition.
|| : le ou. Même combat que le précédent.
? : : l'opérateur ternaire.
Les conditions (suite)
La structure de ces conditions ressemble
if (//condition)
{
... //Exécution des instructions si la condition est remplie
}
else
{
... //Exécution des instructions si la condition n'est pas remplie
}
int i = 10;
if (i < 0)
[Link]("le nombre est négatif");
else
[Link]("le nombre est positif");
if (i < 0)
[Link]("Ce nombre est négatif !");
else if(i > 0)
[Link]("Ce nombre est positif !");
else
[Link]("Ce nombre est nul !");
• Exercice n°1 : Ecrire un algorithme qui demande deux nombres à l’utilisateur et
l’informe ensuite si le produit est négatif ou positif (on inclut le traitement du cas
où le produit peut être nul).
• Exercice n°2 : Écrire un algorithme qui affiche si un nombre entier saisi au clavier
est pair ou impair
• Exercice n°3 : Écrire un programme C qui demande à l'utilisateur de saisir un
nombre, puis vérifie si le nombre est un multiple de 5. Affichez un message
approprié en fonction du résultat.
• Exercice n°4 : Écrire un programme C qui demande à l'utilisateur de saisir sa taille
(en mètres) et son poids (en kilogrammes), puis calcule l'IMC (Indice de Masse
Corporelle) en utilisant la formule IMC = poids / (taille * taille). Ensuite, affichez la
catégorie d'IMC correspondante (p. ex., "Sous-poids", "Poids normal", "Surpoids",
etc.).
• Nb : poids normal est entre 18,5 à 24,9
Switch Case
int nb = 5;
switch(nb) {
case 1:
[Link]("lundi");
break;
case 2:
[Link]("mardi");
break;
case 3: case 6:
[Link]("mercredi"); [Link]("samedi");
break; break;
case 4: case 7:
[Link]("jeudi"); [Link]("dimanche");
break; break;
case 5: default:
[Link]("vendredi");
[Link]("nombre incorrect");
break;
}
}
Les boucles
• La boucle while
while (/* Condition */)
{
//Instructions à répéter
}
do{ do... while s'exécutera au moins une fois
//Instructions à répéter Il y a un « ; » après le while
} while (/* Condition */);
for (int i = 1; i <= 10; i++) - déclaration d'une variable avant la boucle ;
{ - initialisation de cette variable ;
//Instructions à répéter - incrémentation de celle-ci dans la boucle
}
Exercice 1 : Ecrire un algorithme permettant d'afficher la saison selon le numéro du mois saisi au clavier.
• En décembre, en janvier, en février, c’est l’hiver. /En mars, en avril, en mai, c’est le printemps.
• En juin, en juillet, en août, c’est l’été.
• En septembre, en octobre, en novembre, c’est l’automne.
Exercice 2 : Ecrire un algorithme/programme calculatrice permettant la saisie de deux entiers a et b et aussi la saisie un
caractère ( '+' , '–' , '*' ou '/') qui spécifie l'opération entre a et b. sans oublier d'afficher le résultat.
• Exercice n°5 : Écrire un programme C qui demande à l'utilisateur de saisir un numéro de jour de la semaine
(par exemple, 1 pour "Lundi", 2 pour "Mardi", etc.), puis affichez le nom du jour correspondant.
• Exercice n°6 : Écrire un programme C qui demande à l'utilisateur de saisir un entier positif n, puis calcule et
affiche la factorielle de n (n!).
• Exercice n°7 : Écrivez un programme C qui demande à l'utilisateur de saisir les longueurs de trois côtés d'un
triangle, puis vérifie si ces longueurs forment un triangle valide en utilisant l'inégalité triangulaire. Affichez un
message approprié en fonction du résultat.
• L'inégalité triangulaire est un principe fondamental en géométrie qui énonce que la somme de la longueur de
deux côtés d'un triangle est toujours supérieure ou égale à la longueur du troisième côté
Tableau à une dimension
<type du tableau> <nom du tableau> [] = { <contenu du tableau>};
exemple de declaration de tableau :
int tableauEntier[] = {0,1,2,3,4,5,6,7,8,9};
double tableauDouble[] = {0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0};
char tableauCaractere[] = {'a','b','c','d','e','f','g'};
String tableauChaine[] = {"chaine1", "chaine2", "chaine3" , "chaine4"};
int tableauEntier[] = new int[6]; Vous pouvez aussi déclarer un tableau vide, mais celui-ci devra
//Ou encore impérativement contenir un nombre de cases bien défini
int[] tableauEntier2 = new int[6];
Les tableaux
Exercice n°1: Ecrire un programme qui saisi les valeurs d'un tableau de 6 réels, puis les affiche dans l'ordre inverse
Exercice n°2: Ecrire un programme qui saisi les valeurs d'un tableau de 6 réels, puis affiche la moyenne de ces
valeurs.
Exercice n°3: Ecrire un programme qui saisi les valeurs d'un tableau de 6 réels, puis affiche le minimum/maximum
de ces valeurs.
Exercice n°4: Ecrire un programme permettant, à l’utilisateur de saisir 30 notes d'une classe. Une fois la saisie
terminée, programme renvoie le nombre des notes supérieures à 10.
Exercice n°5: Ecrire un programme permettant, à l’utilisateur de saisir 30 notes d'une classe. Une fois la saisie
terminée, le programme renvoie le nombre des notes supérieures à la moyenne de la classe.
Exercice n°6 : Ecrire un programme qui permet à l’utilisateur de saisir 20 notes d'une classe. Une fois la saisie
terminée, programme affiche la plus grande valeur et l'indice de sa position dans le tableau.
Exercice n°7 : Ecrire un programme qui permet d'inverser un tableau A de 9 entiers dans un autre tableau B.
Exercice n°8 : Ecrire un programme qui permet d'inverser un tableau A de 9 entiers dans le même tableau
Les tableaux multidimensionnels
int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} };
int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} };
for(int i = 0; i < 2; i++)
{ Résultat
for(int j = 0; j < 5; j++) 02468
{ 13579
[Link](premiersNombres[i][j]);
}
[Link]("");
}
Les méthodes de classe
Des méthodes concernant les chaînes de caractères
toLowerCase() pour le texte en minuscule
String chaine = new String("BONJOUR TOUT LE MONDE !"), chaine2 = new String();
chaine2 = [Link](); //Donne « Bonjour tout le monde !"
[Link](chaine2);
toUpperCase() pour le texte en majuscule
length() : Celle-ci renvoie la longueur d'une chaîne de caractères (en comptant les espaces).
String chaine = new String("coucou ! ");
int longueur = 0;
longueur = [Link](); //Renvoie 9
[Link](longueur);
equals(): Cette méthode permet de vérifier si deux chaînes de caractères sont identiques
String str1 = new String("coucou"), str2 = new String("toutou");
if ([Link](str2))
[Link]("Les deux chaînes sont identiques !");
else
[Link]("Les deux chaînes sont différentes !");
charAt() : Le résultat de cette méthode sera un caractère : il s'agit d'une méthode d'extraction de caractère
String nbre = new String("1234567");
char carac = [Link](4); //Renverra ici le caractère 5
substring() :
Cette méthode extrait une partie d'une chaîne de caractères. Elle prend deux entiers en arguments : le premier
définit le premier caractère (inclus) de la sous-chaîne à extraire, le second correspond au dernier caractère
(exclu) à extraire. Là encore, le premier caractère porte le numéro 0
String chaine = new String("Bonjour licence iwfs"), chaine2 = new String();
chaine2 = [Link](8,20); //Permet d'extraire "licence iwfs"
[Link](chaine2);
indexOf() / lastIndexOf() : String mot = new
indexOf() explore une chaîne de caractères à la recherche d'une suite String("anticonstitutionnellement");
donnée de caractères, et renvoie la position (ou l'index) de la sous- int n = 0;
chaîne passée en argument. n = [Link]('t'); //n vaut 2
indexOf() explore à partir du début de la chaîne, lastIndexOf() explore n = [Link]('t'); //n vaut 24
en partant de la fin, mais renvoie l'index à partir du début de la chaîne
n = [Link]("ti"); //n vaut 2
n = [Link]("ti"); //n vaut 12
n = [Link]('x'); //n vaut -1
Des méthodes concernant les mathématiques
double X = 0.0;
X = [Link]();
//Retourne un nombre aléatoire
//compris entre 0 et 1, comme 0.0001385746329371058
double sin = [Link](120); //La fonction sinus
double cos = [Link](120); //La fonction cosinus
double tan = [Link](120); //La fonction tangente
double abs = [Link](-120.25); //La fonction valeur absolue (retourne le nombre sans le signe)
double d = 2;
double exp = [Link](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
Créer sa propre méthode
Méthode arrondi : Cette méthode arrondi permet d'arrondir un nombre décimal A à un certain
nombre de décimales B
public class test {
public static void main(String[] args) {
int b = 2;
double a = 2.4649432, ar;
ar = arrondi(a, b);
[Link](ar);
}
public static double arrondi(double A, int B) {
return (double) ( (int) (A * [Link](10, B) + .5)) / [Link](10, B);
}
}
Créer sa propre méthode
• Créer une methode qui parcours un tableau
public class test {
public static void main(String[] args) {
String[] tab = {"toto", "tata", "titi", "tete"};
parcourirTableau(tab);
}
static void parcourirTableau(String[] tabBis)
{
for(String str : tabBis)
[Link](str);
}
}
**********************
Résultat
toto
tata
titi
tete
La surcharge de méthode
la surcharge de méthode consiste à garder le nom d'une méthode (donc un type de traitement à faire : pour nous,
lister un tableau) et à changer la liste ou le type de ses paramètres.
Dans le cas qui nous intéresse, nous voulons que notre méthode parcourirTableau
public class test {
public static void main(String[] args) {
String[] tab = {"toto", "tata", "titi", "tete"};
int[] tab2 = {1,2,3,4,5};
parcourirTableau(tab);
parcourirTableau(tab2); Resultats :
*****************
} toto
static void parcourirTableau(String[] tab) tata
{
for(String str : tab)
titi
[Link](str); tete
} 1
static void parcourirTableau(int[] tab) 2
{ 3
for(int str : tab)
[Link](str); 4
}} 5
// utilisation de la meme methode pour parcourir deux tableaux de types differents (String et int)
exercices
Exercices sans paramètres :
• Affichage d'un message : Écrivez une fonction appelée afficheMessage qui affiche un message de salutation.
• Calcul de la somme : Écrivez une fonction appelée somme qui affiche la somme des nombres de 1 à 10.
• Table de multiplication : Créez une fonction nommée tableMultiplication qui affiche la table de multiplication pour
un nombre donné (par exemple, 5).
• Affichage des nombres pairs : Écrivez une fonction appelée affichePairs qui affiche les nombres pairs de 2 à 20.
Exercices avec paramètres :
• Calcul de la puissance : Créez une fonction puissance qui prend deux paramètres (base et exposant) et renvoie le
résultat de la base élevée à la puissance de l'exposant.
• Calcul de la moyenne : Écrivez une fonction moyenne qui prend trois notes en paramètres et renvoie la moyenne
de ces notes.
• Conversion de température :Créez une fonction celsiusVersFahrenheit qui prend une température en degrés
Celsius en paramètre et renvoie la température équivalente en degrés Fahrenheit. Fahrenheit = (celsius * 9 / 5) + 32
• Vérification de nombre premier : Écrivez une fonction estPremier qui prend un nombre en paramètre et renvoie
vrai s'il est premier, faux sinon.
exercices
• Concaténation de chaînes : Créez une fonction concateneChaine qui prend deux chaînes en paramètres et
renvoie une nouvelle chaîne résultant de la concaténation des deux.
• Inversion d'une chaîne : Écrivez une fonction inverseChaine qui prend une chaîne en paramètre et renvoie
une nouvelle chaîne avec les caractères inversés.
• Calcul de factorielle : Créez une fonction factorielle qui prend un entier en paramètre et renvoie sa
factorielle.
• Calcul de la somme des éléments d'un tableau : Écrivez une fonction sommeTableau qui prend un tableau
d'entiers en paramètre et renvoie la somme de ses éléments.
• Ranger les zéros a la fin du tableau : Ecrire un fonction qui prend en paramètre un tableau T. et range le
tableau de façon à mettre les valeurs 0 à la fin.
• Ecrire un fonction qui remplit un tableau T de 100 entiers. Une autre fonction qui doit calculer la somme: S =
T[0] - T[1] + T[2] -T[3] + T[4] - T[5] + ... - T[99]
• Recherche de l'élément maximum dans un tableau : Créez une fonction maxTableau qui prend un tableau
d'entiers en paramètre et renvoie la valeur maximale.
• Conversion de devise : Écrivez une fonction conversionDevise qui prend un montant en dollars en paramètre
et renvoie l'équivalent en euros (taux de change fixe).