| Accueil site | MathGraph32 | Images | Activités | Tableur | Téléchargements | Informations |
|
|
|||||||
|
 Algorithmique |
| ||||||||||
|
Commentaires Il y a deux types de commentaires en Java.
Variables Le type booléenIl y a deux types de variables :
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 caractèreLe type numérique
Variable de type objet Autres types objetLe 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") 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 :
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 :
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 :
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 :
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.
|
|||||||||||
