Les bases de l'informatique et de la programmation

10% de réduction sur vos envois d'emailing --> CLIQUEZ ICI

Retour à l'accueil, cliquez ici

Source : http://www.enseignement.polytechnique.fr/profs/informatique/Francois.Morain/TC/X2005/Poly/polyX05.pdf

Les bases de l'informatique et de la programmation Ecole  polytechnique Francois Morain22Table des matieres I Introduction a la programmation 11 1 Les premiers pas en Java 13 1.1 Le premier programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 1.1.1 Ecriture  et execution . . . . . . . . . . . . . . . . . . . . . . . . . 13 1.1.2 Analyse de ce programme . . . . . . . . . . . . . . . . . . . . . . 14 1.2 Faire des calculs simples . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 1.3 Types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 1.4 Declaration des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 1.5 Aectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 1.6 Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 1.6.1 Regles d'evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . 18 1.6.2 Incrementation et decrementation . . . . . . . . . . . . . . . . . 18 1.7 Methodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2 Suite d'instructions 21 2.1 Expressions booleennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.1.1 Operateurs de comparaisons . . . . . . . . . . . . . . . . . . . . . 21 2.1.2 Connecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.2 Instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.2.1 If-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.2.2 Forme compacte . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.2.3 Aiguillage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.3 Iterations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 2.3.1 Boucles pour (for) . . . . . . . . . . . . . . . . . . . . . . . . . 24 2.3.2 Iterations tant que . . . . . . . . . . . . . . . . . . . . . . . . . . 26 2.3.3 Iterations repeter tant que . . . . . . . . . . . . . . . . . . . . . . 27 2.4 Terminaison des programmes . . . . . . . . . . . . . . . . . . . . . . . . 28 2.5 Instructions de rupture de contr^ole . . . . . . . . . . . . . . . . . . . . . 28 2.6 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 2.6.1 Methode de Newton . . . . . . . . . . . . . . . . . . . . . . . . . 28 3 Methodes : theorie et pratique 31 3.1 Pourquoi ecrire des methodes . . . . . . . . . . . . . . . . . . . . . . . . 31 3.2 Comment ecrire des methodes . . . . . . . . . . . . . . . . . . . . . . . . 32 3.2.1 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 3.2.2 Le type special void . . . . . . . . . . . . . . . . . . . . . . . . . 33 3.2.3 La surcharge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 34 TABLE DES MATIERES  3.3 Visibilite des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 3.4 Quelques conseils pour ecrire un programme . . . . . . . . . . . . . . . . 36 3.5 Quelques exemples de programmes complets . . . . . . . . . . . . . . . . 37 3.5.1 Ecriture  binaire d'un entier . . . . . . . . . . . . . . . . . . . . . 37 3.5.2 Calcul du jour correspondant a une date . . . . . . . . . . . . . . 38 4 Tableaux 43 4.1 Declaration, construction, initialisation . . . . . . . . . . . . . . . . . . . 43 4.2 Representation en memoire et consequences . . . . . . . . . . . . . . . . 44 4.3 Tableaux a plusieurs dimensions, matrices . . . . . . . . . . . . . . . . . 47 4.4 Les tableaux comme arguments de fonction . . . . . . . . . . . . . . . . 48 4.5 Exemples d'utilisation des tableaux . . . . . . . . . . . . . . . . . . . . . 49 4.5.1 Algorithmique des tableaux . . . . . . . . . . . . . . . . . . . . . 49 4.5.2 Un peu d'algebre lineaire . . . . . . . . . . . . . . . . . . . . . . 51 4.5.3 Le crible d'Eratosthene . . . . . . . . . . . . . . . . . . . . . . . 52 4.5.4 Jouons a la bataille rangee . . . . . . . . . . . . . . . . . . . . . 54 4.5.5 Pile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 5 Composants d'une classe 59 5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 5.1.1 Declaration et creation . . . . . . . . . . . . . . . . . . . . . . . . 59 5.1.2 Objet et reference . . . . . . . . . . . . . . . . . . . . . . . . . . 60 5.1.3 Constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 5.2 Autres composants d'une classe . . . . . . . . . . . . . . . . . . . . . . . 62 5.2.1 Methodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 5.2.2 Passage par reference . . . . . . . . . . . . . . . . . . . . . . . . 62 5.2.3 Variables de classe . . . . . . . . . . . . . . . . . . . . . . . . . . 63 5.2.4 Utiliser plusieurs classes . . . . . . . . . . . . . . . . . . . . . . . 63 5.3 Autre exemple de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 5.4 Public et private . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 6 Recursivite 65 6.1 Premiers exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 6.2 Un piege subtil : les nombres de Fibonacci . . . . . . . . . . . . . . . . . 68 6.3 Fonctions mutuellement recursives . . . . . . . . . . . . . . . . . . . . . 70 6.3.1 Pair et impair sont dans un bateau . . . . . . . . . . . . . . . . . 70 6.3.2 Developpement du sinus et du cosinus . . . . . . . . . . . . . . . 71 6.4 Le probleme de la terminaison . . . . . . . . . . . . . . . . . . . . . . . . 72 7 Introduction a la complexite des algorithmes 73 7.1 Complexite des algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . 73 7.2 Calculs elementaires de complexite . . . . . . . . . . . . . . . . . . . . . 74 7.3 Quelques algorithmes sur les tableaux . . . . . . . . . . . . . . . . . . . 74 7.3.1 Recherche du plus petit element . . . . . . . . . . . . . . . . . . 74 7.3.2 Recherche dichotomique . . . . . . . . . . . . . . . . . . . . . . . 75 7.3.3 Recherche simultanee du maximum et du minimum . . . . . . . 76 7.4 Diviser pour resoudre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 7.4.1 Recherche d'une racine par dichotomie . . . . . . . . . . . . . . . 78 7.4.2 Exponentielle binaire . . . . . . . . . . . . . . . . . . . . . . . . . 78TABLE DES MATIERES  5 7.4.3 Les tours de Hanoi . . . . . . . . . . . . . . . . . . . . . . . . . . 80 8 Introduction aux structures de donnees dynamiques 83 8.1 Operations elementaires sur les listes . . . . . . . . . . . . . . . . . . . . 84 8.1.1 Creation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 8.1.2 Achage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 8.1.3 Longueur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 8.1.4 Le i-eme element . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 8.1.5 Ajouter des elements en queue de liste . . . . . . . . . . . . . . . 87 8.1.6 Copier une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 8.1.7 Suppression de la premiere occurrence . . . . . . . . . . . . . . . 89 8.2 Interlude : tableau ou liste ? . . . . . . . . . . . . . . . . . . . . . . . . . 90 8.3 Partages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 8.3.1 Insertion dans une liste triee . . . . . . . . . . . . . . . . . . . . 91 8.3.2 Inverser les eches . . . . . . . . . . . . . . . . . . . . . . . . . . 92 8.4 Exemple de gestion de la memoire au plus juste . . . . . . . . . . . . . . 92 9 Introduction a la programmation objet 95 9.1 Methodes de classe et methodes d'objet . . . . . . . . . . . . . . . . . . 95 9.2 Un exemple de classe predenie : la classe String . . . . . . . . . . . . 96 9.2.1 Proprietes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 9.2.2 Arguments de main . . . . . . . . . . . . . . . . . . . . . . . . . 98 II Problematiques classiques en informatique 101 10 Ranger l'information . . . pour la retrouver 103 10.1 Recherche en table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 10.1.1 Recherche lineaire . . . . . . . . . . . . . . . . . . . . . . . . . . 103 10.1.2 Recherche dichotomique . . . . . . . . . . . . . . . . . . . . . . . 104 10.1.3 Utilisation d'index . . . . . . . . . . . . . . . . . . . . . . . . . . 106 10.2 Trier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 10.2.1 Tris elementaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 10.2.2 Un tri rapide : le tri par fusion . . . . . . . . . . . . . . . . . . . 109 10.3 Stockage d'informations reliees entre elles . . . . . . . . . . . . . . . . . 112 10.3.1 Piles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 10.3.2 Files d'attente . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 10.3.3 Information hierarchique . . . . . . . . . . . . . . . . . . . . . . . 116 10.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 11 Recherche exhaustive 125 11.1 Rechercher dans du texte . . . . . . . . . . . . . . . . . . . . . . . . . . 125 11.2 Le probleme du sac-a-dos . . . . . . . . . . . . . . . . . . . . . . . . . . 130 11.2.1 Premieres solutions . . . . . . . . . . . . . . . . . . . . . . . . . . 130 11.2.2 Deuxieme approche . . . . . . . . . . . . . . . . . . . . . . . . . 131 11.2.3 Code de Gray* . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 11.2.4 Retour arriere (backtrack) . . . . . . . . . . . . . . . . . . . . . . 137 11.3 Permutations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 11.3.1 Fabrication des permutations . . . . . . . . . . . . . . . . . . . . 1416 TABLE DES MATIERES  11.3.2 En umeration des permutations . . . . . . . . . . . . . . . . . . . 142 11.4 Les n reines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 11.4.1 Prelude : les n tours . . . . . . . . . . . . . . . . . . . . . . . . . 143 11.4.2 Des reines sur un echiquier . . . . . . . . . . . . . . . . . . . . . 143 11.5 Les ordinateurs jouent aux echecs . . . . . . . . . . . . . . . . . . . . . . 145 11.5.1 Principes des programmes de jeu . . . . . . . . . . . . . . . . . . 145 11.5.2 Retour aux echecs . . . . . . . . . . . . . . . . . . . . . . . . . . 146 12 Polyn^omes et transformee de Fourier 149 12.1 La classe Polynome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 12.1.1 Denition de la classe . . . . . . . . . . . . . . . . . . . . . . . . 149 12.1.2 Creation, achage . . . . . . . . . . . . . . . . . . . . . . . . . . 150 12.1.3 Predicats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 12.1.4 Premiers tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 12.2 Premieres fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 12.2.1 Derivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 12.2.2 Ev aluation ; schema de Horner . . . . . . . . . . . . . . . . . . . 153 12.3 Addition, soustraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 12.4 Deux algorithmes de multiplication . . . . . . . . . . . . . . . . . . . . . 156 12.4.1 Multiplication nave . . . . . . . . . . . . . . . . . . . . . . . . . 156 12.4.2 L'algorithme de Karatsuba . . . . . . . . . . . . . . . . . . . . . 157 12.5 Multiplication a l'aide de la transformee de Fourier* . . . . . . . . . . . 162 12.5.1 Transformee de Fourier . . . . . . . . . . . . . . . . . . . . . . . 163 12.5.2 Application a la multiplication de polyn^omes . . . . . . . . . . . 163 12.5.3 Transformee rapide . . . . . . . . . . . . . . . . . . . . . . . . . . 164 III Systeme et reseaux 167 13 Internet 169 13.1 Breve histoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 13.1.1 Quelques dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 13.1.2 Quelques chires . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 13.1.3 Topologie du reseau . . . . . . . . . . . . . . . . . . . . . . . . . 170 13.2 Le protocole IP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170 13.2.1 Principes generaux . . . . . . . . . . . . . . . . . . . . . . . . . . 170 13.2.2 A quoi ressemble un paquet ? . . . . . . . . . . . . . . . . . . . . 171 13.2.3 Principes du routage . . . . . . . . . . . . . . . . . . . . . . . . . 173 13.3 Le reseau de l'Ecole  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 13.4 Internet est-il un monde sans lois ? . . . . . . . . . . . . . . . . . . . . 174 13.4.1 Le mode de fonctionnement d'Internet . . . . . . . . . . . . . . 174 13.4.2 Securite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 13.5 Une application phare : le courrier electronique . . . . . . . . . . . . . . 176 13.5.1 Envoi et reception . . . . . . . . . . . . . . . . . . . . . . . . . . 176 13.5.2 Encore plus precisement . . . . . . . . . . . . . . . . . . . . . . . 176 13.5.3 Le format des mails . . . . . . . . . . . . . . . . . . . . . . . . . 177TABLE DES MATIERES  7 14 Principes de base des systemes Unix 179 14.1 Survol du systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 14.2 Le systeme de chiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 14.3 Les processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 14.3.1 Comment traquer les processus . . . . . . . . . . . . . . . . . . . 182 14.3.2 Fabrication et gestion . . . . . . . . . . . . . . . . . . . . . . . . 182 14.3.3 L'ordonnancement des t^aches . . . . . . . . . . . . . . . . . . . . 186 14.3.4 La gestion memoire . . . . . . . . . . . . . . . . . . . . . . . . . 186 14.3.5 Le mystere du demarrage . . . . . . . . . . . . . . . . . . . . . . 187 14.4 Gestion des ux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 14.5 Proteger l'utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 15 Securite 191 15.1 Parefeu et ltrage de paquets . . . . . . . . . . . . . . . . . . . . . . . . 191 15.1.1 Attaque par submersion . . . . . . . . . . . . . . . . . . . . . . . 191 15.1.2 Spoong . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192 15.1.3 Le ltrage des paquets . . . . . . . . . . . . . . . . . . . . . . . . 192 15.2 Les virus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 15.2.1 Breve histoire (d'apres E.  Filiol ; O. Zilbertin) . . . . . . . . . . . 193 15.2.2 Le cas de Nimda . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 15.2.3 Un peu de theorie . . . . . . . . . . . . . . . . . . . . . . . . . . 194 15.2.4 Conclusion sur les virus . . . . . . . . . . . . . . . . . . . . . . . 195 15.3 En guise de conclusion : nouveaux contextes = danger . . . . . . . . . . 195 IV Annexes 197 A Complements 199 A.1 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199 A.2 La classe MacLib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200 A.2.1 Fonctions elementaires . . . . . . . . . . . . . . . . . . . . . . . . 200 A.2.2 Rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 A.2.3 La classe Maclib . . . . . . . . . . . . . . . . . . . . . . . . . . 202 A.2.4 Jeu de balle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 A.3 La classe TC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204 A.3.1 Fonctionnalites, exemples . . . . . . . . . . . . . . . . . . . . . . 204 A.3.2 La classe Efichier . . . . . . . . . . . . . . . . . . . . . . . . . 207 Table des gures 2118 TABLE DES MATIERES Introduction Les audacieux font fortune a Java. Ce polycopie s'adresse a des eleves de premiere annee ayant peu ou pas de connais- sances en informatique. Une partie de ce cours consistitue une introduction generale a l'informatique, aux logiciels, materiels, environnements informatiques et a la science sous-jacente. Une autre partie consiste a etablir les bases de la programmation et de l'algo- rithmique, en etudiant un langage. On introduit des structures de donnees simples : scalaires, cha^nes de caracteres, tableaux, et des structures de contr^ole elementaires comme l'iteration, la recursivite. Nous avons choisi Java pour cette introduction a la programmation car c'est un langage type assez repandu qui permet de s'initier aux diverses constructions presentes dans la plupart des langages de programmation modernes. A ces cours sont couples des seances de travaux diriges et pratiques qui sont beau- coup plus qu'un complement au cours, puisque c'est en ecrivant des programmes que l'on apprend l'informatique. Comment lire ce polycopie ? La premiere partie decrit les principaux traits d'un langage de programmation (ici Java), ainsi que les principes generaux de la program- mation simple. Une deuxieme partie presente quelques grandes classes de problemes que les ordinateurs traitent plut^ot bien. La troisieme est plus culturelle et decrit quelques grands domaines de l'informatique. Un passage indique par une etoile (*) peut ^etre saute en premiere lecture. Remerciements Je remercie chaleureusement Jean-Jacques Levy et Robert Cori pour m'avoir permis de reutiliser des parties de leurs polycopies anciens ou nouveaux. G. Guillerm m'a aide pour le chapitre Internet, J. Marchand pour le courrier electronique, T. Besancon pour NFS. Qu'ils en soient remercie ici, ainsi que E. Thome pour ses coups de main, V. Menissier-Morain pour son aide. Je remercie egalement les relecteurs de la presente version : T. Clausen, E.  Duris, C. Gwiggner, J.-R. Reinhard ; E. Waller, ce dernier etant egalement le beta-testeur de mes transparents d'amphis, ce qui les a rendus d'autant plus justes. Le polycopie a ete ecrit avec LATEX, il est consultable a l'adresse : http ://www.enseignement.polytechnique.fr/informatique/ Les erreurs seront corrigees des qu'elles me seront signalees et les mises a jour seront eectuees sur la version html. Polycopie, version 1.9, mars 2006 910 TABLE DES MATIERES Premiere partie Introduction a la programmation 11Chapitre 1 Les premiers pas en Java Dans ce chapitre on donne quelques elements simples de la programmation avec le langage Java : types, variables, aectations, fonctions. Ce sont des traits communs a tous les langages de programmation. 1.1 Le premier programme 1.1.1 Ecriture  et execution Commencons par un exemple simple de programme. C'est un classique, il s'agit simplement d'acher Bonjour ! a l'ecran. // Voici mon premier programme public class Premier{ public static void main(String[] args){ System.out.println("Bonjour !"); return; } } Pour executer ce programme il faut commencer par le copier dans un chier. Pour cela on utilise un editeur de texte (par exemple nedit) pour creer un chier de nom Premier.java (le m^eme nom que celui qui suit class). Ce chier doit contenir le texte du programme. Apres avoir tape le texte, on doit le traduire (les informaticiens disent compiler) dans un langage que comprend l'ordinateur. Cette compilation se fait a l'aide de la commande 1 unix% javac Premier.java Ceci a pour eet de faire construire par le compilateur un chier Premier.class, que la machine virtuelle de Java rendra comprehensible pour l'ordinateur : unix% java Premier 1 Une ligne commencant par unix% indique une commande tapee en Unix. 1314 CHAPITRE 1. LES PREMIERS PAS EN JAVA On voit s'acher : Bonjour ! 1.1.2 Analyse de ce programme Un langage de programmation est comme un langage humain. Il y a un ensemble de lettres avec lesquelles on forme des mots. Les mots forment des phrases, les phrases des paragraphes, ceux-ci forment des chapitres qui rassembles donnent naissance a un livre. L'alphabet de Java est peu ou prou l'alphabet que nous connaissons, avec des lettres, des chires, quelques signes de ponctuation. Les mots seront les mots-clefs du langage (comme class, public, etc.), ou formeront les noms des variables que nous utiliserons plus loin. Les phrases seront pour nous des instructions, les paragraphes des fonctions (appelees methodes dans la terminologie des langages a objets). Les chapitres seront les classes, les livres des programmes que nous pourrons executer et utiliser. Le premier chapitre d'un livre est l'amorce du livre et ne peut generalement ^etre saute. En Java, un programme debute toujours a partir d'une methode speciale, appelee main et dont la syntaxe immuable est : public static void main(String[] args) Nous verrons plus loin ce que veulent dire les mots magiques public, static et void, args contient quant a lui des arguments qu'on peut passer au programme. Reprenons la methode main : public static void main(String[] args){ System.out.println("Bonjour !"); return; } Les accolades f et g servent a constituer un bloc d'instructions ; elles doivent en- glober les instructions d'une methode, de m^eme qu'une paire d'accolades doit englober l'ensemble des methodes d'une classe. Notons qu'en Java les instructions se terminent toutes par un ; (point-virgule). Ainsi, dans la suite le symbole I signiera soit une instruction (qui se termine donc par ;) soit une suite d'instructions (chacune nissant par ;) placees entre accolades. La methode eectuant le travail est la methode System.out.println qui appar- tient a une classe predenie, la classe System. En Java, les classes peuvent s'appeler les unes les autres, ce qui permet une approche modulaire de la programmation : on n'a pas a recrire tout le temps la m^eme chose. Notons que nous avons ecrit les instructions de chaque ligne en respectant un decalage bien precis (on parle d'indentation). La methode System.out.println etant executee a l'interieur de la methode main, elle est decalee de plusieurs blancs (ici 4) sur la droite. L'indentation permet de bien structurer ses programmes, elle est systematiquement utilisee partout. La derniere instruction presente dans la methode main est l'instruction return; que nous comprendrons pour le moment comme voulant dire : rendons la main a l'uti- lisateur qui nous a lance. Nous en preciserons le sens a la section 1.7.1.2. FAIRE DES CALCULS SIMPLES 15 La derniere chose a dire sur ce petit programme est qu'il contient un commentaire, repere par // et se terminant a la n de la ligne. Les commentaires ne sont utiles qu'a des lecteurs (humains) du texte du programme, ils n'auront aucun eet sur la compilation ou l'execution. Ils sont tres utiles pour comprendre le programme. 1.2 Faire des calculs simples On peut se servir de Java pour realiser les operations d'une calculette elementaire : on aecte la valeur d'une expression a une variable et on demande ensuite l'achage de la valeur de la variable en question. Bien entendu, un langage de programmation n'est pas fait uniquement pour cela, toutefois cela nous donne quelques exemples de programmes simples ; nous passerons plus tard a des programmes plus complexes. // Voici mon deuxieme ` programme public class PremierCalcul{ public static void main(String[] args){ int a; a = 5 * 3; System.out.println(a); a = 287 % 7; System.out.println(a); return; } } Dans ce programme on voit appara^tre une variable de nom a qui est declaree au debut. Comme les valeurs qu'elle prend sont des entiers elle est dite de type entier. Le mot int 2 qui precede le nom de la variable est une declaration de type. Il indique que la variable est de type entier et ne prendra donc que des valeurs entieres lors de l'execution du programme. Par la suite, on lui aecte deux fois une valeur qui est ensuite achee. Les resultats aches seront 15 et 0. Dans l'operation a % b, le symbole % designe l'operation modulo qui est le reste de la division euclidienne de a par b (quand a et b sont positifs). Insistons un peu sur la facon dont le programme est execute par l'ordinateur. Celui- ci lit les instructions du programme une a une en commencant par la methode main, et les traite dans l'ordre ou elles apparaissent. Il s'arr^ete des qu'il rencontre l'instruction return;, qui est generalement la derniere presente dans une methode. Nous revien- drons sur le mode de traitement des instructions quand nous introduirons de nouvelles constructions (iteration, recursion). 1.3 Types primitifs Un type en programmation precise l'ensemble des valeurs que peut prendre une variable ; les operations que l'on peut eectuer sur une variable dependent de son type. 2 Une abreviation de l'anglais integer, le g etant prononce comme un j francais.16 CHAPITRE 1. LES PREMIERS PAS EN JAVA Le type des variables que l'on utilise dans un programme Java doit ^etre declare. Parmi les types possibles, les plus simples sont les types primitifs. Il y a peu de types primitifs : les entiers, les reels, les caracteres et les booleens. Les principaux types entiers sont int et long, le premier utilise 32 bits pour representer un nombre ; sachant que le premier bit est reserve au signe, un int fait reference a un entier de l'intervalle [2 31 ; 2 311]. Si lors d'un calcul, un nombre depasse cette valeur le resulat obtenu n'est pas utilisable. Le type long permet d'avoir des mots de 64 bits (entiers de l'intervalle [2 63 ; 2 63 1]) et on peut donc travailler sur des entiers plus grands. Il y a aussi les types byte et short qui permettent d'utiliser des mots de 8 et 16 bits. Les operations sur les int sont toutes les operations arithmetiques classiques : les operations de comparaison : egal (==), dierent de (!=), plus petit (<), plus grand (>) et les operations de calcul comme addition (+), soustraction (-), multiplication (*), division (/), reste (%). Dans ce dernier cas, precisons que a/b calcule le quotient de la division euclidienne de a par b et que a % b en calcule le reste. Par suite int q = 2/3; contient le quotient de la division euclidienne de 2 par 3, c'est-a-dire 0. Les types reels (en fait, des nombres dont le developpement binaire est ni) sont float et double, le premier se contente d'une precision dite simple, le second donne la possibilite d'une plus grande precision, on dit que l'on a une double precision. Les caracteres sont declares par le type char au standard Unicode. Ils sont codes sur 16 bits et permettent de representer toutes les langues de la planete (les caracteres habituels des claviers des langues europeennes se codent uniquement sur 8 bits). Le standard Unicode respecte l'ordre alphabetique. Ainsi le code de 'a' est inferieur a celui de 'd', et celui de 'A' a celui de 'D'. Le type des booleens est boolean et ses deux valeurs possibles sont true et false. Les operations sont et, ou, et non ; elles se notent respectivement &&, ||, !. Si a et b sont deux booleens, le resultat de a && b est true si et seulement si a et b sont tous deux egaux a true. Celui de a || b est true si et seulement si l'un de a ou b est egal a true. Enn !a est true quand a est false et reciproquement. Les booleens sont utilises dans les conditions decrites au chapitre suivant. 1.4 Declaration des variables La declaration du type des variables est obligatoire en Java, mais elle peut se faire a l'interieur d'une methode et pas necessairement au debut de celle-ci. Une declaration se presente sous la forme d'un nom de type suivi soit d'un nom de variable, soit d'une suite de noms de variables separes par des virgules. En voici quelques exemples : int a, b, c; float x; char ch; boolean u, v; 1.5 Aectation On a vu qu'une variable a un nom et un type. L'operation la plus courante sur les variables est l'aectation d'une valeur. Elle s'ecrit :