Formation Développeur Java Introduction à la programmation en Java

Badr Benmammar bbm@badr-benmammar.com
Formation Développeur Java Introduction à la programmation en Java Badr Benmammar

Plan Introduction générale Langages compilés Langages interprétés
Langages intermédiaires Introduction au JAVA Environnement de programmation JVM, JRE, JDK et SDK Quelques packages Package de base : java.lang Historique des versions J2SE, J2EE et J2ME Terminologie JAR, JCP et JSR JAVA, interprété ou compilé ?

Plan Syntaxe et éléments de bases de Java Types primitifs Variables
Constantes Conversion de type de données Conversion explicite Conversion implicite Lire les entrées clavier Opérateurs Fonctions mathématiques Structures de contrôles des instructions Tableaux Fonctions Procédures

Langages de programmation
Les langages de programmation actuels sont majoritairement de deux sortes : Langages compilés. Langages interprétés. Lors du choix d’un langage pour un projet, cet aspect fondamental peut faire pencher la balance.

Langage machine Le langage machine, ou code machine, c’est le langage natif d'un processeur, c'est-à-dire le seul qu'il puisse traiter. C’est la suite de bits qui est interprétée par le processeur d'un ordinateur exécutant un programme informatique. Il est composé d'instructions et de données à traiter codées en binaire. Le code machine est généré, généralement par la compilation d'un langage de programmation.

Langage compilé Un programme écrit dans un langage compilé va être traduit une fois pour toutes par un compilateur, afin de générer un fichier exécutable. Exemple : C, C++, Pascal, Fortran, Cobol, ADA. Le langage C : gcc -o essai.o -c essai.c gcc -o essai essai.o Ou gcc –o essai essai.c Avantage : rapide. Inconvénient : fermé si on n’a pas le source, besoin de l’outil de développement pour modifier.

Langage interprété Un langage informatique se dit interprété lorsque les instructions qui le composent sont décodées les unes après les autres et exécutées aussitôt. Son fonctionnement est le suivant : Lire l’instruction ; Exécuter l’instruction ; Passer à l’instruction suivante et recommencer.

Langage interprété Un langage interprété a besoin d’un interpréteur.
BASIC, MATLAB, PHP, Prolog, Perl. Le QBasic se lançait avec la commande : qbasic /run prog.bas Avantage : le programme prog.bas est un fichier texte, facilement modifiable. Inconvénient : c’est forcément plus lent que quand c’est compilé.

Quelques langages

Langages intermédiaires
Certains langages appartiennent en quelque sorte aux deux catégories : LISP, Python, … Le programme écrit avec ces langages peut dans certaines conditions subir une phase de compilation intermédiaire vers un fichier écrit dans un langage différent du fichier source et non exécutable (nécessité d’un interpréteur).

JAVA : portabilité et fiabilité
JAVA a été développé par Sun au début des années 90 dans une filiation avec le langage C et surtout le langage objet C++ mais dans une optique de plus grande portabilité d’une machine à une autre et d’une plus grande fiabilité . Les programmes JAVA sont compilés en "bytecode", un langage intermédiaire indépendant de la plateforme. Ce "bytecode" est interprété par une machine virtuelle sur des machines différentes : Mac, Pc, Windows, Linux, Unix, ... Exemple : applets Java, petits programmes insérés parfois dans les pages Web, sont des fichiers qui sont compilés mais que l’on ne peut exécuter qu'à partir d’un navigateur internet.

JAVA : compilé ou interprété ?
Un langage compilé est un langage pour lequel le compilateur va traduire le code écrit par les développeurs en code exécutable directement par la machine. Un langage interprété est un langage pour lequel la traduction en code machine n'est fait qu’à l'exécution. Pour le java, on à une étape de compilation qui produit du code qui sera exécuté par une machine virtuelle, c’est une solution intermédiaire qui permet de rester indépendant du type de machine qui exécutera le code tout en ayant un code déjà optimisé pour l'exécution.

JAVA : compilé ou interprété ?
Compilateur (javac) Fichier source (*.java) Bytecode (*.class) Interpréteur (java)

JAVA : environnement de programmation
JAVA est un environnement de programmation objet composé de : Langage orienté objet JAVA. JVM (machine virtuelle Java) : permettant d’interpréter et d’exécuter le bytecode Java. API (application programming interface) : un ensemble de classes standards (bibliothèque). JRE (Java Runtime Environment) : l’environnement d’exécution Java désigne un ensemble d’outils permettant l’exécution de programmes Java sur toutes les plates-formes supportées. JRE est constitué de la JVM et d’une bibliothèque standard à partir de laquelle doivent être développés tous les programmes en Java. java.lang est le package de base qui contient les classes qui seraient toujours utilisées (System, Thread, Math, String, …). Toutes les classes et interfaces de java.lang sont automatiquement importées par le compilateur.

JAVA : environnement de programmation
Java Development Kit (JDK) : le nouveau terme c’est SDK (Standard Development Kit) qui est l’environnement dans lequel le code Java est compilé pour être transformé en bytecode afin que la machine virtuelle Java (JVM) puisse l'interpréter. Les composants primaires du JDK sont une sélection d’outils de programmation, incluant : javac : le compilateur, qui convertit le code source en fichier .class (contenant le bytecode Java). javadoc : le générateur de documentation, qui génère automatiquement de la documentation à partir des commentaires du code source. jar : l’archiveur, qui met sous forme d’un paquetage unique l’ensemble des fichiers class en un fichier JAR. jdb : le débogueur. JRE : environnement d’exécution Java.

Quelques packages Package de base : java.lang
Toutes les classes et interfaces de java.lang sont automatiquement importées par le compilateur. Gestion de données et utilitaires : java.util Rassemble des classes d'utilitaires (gestion des collections de données, génération de nombres aléatoires, énumération, date,...). Définit les classes d'exceptions : EmptyStackException. NoSuchElementException. Gestion des applets : java.applet La classe Applet et les interfaces de ce package permettent de programmer une applet Java et d'intégrer une applet dans un navigateur. Manipulation d'images : java.awt.image Les classes de ce package permettent de manipuler les images (gestion du chargement des images, filtres, gestion des couleurs,...).

Quelques packages Entrées-sorties : java.io
Rassemble les classes permettant de gérer les entrées-sorties (accès fichiers, gestion de répertoires,...). Définit les classes d'exceptions : IOException. EOFException. FileNotFoundException. InterruptedIOException. UTFDataFormatException. Accès réseau : java.net Rassemble les classes permettant de gérer les accès réseau. MalformedURLException. ProtocolException. SocketException. UnknownHostException. UnknownServiceException.

Quelques packages Interface utilisateur :
java.awt : utilise les composant graphiques natifs (peers). Définit les classes d'exceptions : AWTException. AWTError. javax.swing : librairie très puissante, composants très évolués (arbres, tables, …). Définit l’exception : UnsupportedLookAndFeelException Java 3D : javax.media.j3d Rassemble les classes de l’API Java 3D (interface de programmation pour la plateforme Java visant la synthèse d'image 3D).

Historique des versions
Le langage Java a connu plusieurs évolutions depuis le JDK 1.0 (Java Development Kit) avec l’ajout de nombreuses classes et packages à la bibliothèque standard. JDK 1.0 (23 janvier classes et interfaces) : version initiale. JDK 1.1 (19 février classes et interfaces) : de nombreux ajouts avec notamment : Une refonte complète du modèle événementiel AWT. Les classes internes sont ajoutées au langage. JavaBeans. JDBC. Java Remote Invocation (RMI).

J2SE 1.2 (9 décembre classes et interfaces) : cette version et les suivantes jusque J2SE 5.0 sont rebaptisées Java 2 et l’édition nommée J2SE remplace JDK pour distinguer la plate-forme de base de l’édition J2EE et de l’édition J2ME. J2SE : (Java 2 Standard Edition) comprenant les API et bibliothèques de bases, ainsi que les API destinés au poste client (comme par exemple Java Foundation Classes (JFC) qui est un framework graphique pour Java composé de AWT, Swing et Java2D). J2EE : (Java 2 Enterprise Edition) destinée aux développements des applications d’entreprises. Sun propose en plus des spécifications, des mises en œuvre illustratives. J2ME : (Java 2 Micro Edition) destinée aux systèmes mobiles tel que par exemple, les assistants personnels ou les téléphones portables. Plusieurs ajouts par rapport à la version précédente dont : Le framework Collections. L’API graphique Swing est intégrée.

J2SE 1.3 (8 mai classes et interfaces) : changements principaux : Changement pour les RMI pour être basé sur CORBA. JavaSound. JNDI (Java Naming and Directory Interface) inclus de base (disponible auparavant comme extension) pour utiliser différents services de nommages ou d'annuaires. JPDA (Java Platform Debugger Architecture) pour les outils de type débogueur.

J2SE 1.4 (6 février classes et interfaces) : les principaux changements sont : Mot-clé assert. Expressions rationnelles modélisées en s’inspirant du langage Perl. Chaînage d’exception. API de journalisation. API Image I/O pour lire et écrire des images dans des formats comme JPEG et PNG. Intégration d’un parser XML (pour extraire les données d’un document XML et pour vérifier sa validité) et du moteur XSLT nommé JAXP. JAXP (Java API for XML Processing) est une API permettant la création, la manipulation et le traitement de fichiers XML à bas niveau. Intégration des extensions de sécurité JCE (Java Cryptography Extension), JSSE et JAAS. Java Web Start (introduit pour la première fois en mars 2001 pour J2SE 1.3).

J2SE 5.0 (30 septembre classes et interfaces) : (initialement numérotée 1.5, qui est toujours utilisé comme numéro de version interne), ajoute un nombre significatif de nouveautés au langage : Programmation générique. Metadata, également appelées annotations, permet au langage de construire des classes et des méthodes étiquetées avec des données additionnelles qui peuvent être utilisées en tant que méta-données. Autoboxing/unboxing, conversion automatique entre des types primitifs (comme le type int) et le Wrapper de classe correspondant (comme la classe Integer). Énumérations : le mot-clé enum permet de créer une liste ordonnée de valeurs sans type. Extension du for pour les boucles, la syntaxe du for est étendue avec une syntaxe spéciale pour itérer sur n’importe quel objet itérable comme un tableau, ou une collection.

Java SE 6 (11 décembre classes et interfaces) : avec cette version, Sun remplace le nom J2SE par Java SE et supprime le .0 au numéro de version. Java SE 7 : Une des nouveautés majeures de cette version sera l’ajout des closures (en cours de spécifications). Il s’agira de la première version sous la licence GPL. closure est un bloc de code référençable, manipulant optionnellement des variables dites "libres", libres en ce sens qu'elles sont définies non dans le bloc de code, ni de façon globale, mais par le contexte dans lequel le bloc est exécuté.

Caractéristiques du JAVA
Simple : plus simple que le C ou le C++ car on lui a retiré les caractéristiques peu utilisées ou difficile à utiliser : Pointeurs. Surcharge d'opérateurs. Héritage multiple. Le mécanisme de libération de la mémoire (garbage collection) est transparent contrairement au C++. Le ramasse-miettes qui est une fonctionnalité de la JVM est appelé régulièrement et automatiquement pendant l'exécution du programme. L'espace mémoire nécessaire à chaque objet créé est alloué dans un tas de mémoire réservé à cet usage. Le programme peut ensuite accéder à chaque objet grâce à sa référence dans le tas. Quand il n'existe plus aucune référence permettant d'atteindre un objet, le ramasse-miettes le détruit automatiquement puisque qu'il est devenu inaccessible libérant la mémoire et prévenant ainsi toute fuite de mémoire.

Exemple de pointeurs en C
#include <stdio.h> echanger (int *a, int *b) { int c; c=*a; *a=*b; *b=c; } void main() int x=5; int y =10; printf("avant\n"); printf("%d\n",x); printf("%d\n",y); echanger (&x,&y); printf("apres\n"); Une procédure echanger pour échanger les deux valeurs contenues dans les variables x et y. Mots-clés du C/C++ absent en Java

Orienté objet : l’ensemble des instructions de base a été réduit pour augmenter sa fiabilité mais donne accès à de nombreuses classes permettant de définir et de manipuler des objets. Une classe contient des données et du code. Le code est sous forme de fonctions ou procédures appelées méthodes. Principe de l'encapsulation. Distribué : les fonctions d'accès au réseau et les protocoles Internet les plus courants (HTTP, FTP, Telnet) font partie de Java. Il est donc facile de mettre en place une architecture Client-Serveur pour travailler avec des fichiers situés sur un ordinateur distant.

Robuste : le typage des données est très strict, tant à la compilation qu'à l'exécution. Les pointeurs utilisés dans Java ne sont pas accessibles au programmeur. Sûr : L'interpréteur de java vérifie que le byte code n'a pas été altéré depuis sa compilation. Sun travaille sur un système qui permettra à terme la transmission codée des informations sur le réseau. Dynamique : contrairement au C++, les classes de Java peuvent être modifiées sans modification du programme qui les utilise. Indépendant des architectures matérielles : Le compilateur java fabrique du byte code "universel". Pour l'exécuter sur une machine quelconque, il faut qu'un interpréteur java (machine virtuelle) existe pour cette machine.

Portable : les types de données sont indépendants de la plate-forme. Une variable int sera toujours définie dans un entier 32 bits en complément à 2 aussi bien sur un PC 486 que sur un Power Macintosh. Les float, double et long se conforment à la spécification IEEE754. Les char relèvent du standard Unicode. Les boolean prennent toujours les valeurs true et false. Multithread : pour l'exécution simultanée de plusieurs processus. Java est fourni avec un jeu de primitives qui facilitent l'écriture de ce genre de programmes. Haute performance : bien que java soit un langage interprété, le compilateur java génère du byte code optimisé en incluant des instructions qui permettront à chaque interpréteur de tirer la meilleure performance possible du code. La vitesse d'exécution du code peut être semblable à celle de C ou C++.

Terminologie : fichier JAR
Un fichier JAR (Java ARchive) est utilisé pour distribuer un ensemble de classes Java. Ce format est utilisé pour stocker des classes compilées, ainsi que des métadonnées constituant l’ensemble d’un programme (images, sons, des fichiers de paramétrages, …). Créer un fichier Jar : jar cfv fichier.jar fichier1.class fichier2.class Visualiser le contenu d’un fichier Jar : jar tf fichier.jar Extraire le contenu d’un fichier Jar : jar xfv fichier.jar Modifier un fichier Jar : jar uf fichier.jar fichier3.class L’option c indique qu’il faut créer une archive Jar. L’option f indique que le résultat sera redirigé dans un fichier. L’option v fait afficher les commentaires associés à l’exécution de la commande, en particulier, les noms des éléments ajoutés au fichier d’archive au fur et à mesure qu’ils y sont ajoutés. L’option t fait afficher le contenu de l’archive Jar. L’option u indique qu’il faut mettre à jour une archive Jar. L’option x indique qu’il faut extraire le contenu d'une archive Jar.

Terminologie : JCP et JSR
Java Community Process (JCP) est une organisation créée par Sun en 1998. Son but est de coordonner l'évolution du langage Java et des technologies qui lui sont associées. Le JCP s'est doté d'un processus formalisé permettant aux différentes parties intéressées d'être impliquées dans la définition des futures versions et fonctionnalités de la plateforme Java. Le JCP émet des Java Specification Requests (JSR), qui décrivent les spécifications et technologies proposées pour un ajout à la plateforme Java. Des revues publiques formelles des JSRs sont menées avant qu'une JSR ne devienne finale et qu'elle ne soit votée par le comité exécutif du JCP.

JCP et JSR Une JSR finale fournit une implémentation de référence qui offre : Une implémentation gratuite de la technologie sous la forme de code source. Un ensemble de tests TCK (Technology Compatibility Kit) pour vérifier la compatibilité d'une implémentation avec la spécification. Le JCP est composé d'entreprises du domaine Java, comme Sun, IBM, Oracle, Borland, BEA, Nokia, Sony, mais aussi de fondations du monde du logiciel libre, comme la fondation Apache ou OW2 qui regroupe des entreprises et des organismes de recherche tels que l’INRIA, Bull, France Télécom, Thales Group ou Red Hat, ainsi que de particuliers, pour lesquels l'adhésion est libre.

Premier programme JAVA
// mon premier programme java class Prog1 { public static void main(String args[]) System.out.println ("bonjour tous le monde"); } Un programme JAVA est une classe qui doit être enregistrée dans un fichier de même nom et d'extension .java.

Lignes du programme // introduit un commentaire.
Le programme Java comporte au moins 1 classe qui contient elle-même au moins la méthode main. La méthode main est toujours celle qui est "lancée" à l'exécution du programme. La seule instruction de la méthode est l'affichage d'une chaîne de caractères sur la sortie standard (l'écran) avec ajout d'un passage à la ligne : appel à la méthode println de la classe System. Compilation puis exécution : javac Prog1.java java Prog1 bonjour tous le monde

Types primitifs en JAVA

Variables Une variable est un objet repéré par son nom, pouvant contenir des données, qui pourront être modifiées lors de l'exécution du programme. Les variables en langage Java sont typées, c'est-à-dire que les données contenues dans celles-ci possèdent un type, ainsi elles sont donc stockées à une adresse mémoire et occupent un nombre d'octets dépendant du type de donnée stockée. La déclaration de variables : int nb; nb=8; int x=nb+2; float toto = f; System.out.println("Le nombre entier vaut : " + x + "\n"+"Le nombre reel vaut : " +toto );

Constantes final int d = 12; final double b = 12.6; b=b*2;
Une constante est une variable dont la valeur est inchangeable lors de l'exécution d'un programme. Le mot clé final permet de définir une variable dont la valeur ne peut pas être modifiée après son initialisation. final int d = 12; final double b = 12.6; b=b*2;

Conversion de type de données
Conversions implicites : Une conversion de type implicite sans perte d'informations est réalisée d'un type primitif vers un type plus grand (élargissement) : byte short int long float double char int Exemple: int i=7; double x=i;

Conversion de type de données
Conversion explicite : Une conversion explicite consiste en une modification du type de donnée forcée. Cela signifie que l'on utilise un opérateur dit de cast pour spécifier la conversion. L'opérateur de cast est tout simplement le type de donnée, dans lequel on désire convertir une variable, entre des parenthèses précédant la variable. Une conversion de type explicite se fait avec perte d'informations est réalisée d'un type primitif vers un type plus petit. Exemple : double x=4.667; int i= (int) x;

Lire les entrées clavier
import java.util.Scanner; class Prog1 { public static void main(String args[]) Scanner sc = new Scanner (System.in); System.out.println("Veuillez saisir un mot :"); String str = sc.nextLine(); System.out.println("Vous avez saisi : " + str); System.out.println("Veuillez saisir un caractere :"); char carac = sc.nextLine().charAt(0); System.out.println("Vous avez saisi le caractère : " + carac); System.out.println("Veuillez saisir un entier :"); int x = sc.nextInt(); System.out.println("Vous avez saisi le nombre : " + x); System.out.println("Veuillez saisir un reel :"); double d = sc.nextDouble(); System.out.println("Vous avez saisi le nombre : " + d); System.out.println("Veuillez saisir un boolean :"); boolean bool=sc.nextBoolean(); System.out.println("Vous avez saisi : " + bool); }

Chaînes de caractères La classe String permet de gérer les chaînes de caractères. La méthode length() retourne le nombre de caractères de la chaîne concernée. String s = "java" ; System.out.println (s.length ( ) ) ; // affiche 4 La méthode charAt (int i) retourne le caractère d’indice i de la chaîne. System.out.println (s.charAt ( 2 ) ) ; // affiche v La méthode equals (String c) retourne true si la chaîne concernée est identique à la chaîne c et false sinon. String t = "lundi" ; String u = "ja" + "va" ; // Concaténation de 2 chaine s System.out.println (s.equals ( t ) ) ; // Affiche false System.out.println (s.equals (u ) ) ; // Affiche true

Chaînes de caractères public String concat (String str)
Renvoie la chaîne, résultat de la concaténation de str à la fin d'une chaîne de caractères. public String replace (char oldChar, char newChar) Renvoie une chaîne où tous les caractères oldChar sont convertis en newChar. public String toLowerCase ( ) public String toUpperCase ( ) Renvoie une chaîne où tous les caractères majuscules sont convertis en minuscules, et inversement. public String trim ( ) Renvoie une chaîne où tous espaces en tête et en queue d'une chaîne de caractères sont supprimés.

Opérateurs Les opérateurs sont des symboles qui permettent de manipuler des variables. On distingue plusieurs types d’opérateurs : Opérateurs de calcul. Opérateurs d’assignation. Opérateurs d’incrémentation. Opérateurs de comparaison. Opérateurs logiques. Opérateurs bit-à-bit. Opérateurs de rotation de bit.

Opérateurs de calcul Permettent de modifier mathématiquement la valeur d’une variable

Opérateurs d’assignation
Ces opérateurs permettent de simplifier des opérations telles que ajouter une valeur dans une variable et stocker le résultat dans la variable. Exemple : x=x x+=2 Les autres opérateurs du même type sont les suivants : Opérateur Effet += Addition deux valeurs et stocke le résultat dans la variable à gauche -= Soustrait deux valeurs et stocke le résultat dans la variable *= Multiplie deux valeurs et stocke le résultat dans la variable /= Divise deux valeurs et stocke le résultat dans la variable

Opérateurs d’incrémentation
Ce type d’opérateur permet de facilement augmenter ou diminuer d’une unité une variable. Ces opérateurs sont très utiles pour des structures telles que des boucles qui ont besoin d’un compteur (variable qui augmente de un en un).

i++ et ++i int i=1; int j=i++; System.out.println (j);
System.out.println (i); int j=++i; i++ : on retourne la valeur de i et après on l’incrémente. 1 2 ++i : on incrémente la valeur de i et on la retourne.

Opérateurs de comparaison

Opérateurs logiques (booléens)
Ce type d’opérateur permet de vérifier si plusieurs conditions sont vraies :

Opérateurs bit-à-bit Ce type d’opérateur traite ses opérandes comme des données binaires, plutôt que des données décimales, hexadécimales ou octales. Ces opérateurs traitent ces données selon leur représentation binaire mais retournent des valeurs numériques standards dans leur format d’origine. Les opérateurs suivants effectuent des opérations bit-à-bit, c’est-à-dire avec des bits de même poids.

Opérateurs de rotation de bit
Ce type d’opérateur traite ses opérandes comme des données binaires d’une longueur de 32 bits, plutôt que des données décimales, hexadécimales ou octales. Ces opérateurs traitent ces données selon leur représentation binaire mais retournent des valeurs numériques standards dans leur format d’origine. Les opérateurs suivants effectuent des rotation sur les bits, c’est-à-dire qu’il décale chacun des bits d’un nombre de bits vers la gauche ou vers la droite. La première opérande désigne la donnée sur laquelle on va faire le décalage, la seconde désigne le nombre de bits duquel elle va être décalée.

Priorités

Fonctions mathématiques
double r; r=Math.random(); System.out.println("valeur aléatoire = " +r); System.out.println("encore : " +r); double d=5.4; System.out.println("valeur = "+d+" son arrondi = "+Math.round(d)); int i=11, j=32, k=13, m; m = Math.max (i,Math.max(j,k)); System.out.println("max de 3 entiers = " +m); Pas besoin d’importer la classe Math : elle fait partie du "package" java.lang de classes directement intégrées.

Structures de contrôles des instructions
Les instructions alternatives (de choix) if-else if (condition) instruction à exécuter quand la condition est vrai; else la condition est fausse;

Exemple Écrire un programme qui affiche "vous êtes majeur" ou "vous êtes mineur" en fonction d’une variable age.

Solution int age ; age=17; if ( age>=18) {
System.out.println ("Vous êtes majeur" ) ; } else System.out.println ( "Vous êtes mineur") ;

Imbrication de structure de contrôle alternative
if (condition1) bloc_1 else if (condition2) bloc_2 else if (condition3) bloc_3 . else bloc_n

Exemple Écrire un programme qui affiche l’état d’un liquide composé d’eau pure en fonction d’une variable température t. Bien évidemment nous sommes sur terre, au niveau de la mer, avec une pression normale.

Solution int t ; t=-10; if ( t<=0) {
System.out.println ("solide") ; } else if (t<=100) System.out.println ("liquide") ; else System.out.println ( "gaz") ;

Opérateur ternaire Il est possible de faire un test avec une structure beaucoup moins lourde grâce à la structure suivante, appelée opérateur ternaire : (condition) ? instruction si vrai : instruction si faux Lorsque la condition est vraie, l'instruction de gauche est exécutée. Lorsque la condition est fausse, l'instruction de droite est exécutée. Exemple: int a=12; int b=9; int max = (a>b) ? a : b; System.out.println(max);

Switch L'instruction switch permet de faire plusieurs tests de valeurs sur le contenu d'une même variable. Ce branchement conditionnel simplifie beaucoup le test de plusieurs valeurs d'une variable. Cette opération aurait été compliquée (mais possible) avec des if imbriqués. Sa syntaxe est la suivante : switch (Variable) { case Valeur1 : Liste d'instructions; break; case Valeur2 : case Valeurs... : default: }

Exemple import java.util.Scanner; class Jour {
public static void main (String args[]) { Scanner sc = new Scanner(System.in); String res; System.out.println("donner un numero"); int x = sc.nextInt(); switch (x) { case 0 : res = "lundi"; break; case 1 : res = "mardi"; case 2 : res = "mercredi"; case 3 : res = "jeudi"; case 4 : res = "vendredi"; case 5 : res = "samedi"; case 6 : res = "dimanche"; default : res = "erreur"; } System.out.print("c'est un "+res); Exemple

Boucles : instructions répétitives
La boucle for : permet de répéter un nombre de fois prédéfini une instruction ou un bloc d’instructions. int i ; int x ; for (i =1; i <5; i=i+1) { x=2*i ; System.out.println (x) ; }

Double boucle for (int i=0; i<10; i=i+1) { Exécution :
for (int j =0; j<i ; j=j+1) System.out.print("x") ; } System.out.println( ) ; Exécution : x xx xxx xxxx xxxxx xxxxxx xxxxxxx xxxxxxxx xxxxxxxxx

Boucle while int x ; x=32; while ( x!=1) { System.out.println (x) ;
}

Boucle do while Exemple : Obliger l’utilisateur à saisir une valeur entre 5 et 9. // import java.util.Scanner; class nombre { public static void main (String args[]) Scanner sc = new Scanner(System.in); int nombre; do { System.out.println ("donnez une valeur entiere entre 5 et 9"); nombre= sc.nextInt(); } while ((5 > nombre) || (nombre > 9)) ; System.out.println("la valeur est : " + nombre); }

Math.random( ) La fonction Math.random ( ) permet de générer aléatoirement un nombre réel dans l’intervalle [0; 1[. Pour générer un nombre entier aléatoire compris entre 0 et 100 nous devons multiplier le résultat de la fonction Math.random(), puis convertir le résultat en entier. int x ; x=(int) (Math.random( ) *101 ) ; x aura pour valeur un nombre aléatoire compris entre 0 et 100. Exercice : Proposer un programme permettant d’afficher : 15 valeurs aléatoires comprises entre 56 et 78. 4 valeurs aléatoires comprises entre -5 et 5.

Exercices Écrire un programme affichant les multiples de 3 de 1 à 10.
Écrire un programme affichant la somme des 20 premiers entiers. Écrire deux programme différents qui affichent les 20 premiers chiffres entiers, du plus grand au plus petit. Écrire un programme permettant de lire au clavier un entier, tant que celui-ci n’est pas pair. Écrire un programme qui lit des entiers tant que leur somme est inférieure à 100. Écrire un programme qui lit un nombre entier, qui affiche son carré et qui se termine quand le chiffre 0 est lu.

Exercices Écrire un programme, en utilisant une boucle adaptée, pour chacune des tâches suivantes : Afficher les 20 premiers termes de la suite 1/2^i. Lire un entier x et afficher les nombres pairs, à partir de 2, tant que leur somme est inférieure à x. Lire 10 nombres et calculer le minimum de ceux-ci. Lire un entier x et afficher les 5 premiers termes de la suite 1/x^i , tant que l’entier x lu n’est pas 0.

Tableaux Stocker plusieurs éléments de même type class TabMax {
public static void main (String args[]) int [] tab; tab = new int[5]; tab[0]= 3; tab[1]= 45; tab[2]= 5; tab[3]= 412; tab[4]= 0; //int tab[] = {3,45,5,412,0}; int nbre, i, max; System.out.println("le nombre d'element"+ " du tableau = " + tab.length); i=1; max=tab[0]; while (i < tab.length) if (tab[i]>max) max = tab[i] ; i = i+1; } System.out.println("le maximun est " + max); Stocker plusieurs éléments de même type

Tableau à 2 dimensions class IDENT {
public static void main (String args[]) { double ident[][]; int i,j; ident = new double[10][10]; for (i=0; i<10 ; ++i) for (j=0; j<10 ; ++j) if (i ==j ) ident[i][j]=1.0; else ident[i][j]=0.0; System.out.println("matrice identité :"); for (i=0; i<ident.length ; ++i) { for (j=0; j<ident[0].length ; ++j) System.out.print(ident[i][j]+" "); System.out.println(); } //int matrice [] [] = {{1,2},{3,4}}; //System.out.print(matrice[1][0]+" ");

Tableau : arguments de la méthode main
Il est possible de passer des paramètres au programme par l'argument de la méthode main : String args[] est un tableau de chaînes de caractères, autant de paramètres passés. Le passage se fait en tapant la commande : java programme parametre1 parametre2 …. Exemple : class ARG { public static void main (String args[]) { int i; System.out.println("les arguments :"); for (i=0; i<args.length ; ++i) System.out.println(args[i]); } for (String d : args) System.out.println (d); Rapprochement vers la boucle foreach() que l'on trouve dans d'autres langages.

Exercice Proposer un programme permettant de définir un tableau de 20 entiers de valeurs initiales 1. Proposer un programme permettant de définir un tableau de 20 entiers correspondant aux 20 premières valeurs de la suite ui = 2*i; i > 0. Proposer un programme permettant de définir un tableau de 2000 entiers de la suite 2000, 1999, 1998, 1997, 1996, 1995, 1994, . . ., . . ., 3, 2, 1. Proposer un programme permettant de remplir, par des lectures au clavier, un tableau de 10 entiers.

Tableau de caractères vs String
char [] tab ={'a','b','c','d'}; String s =new String (tab); System.out.println (s); // affiche abcd char [ ] tab2 = new char [2] ; tab2 [0] = 'h'; tab2 [1] = 'i'; s = new String (tab2); System.out.println (s); // affiche hi

Pointeurs C vs JAVA #include <stdio.h> echanger (int *a, int *b)
{ int c; c=*a; *a=*b; *b=c; } void main() int x=5; int y =10; printf("avant\n"); printf("%d\n",x); printf("%d\n",y); echanger (&x,&y); printf("apres\n"); class Echange { public static void echanger (int [] a) int tmp; tmp=a[0]; a[0]=a[1]; a[1]=tmp; } public static void main (String args[]) int []x=new int [2]; x[0]=5; x[1]=10; System.out.println("avant : "+x[0]+" "+x[1]) ; echanger (x); System.out.println("apres : "+x[0]+" "+x[1]) ;

Fonctions et procédures
Un algorithme a souvent besoin de répéter des séries d’instructions, identiques ou similaires, qui aboutissent à un résultat dépendant des valeurs d’entrée. Il va donc déporter ces tâches de calcul dans un sous-algorithme. Un algorithme peut appeler un sous-algorithme : l’algorithme principal passe ainsi temporairement le contrôle de l’exécution du traitement au sous-algorithme. Un sous-algorithme est conçu pour faire un traitement bien défini, bien délimité, si possible indépendamment du contexte particulier de l’algorithme appelant.

Procédure avec paramètres
public class carre { public static void affichagecarre (int i) System.out.println (i*i) ; } public static void main ( String [ ] Argv ) int y ; y = 8 ; affichagecarre (3) ; affichagecarre (5) ; affichagecarre (y) ; affichagecarre (10) ;

Procédure sans paramètres
public class affichage { public static void affichage5 ( ) int i ; for ( i =1; i <6; i=i+1) System.out.println ( i ) ; } public static void main ( String [ ] Argv ) affichage5 ( );

Fonctions public class PROD {
public static int produit ( int i , int j ) int k ; k=i*j ; return k ; } public static void main ( String [ ] Argv ) int x ; x= produit (5 , 6) ; System.out.println (x) ; x= produit (15 , 3) ;

Fonctions public class MAXI {
public static double maximun( double x , double y ) double z ; if (x<y ) z=y ; } else z=x; return z ; public static void main ( St ring [ ] Argv ) double max ; max= maximun ( 5.0 , 5.1 ) ; System .out.println (max ) ; max= maximun ( , 7.91 ) ;

Instruction d’interruption break
Une instruction break ne peut se situer qu'à l'intérieur du corps d'instruction d'un bloc switch ou de l'une des trois itérations while, do..while, for. Lorsque break est présente dans l'une des trois itérations while, do..while, for : Si break n'est pas suivi d'une étiquette, elle interrompt l'exécution de la boucle dans laquelle elle se trouve, l'exécution se poursuit après le corps d'instruction. Si break est suivi d'une étiquette, elle fonctionne comme un goto : utilisation déconseillée en programmation moderne sauf pour le switch. public static void afficher (int n) { for (int i=1; i<=n;i++) { System.out.print(i+" "); if (i%10==0) break; } System.out.println("bonjour"); public static void main (String args[]) { afficher(17); } bonjour

Instruction de rebouclage continue
Une instruction continue ne peut se situer qu'à l'intérieur du corps d'instruction de l'une des trois itérations while, do..while, for. Lorsque continue est présente dans l'une des trois itérations while, do..while, for : Si continue n'est pas suivi d'une étiquette elle interrompt l'exécution de la séquence des instructions situées après elle, l'exécution par rebouclage de la boucle. Si continue est suivi d'une étiquette elle fonctionne comme un goto : utilisation déconseillée en programmation moderne. public static void afficher(int n){ for (int i=1; i<=n;i++) { if (i%10==0) continue; System.out.print(i+" "); } public static void main (String args[]) { afficher(17); }

Exercice Le palindrome est un mot dont l'ordre des symboles reste le même qu'on le lise de gauche à droite ou de droite à gauche (radar, elle, rever, Engage le jeu que je le gagne, ...). Écrire une fonction inverseChaine qui retourne une chaine de caractères représentant l’inverse de la chaîne passée en paramètre. Écrire une fonction estIdentique qui retourne vrai si les 2 chaînes de caractères passées en paramètres sont identiques, faux sinon. Écrire un programme principal qui utilise intelligemment toutes les fonctions et procédures écrites précédemment. Reprendre les questions précédentes en gérant les espaces et la casse.

Exercice En utilisant des procédures, proposez les algorithmes suivants : Lire un nombre entier et afficher son cube. Lire un entier et afficher "Vrai" si l’entier est pair. Lire un nombre réel x et afficher tous les entiers positifs plus petit que x, ceci tant que x est supérieur à 0.

Exercice En utilisant des fonctions, proposez les algorithmes suivants. A noter qu’il est préférable d’éviter les instructions d’affichage à l’intérieur d’une fonction. Lire un nombre réel et calculer le cube de celui-ci. Lire un nombre entier n et calculer la somme des n premiers entiers (en utilisant une boucle). Lire deux nombres entiers hauteur et largeur puis calculer l’aire du rectangle correspondant. Calculer le maximum de trois nombres. Lire un nombre entre 1 et 7 et afficher le jour de la semaine correspondant. Lire un nombre réel x puis calculer l’arrondi inférieur de x.

Exercice Proposez une fonction lire_entier_pair permettant de lire un entier et d’assurer sa parité. Proposez un jeu permettant de retrouver au clavier un nombre préalablement défini. Tant que le nombre lu n’est pas le bon, le jeu affichera plus petit ou plus grand. La victoire sera marquée par gagné. On affichera au final le nombre de coups nécessaires pour trouver le nombre.

Exercice Proposer une procédure affiche_tableau_entiers (tab : tableau d’entiers) permettant d’afficher un tableau d’entiers. Écrire une fonction créer_tableau qui permet de définir un tableau de 20 entiers correspondant aux 20 premières valeurs de la suite u0 = 1; ui = 3*u i-1 +4; i > 0. La fonction Math.random ( ) permet de générer aléatoirement un nombre réel dans l’intervalle [0; 1[. Pour générer un nombre entier aléatoire compris entre 0 et 100 nous devons multiplier le résultat de la fonction Math.random(), puis convertir le résultat en entier. int x ; x=(int) (Math.random( ) *101 ) ; x aura pour valeur un nombre aléatoire compris entre 0 e t 100. Proposer un programme permettant de définir un tableau de 50 entiers rempli avec des valeurs aléatoires comprises entre 0 et 1000.

Exercice Écrire une fonction somme qui permet de calculer la somme des éléments d’un tableau. Écrire une fonction au_dessus qui prend en paramètre un tableau d’entiers et un entier n. Cette fonction retourne le nombre d’éléments strictement supérieurs à la valeur n. Écrire une fonction moyenne qui permet de calculer la moyenne des éléments d’un tableau. Écrire une fonction maximum qui retourne le maximum des éléments d’un tableau. Écrire une fonction minimum qui retourne le minimum des éléments d’un tableau. Écrire une fonction occurrence qui retourne le nombre d’occurrences d’un entier x parmi les éléments d’un tableau. La valeur de x sera passée en paramètre de la fonction. Écrire une procédure affichage_inverse qui affiche un tableau dans l’ordre inverse.

Exercice Écrire une fonction autreSens qui retourne le tableau d’entiers passé en paramètre dans l’ordre inverse. La première valeur de l’un est donc la dernière valeur de l’autre. Écrire une fonction sousTab qui prend un tableau d’entiers tab, une valeur de départ, une valeur de fin et qui retourne le sous tableau compris entre les indices départ et fin du tableau tab. On prendra soin de vérifier que les valeurs départ et fin sont valides (par exemple fin doit être supérieur à départ). Écrire une fonction compareTab qui retourne vrai si les deux tableaux d’entiers passés en paramètres sont égaux. Écrire une fonction concatTab qui retourne la concaténation de deux tableaux d’entiers passés en paramètres. Ecrire une fonction qui teste si un tableau d'entiers passé en paramètre est trié ou non (la fonction retourne un booléen).

Exercice Écrire la procédure public static void remplissagealeatoire(int [] tableau) qui remplit un tableau de nombres aléatoires compris entre 0 et Écrire la procédure public static void remplissageordrecroissant(int [] tableau) qui remplit un tableau avec des valeurs classées par ordre croissant. Écrire la procédure public static void remplissageordredecroissant(int [] tableau) qui remplit un tableau avec des valeurs classées par ordre décroissant. Écrire la procédure public static void triSelection(int[] tableau) permettant de trier le tableau par selection. La fonction System.currentTimeMillis() ; retourne une valeur de type long égale au nombre de millisecondes écoulées depuis le 1er janvier H00 UTC. En comparant les valeurs retournées avant et après l’exécution d’une fonction nous pouvons en déduire le temps approximatif d’exécution de la fonction.

Exercice long start ; long stop ; start=System.currentTimeMillis ( ) ;
triSelection (tab) ; stop=System.currentTimeMillis ( ) ; System.out.println ( "Temps tri du tableau : "+(stops-start ) ) ; Modifier la procédure main de la classe précédente pour afficher : Le temps pour trier un tableau rempli de nombres aléatoires. Le temps pour trier un tableau rempli de nombres trier par ordre croissant. Le temps pour trier un tableau rempli de nombres trier par ordre décroissant. Créer une nouvelle classe TriBulle et répéter les questions précédentes mais appliquées au tri bulle. Compléter le fichier TriRapide.java afin de comparer les temps d’exécution du tri par sélection et du tri bulle avec le tri rapide. Attention : Pour exécuter TriRapide, utilisez la syntaxe suivante : java -Xss4m TriRapide

Formation Développeur Java Introduction à la programmation en Java

Présentations similaires

Présentation au sujet: "Formation Développeur Java Introduction à la programmation en Java"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

Formation Développeur Java Introduction à la programmation en Java

Présentations similaires

Présentation au sujet: "Formation Développeur Java Introduction à la programmation en Java"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back