Accueil site Tableur Programmation Outils XML Téléchargement Informations



Algorithmique

Avec Java

L'essentiel 
 
Introduction
Initiation
  Généralités
  Première activité
  Calcul d'une racine carrée
  Exemple en géométrie
  Exemple avec Logo
Prolongement
  Symétrie centrale
  Parallélogramme
  Procédures avec Logo
  Récursivité avec Logo
Avec Algobox
  Fraction irréductible
  Fonction monotone
  Résolution d'équation 1
  Résolution d'équation 2
Avec Python
  Environnement
  Autres environnements
  L'essentiel
  Premier exemple
  Addition de fractions
  Cryptographie
  Statistiques / Probabilité
Avec Java
  Environnement
  L'essentiel
  Premier exemple
  Avec des classes
 
Commentaires
Il y a deux types de commentaires en Java.
  • Le premier est le commentaire traditionnel (issu du langage C). Ces commentaires commencent par /* et continuent, éventuellement sur plusieurs lignes, jusqu'à un */.
Exemple :
/* Ceci est un commentaire qui
continue sur plusieurs lignes */

  • Le deuxième vient du C++. C'est le commentaire sur une seule ligne qui commence avec // et continue jusqu'à la fin de la ligne.
Exemple :
// Ceci est un commentaire sur une seule ligne
Variables
Il y a deux types de variables :
  • des variables de type simple ou "primitif";
  • des variables de type objet.
Ce qu'on appelle en Java des types simples, ou types primitifs, ce sont des nombres entiers, des nombres réels, des booléens ou encore des caractères.
Quel que soit son type, il y a deux opérations à faire pour chaque variable : la déclaration et l'initialisation (on affecte une valeur). La déclaration se fait en précisant le type devant le nom (l'identificateur) de la variable. L'affectation se fait par le signe égal (=).
Exemple :
int a; // pour déclarer la variable a de type int (entier)
a = 10; // pour affecter la valeur 10 à la variable a

On peut également déclarer et initialiser une variable en une seule opération. Exemple : int a = 10.
Portée des variables
En Java, la portée est fixée par l'emplacement des accolades { }. Une variable définie dans une portée n'est accessible que jusqu'à la fin de cette portée.
Exemple :
{
   int x = 10;
   /* seul x est accessible */
       {
            int y = 20;
           /* les variables x et y sont toutes les deux accessibles */
        }
   /* seul x est accessible, y étant hors de portée */
}
Variables de type simple
Le type numérique
  • Le type byte (1 octet) peut contenir les entiers entre -128 et +127.
  • Le type short (2 octets) contient les entiers compris entre -32768 et +32767.
  • Le type int (4 octets) pour les entiers de -231 soit -2 147 483 648 à 231-1 soit 2 147 483 647
  • Le type long(8 octets) de -263 à 263-1
  • Le type float (4 octets) correspond à des nombres avec virgule flottante. Le séparateur décimal est le point et le symbole f derrière le nombre (par exemple : 4.2f) permet de préciser ce type..
  • Le type double (8 octets) est identique à float, si ce n'est que l'étendue et la précision des nombres représentés sont plus grandes. Le symbole d derrière le nombre (par exemple 3.27d) précise ce type.
Le type caractère
  • Le type char ne peut contenir qu'un seul caractère. On affecte un caractère à une variable de type char en mettant le caractère entre simple quotes ('). Exemple : char caractere = 'a';
Le type booléen
  • Le type boolean ne peut contenir que true (vrai) ou false (faux). Exemple : boolean question = true;
Variable de type objet
Le type String
Celui-ci correspond à une chaîne de caractères.
Ici, il ne s'agit pas d'une variable mais d'un objet (en réalité une classe prédéfinie de Java qui n'a pas besoin d'être instanciée, voir plus loin le paragraphe POO) ; on peut l'initialiser en utilisant l'instruction new dont on se sert pour instancier une classe et donc réserver un emplacement mémoire à l'objet ou alors lui affecter directement la chaîne de caractères.
Exemple :
- première manière : String chaine; chaine = "Bonjour";
- deuxième manière : String chaine = new String(); chaine = "Bonjour"

Attention : String commence par une majuscule ! Et lors de l'initialisation, on utilise ici des doubles cotes ou guillemets (").

On peut également déclarer ou instancier et affecter une variable de type String en une seule opération.
Exemple :
- première manière : String chaine = "Bonjour";
- deuxième manière : String chaine = new String("Bonjour")
Autres types objet
En java, la création d'une nouvelle classe définit un nouveau type d'objet (voir plus loin le paragraphe POO).
Les conversions de type
Il est possible de convertir une variable ou le résultat d'une opération mathématique dans un autre type. En mettant celle-ci entre () et précédée du type souhaité :
Exemple 1 :
int nb1; double nb2;
nb2 = (double) nb1;
Exemple 2 :
double nbre1 = 10, nbre2 = 3;
int resultat = (int)(nbre1 / nbre2);

Ce type de conversion s'appelle une conversion d'ajustement ou cast de variable. On peut passer directement d'un type int à un type double (conversion implicite), la conversion de l'exemple 1 n'est donc pas nécessaire. Mais ceci ne fonctionnera pas dans le sens inverse sans une conversion d'ajustement avec une perte de précision ; en effet la valeur du double sera ajustée à sa partie entière (ce qui est le cas dans l'exemple 2 précédent).

Pour affecter une variable de type chaîne par la valeur d'une variable numérique (de type int par exemple), il faut appliquer la méthode valueOf de l'objet String.
Exemple :
int i = 12;
String ch = new String();
ch = ch.valueOf(i);
Ceci fonctionne aussi avec les autres types numériques.

Pour l'opération inverse, on utilise la méthode valueOf de la classe Integer (c'est la classe qui contient le type int et plusieurs méthodes dont celles pour convertir un entier en chaîne).
Exemple : int k = Integer.valueOf(ch);
Il y a l'équivalent pour les autres types numériques (en utilisant les classes Long, Float, Double, ...)
Notation des constantes
Une constante entière est de l'un des types int ou long. On peut forcer une constante à être du type long en faisant suivre sa valeur par la lettre l ou L. par exemple : 54l (sinon 54 serait du type int).
Une constante flottante peut s'écrire sous forme décimale ou exponentielle (signe, mantisse et exposant). La notation décimale doit comporter obligatoirement un point (correspondant à la virgule). La partie entière ou décimale peut être omise si elle n'est pas significative (par exemple : 0.52 ou .52 ; 3.0 ou 3.). Par défaut, toute les constantes flottantes sont de type double, on peut imposer le type float à une constante en faisant suivre son écriture par la lettre f ou F par exemple : float x = 17.5f ;(sinon 17.5 serait de type double et comme la conversion implicite ne peut pas se faire, il y aurait une erreur de compilation) .
Une constante de type caractère peut se noter de façon classique entre quotes (par exemple : 'a') ou par une notation spéciale (par exemple \n pour un saut de ligne) ou un code Unicode exprimé en hexadécimal sous la forme \uxxxx où xxxx sont quatre chiffres hexadicimaux (par exemple : \u0228).
Une constante chaîne se note entre guillemets (par exemple "Bonjour") et peut inclure à l'intérieur des guillemets une notation spéciale d'un caractère ou un code Unicode.
Le mot-clé final
En java, il n'y a pas de mot-clé (const) permettant de déclarer une constante symbolique comme dans d'autres langages. Toutefois, le mot-clé final permet de déclarer que la valeur d'une variable, une fois initialisée, ne doit pas être modifiée pendant l'exécution du programme. Lorsque final est utilisé conjointement avec une expression constante, on retrouve la notion usuelle de constante symbolique c'est à dire un symbole dont la valeur est parfaitement connue du compilateur (par exemple : final int nb = 30;). Il est d'usage en Java d'écrire les constantes symboliques en majuscules (donc l'exemple précédent devrait plutôt s'écrire : final int NB = 30;).
Les expressions vraies / fausses
Java n'accepte que les booléens true et false et non, comme beaucoup de langage, la valeur 0 pour faux et une valeur numérique non nulle pour vraie.
Les opérateurs
Les opérateurs arithmétiques
+, - , *, / permettent d'ajouter, soustraire, multiplier, diviser deux variables numériques et le moins unaire (-) donne l'opposé d'une variable numérique.
% (opérateur modulo) permet de renvoyer le reste de la division entière de deux variables de type numérique.
Raccourcis d'écriture
Par exemple, les 4 écritures suivantes donnent le même résultat (idem avec -) :
nbre = nbre + 1;
nbre += 1;
nbre++;
++nbre;
Raccourcis pour la multiplication et la division :
nbre = nbre * 2;
nbre *= 2;
nbre = nbre / 2;
nbre /= 2;
Opérateur sur les chaînes de caractères
+ permet de concaténer deux chaînes de caractères
Les opérateurs logiques
= = permet de tester l'égalité.
!= différent de.
< strictement inférieur.
<= inférieur ou égal.
> strictement supérieur.
>= supérieur ou égal.
&& est l'opérateur ET.
|| est l'opérateur OU.
! est l'opérateur NON
Les opérateurs bit à bit
Les opérateurs bit à bit permettent de manipuler les bits individuels d'une donnée de type primitif.
Ils effectuent des opérations d'algèbre booléenne sur les bits en correspondance dans les deux arguments afin de produire un résultat. Il existe les opérateurs AND (&), OR (|), XOR (^) et NOT (~).
Il existe aussi les opérateurs de décalage (uniquement avec les types primitifs entiers).
Entrée/Sortie
Sortie
Pour afficher le contenu d'une variable dans la console, il suffit d'écrire l'instruction : System.out.println(maVariable); ou encore System.out.print(maVariable);.
Ces instructions appliquent la méthode println() sur la sortie standard.
Dans ce contexte, l'opérateur + est un opérateur de concaténation étendue, c'est-à-dire qu'il permet de mixer des expressions de type texte (chaîne de caractères) avec des expressions de type numérique (la conversion se fait automatiquement si la première expression est du texte).
Exemple :
int a = 3, b = 10;
System.out.println("a = "+a+" et b = "+b); // affiche : a = 3 et b = 10
Entrée
Il faut instancier la classe Scanner (voir plus loin le paragraphe POO)
Cette classe peut prendre différents paramètres, mais pour les saisies au clavier on utilise System.in. qui correspond à l'entrée standard en Java.
On instancie un objet Scanner de la manière suivante :
Scanner sc = new Scanner(System.in);
Pour lire une chaîne de caractères, on doit utiliser nextLine().
String str = sc.nextLine();

La méthode nextLine() renvoie une chaîne de caractères.
Pour lire un entier, on doit utiliser nextInt().
De façon générale, pour récupérer un type de variable, il suffit d'appeler nextType() où Type est le type voulu.
Exemple :
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
double d = sc.nextDouble();
long l = sc.nextLong();
byte b = sc.nextByte();

Remarques :
  • il y a un type de variable primitive qui n'est pas pris en compte par la classe Scanner : il s'agit des variables de type char. Il faudra récupérer une chaîne de caractères puis utiliser la méthode chartAt pour récupérer le premier caractère :

    char carac = str.charAt(0);
  • la méthode nextLine() récupère le contenu de toute la ligne saisie et repositionne le curseur au début de ligne ce que ne fait pas les méthodes comme nextInt() , nextDouble() et il est nécessaire d'invoquer derrière ces méthodes la méthode nextLine() qui repositionne le curseur avant toute autre saisie d'une autre ligne.par la méthode nexLine().
  • Ces entrées/sorties ne sont employées que pour des tests dans les applications avec une interface graphique.
Les structures de test
La structure if....else
if (/*condition*/) {
          .....// si la condition est remplie
          .....instructions;
          }
else {
           ....// si la condition n'est pas remplie
           ....instructions;
 }
Remarques :
  • les parenthèses sont obligatoires, même autour d'une simple variable booléenne mais les accolades peuvent être omises si le bloc d'instructions à exécuter est réduit à une seule instruction ;
  • la clause else est facultative ;
  • on peut emboîter plusieurs structures l'une dans l'autre.
La structure switch
Cette structure permet de traiter plusieurs cas en fonction de la valeur ou plage de valeurs d'une variable.
switch (/*variable*/) {
       case /*argument 1*/:
            // instructions;
            break;

       case /*argument 2*/:
            // instructions;
            break;
........................................
       case /*argument n*/:
            // instructions;
            break;
 }
Remarques :
  • l'instruction break permet de sortir de la structure (elle est optionnelle). Mais en l'absence de break, le programme continue sur le bloc case suivant (c'est une erreur courante de l'oublier) ;
  • on peut ajouter en dernier, case default, avec les instructions à exécuter dans le cas où aucun des cas précédents n'a permis de sortir de la structure (ces instructions sont exécutées si break a été omis au bloc case précédant).
Les structures de boucle
Dans les trois structures suivantes, l'instruction break permet de sortir prématurément d'une boucle et l'instruction continue sert à reprendre en début de boucle avec l'itération suivante.
La boucle while
while (condition) {
                // Instructions;
}
Tant que la condition est vraie, les instructions entre accolades sont exécutées en boucle
Exemple :
int a = 1, b = 20;
while (a < b){
        a++;
        --b;
}
La boucle do....while
do {
        Instructions
}
while (condition);
La boucle do... while s'exécutera au moins une fois puisque le test de la condition se fait à la fin.
La boucle for
Exemple
int S = 0:
for (int i = 1; i <= 10; i++) {
        S = S + 3;
}
Cette boucle peut prendre tous ses attributs dans sa condition : la déclaration de la variable compteur de boucles, son initialisation, sa borne et son pas d'incrémentation. Toutefois, on peut déclarer la variable compteur avant la boucle surtout si on veut récupérer la valeur de cette variable en fin de boucle.

Remarques :
  • il faut des points virgules dans la condition pour la séparation des attributs ;
  • les accolades peuvent être omises si le bloc d'instructions ne contient qu'une seule instruction.
Les classes et méthodes (fonctions) intégrées
Il existe de multiples classes et méthodes fournies avec la version standard de Java. On peut voir la documentation en ligne à l'adresse :
http://doc.java.sun.com/DocWeb/#
ou http://download.oracle.com/javase/6/docs/api/index.html
et pour la bibliothèque Maths à l'adresse :
http://download.oracle.com/javase/6/docs/api/java/lang/Math.html

Les tableaux
Un tableau est simplement une suite d'éléments ordonnés (chacun repéré par son index), tous du même type et réunis ensemble sous un même nom. Les tableaux sont définis et utilisés avec des crochets ouvrants et fermants [ ].
Pour déclarer un tableau il suffit d'ajouter des crochets vides après le nom du type.
Exemple :
int[] a;
Les crochets peuvent également être placés après le nom de la variable :
int a[];

Remarque : la déclaration ne crée qu'une référence (aucun espace en mémoire n'est réservé, c'est au moment de l'affectation qu'il le sera). On peut aussi faire les deux en même temps, par exemple : int [] a = {0, 1, 3}, on peut aussi le faire après la déclaration, à tout endroit du code par l'instruction new (exemple : a = new int[3];). Une fois l'affectation faite, le tableau possède une propriété (donnée membre) length qui donne la taille du tableau (les index commencent à 0, le plus grand est donc length - 1). On accède à un élément du tableau par son index (par exemple a[2]) et un index hors les bornes déclenche une erreur.
POO
Objets, propiétés et méthodes
Une classe est une « catégorie » d'objets ou si l'on veut une sorte de modèle.
Tout ce que l'on fait en Java consiste à définir des classes, fabriquer des objets à partir de ces classes (instancier les classes) et communiquer avec ces objets.
Classe
Pour créer une classe, il faut utiliser le mot clé Class et préciser devant la portée (public ou private). Le contenu de la classe sera entre accolades {}.
Exemple :
public class MaClasse {
........................................
}
Lorsqu'on définit une classe, on peut mettre deux types d'éléments dans ces classes : des données membres de la classe (aussi appelées champs ou propriétés) et des fonctions membres de la classe (habituellement appelées méthodes).
Pour créer une donnée membre dans une classe il suffit de déclarer une variable. Une donnée membre est soit du type d'un objet soit d'un type primitif.
Pour créer une méthode dans une classe, il faut préciser le type des paramètres s'il y en a, et le type de la valeur de retour s'il y en a, ou le type void s'il n'y en a pas. Si la méthode renvoie une valeur, il faut utiliser l'instruction return pour renvoyer cette valeur. Enfin il faut préciser, avant le type de retour (ou void), le mode d'accès de la méthode : public, private ou protected (voir ci-dessous la portée).
Exemple :
public class MaClasse {
              public int MaMéthode (int n){
                             // instructions;
                             ......................
              return S;
              }
}
Accès
Java utilise trois mots clés pour fixer des limites au sein d'une classe : public, private et protected. Leur signification et leur utilisation sont relativement explicites. Ces spécificateurs d'accès déterminent qui peut utiliser les définitions qui suivent. Le mot clé public veut dire que les définitions sont disponibles pour tout le monde. Le mot clef private, au contraire, veut dire qu'on ne peut pas accéder à ces définitons en dehors de la classe (sinon une erreur est générée à la compilation). Le mot clé protected se comporte comme private, en moins restrictif : une classe dérivée a accès aux membres protected, mais pas aux membres private.
Objet
Un objet est créé par instanciation d'une classe. Avec Java, on instancie une classe à l'aide de l'instruction new.
Exemple : si MaClasse est une classe
MaClasse MonObjet = new MaClasse( )   // une référence à l'objet est créée.

Remarque : la syntaxe de Java exige de préciser le type de MonObjet (le nom de la classe) et d'ajouter des parenthèses vides à la fin du nom de la classe.

La syntaxe pour utiliser une méthode ou une propriété (donnée membre) est la suivante :
objet.NomMéthode ou objet.NomPropriété
Chaque objet met ses données membres dans sa zone de mémoire propre, les données membres ne sont pas partagées entre les objets.
Interface graphique (GUI : Graphical User Interface)
Java permet de créer une interface graphique pour une application en utilisant, par exemple, la bibliothèque swing. Des plug-ins existent aussi pour dessiner l'interface et générer une partie du code nécessaire (faire une recherche sur internet).
Les bibliothèques
Les bibliothèques ajoutent des fonctionnalités à Java en donnant accès à des classes supplémentaires (et donc aux méthodes et données membres de ces classes une fois instanciées).
Par exemple, la bibliothèque util contient un certain nombre de classes comme la classe Scanner (pour gérer les entrées) ou la classe Random (pour générer des nombres aléatoires).
On ajoute une bibliothèque à son projet au tout début (avant la définition de la première classe) par le mot clé import.
Exemple 1:
import java.util.*; // rend disponibles toutes les classes de la bibilothèque util
Exemple 2 :
import java.util.Scanner; // n'importe que la classe Scanner.

Remarque : certaines méthodes et données membres peuvent être déclarées static ce qui signifie qu'elles peuvent être utilisées sans que les classes soient instanciées
Ecrire un programme
Un programme Java est un ensemble de classes réparties dans un ou plusieurs fichiers, certaines pouvant être imbriquées dans d'autres. Mais une et une seule classe doit avoir une méthode main qui sera le point d'entrée du programme (c'est à dire que le code de cette méthode sera exécuté au lancement du programme). Cette méthode n'a donc pas de valeur de retour, elle est du type void. Elle doit aussi être public (sinon elle ne sera pas accessible) et static (car elle est appelée avant que la classe puisse être instanciée) soit :

public static void main(String[] args) {
.............................................................
}

Remarque : les paramètres String[] et args sont imposés même si non nécessaires. Le paramètre args contient les arguments éventuels de la ligne de commande.

© Matabu mars 2020 - Tous droits réservés. Limitation à l'usage non commercial, privé ou scolaire.