Résumé

Apprendre Java en douceur

Vous avez décidé de vous initier à la programmation et souhaitez opter pour un langage largement utilisé dans le monde professionnel ? Java se révèle un choix idéal comme vous le constaterez dans ce livre conçu pour les vrais débutants en programmation.

Vous apprendrez d’abord, à travers des exemples simples en Java, à maîtriser les notions communes à tous les langages : variables, types de données, boucles et instructions conditionnelles, etc. Vous franchirez un nouveau pas en découvrant par la pratique les concepts de la programmation orientée objet (classes, objets, héritage), puis le fonctionnement des librairies graphiques AWT et Swing (fenêtres, gestion de la souris, tracé de graphiques). Cet ouvrage vous expliquera aussi comment réaliser des applications Java dotées d’interfaces graphiques conviviales grâce au logiciel libre NetBeans. Enfin, vous vous initierez au développement d’applications pour téléphones mobiles Android.

Chaque chapitre est accompagné de deux types de travaux pratiques : des exercices, dont le corrigé est fourni sur le site de l’auteur, et un projet développé au fil de l’ouvrage, qui vous montrera comment combiner toutes les techniques de programmation étudiées pour construire une véritable application Java.

À qui s’adresse ce livre ?

• Aux étudiants de 1er cycle universitaire (IUT, Deug…) ou d’écoles d’ingénieurs

• Aux vrais débutants en programmation : passionnés d’informatique et programmeurs autodidactes, concepteurs de sites Web souhaitant aller au-delà de HTML et JavaScript, etc.

• Aux enseignants et formateurs recherchant une méthode pédagogique et un support de cours pour enseigner Java à des débutants

Au sommaire

Introduction. Qu’est-ce qu’un programme ? • Construire un algorithme • Premier exemple de programme en Java • Exécution du programme • Présentation du projet détaillé dans l’ouvrage (application de gestion de compte bancaire). Techniques de base de la programmation. Stocker une information • Types de données • Variables et opérateur d’affectation • Expressions et opérateurs arithmétiques • Les entrées-sorties, la classe Scanner • Affichage et saisie des données • Instructions if-else et switch • Boucles do…while, while et for. Initiation à la programmation orientée objet. De l’algorithme paramétré à l’écriture de fonctions • Fonctions Java prédéfinies • Construire ses propres fonctions • Variables locales et variables de classe • Passage de paramètres par valeur • Classes et objets • Exemple : la classe String et ses méthodes • Construire et utiliser ses propres classes • Les données de type static • Passage de paramètres par référence • La notion d’encapsulation des données • Constructeurs d’objets • Héritage et polymorphisme. Programmation objet avancée et interfaces graphiques. Tableaux à une et deux dimensions • Programmation dynamique : listes et dictionnaires • Types génériques • L’archivage des données : fichiers texte et fichiers d’objets • Gestion des exceptions • Programmation d’interfaces graphiques : la librairie AWT et la librairie Swing • Construire une fenêtre • Dessiner dans une fenêtre • Gérer les événements liés au clavier et à la souris • Créer une interface graphique avec NetBeans • Développer une application Android. Annexe. Extensions Web • Installation d'un environnement de développement sous Windows, Mac et Linux • Utilisation des outils de développement.

Sur le site www.annetasso.fr

• Consultez les corrigés du projet et des exercices

• Téléchargez le code source de tous les exemples du livre

• Dialoguez avec l’auteur

Biographie auteur

Anne Tasso

Maître de conférences à l’université Paris-Est Marne-la-Vallée, Anne Tasso enseigne les langages de programmation Java et ActionScript, en formation initiale et continue, au sein du département SRC (Services et réseaux de communication) de l’IUT de Marne-la-Vallée. Son public universitaire est essentiellement constitué de débutants en programmation, ce qui lui a permis d’élaborer une méthode pédagogique structurée et imagée. Son objectif est d’expliquer, avec des mots simples, les techniques de programmation jusqu’à un niveau avancé. Elle est aussi l’auteur de l’ouvrage Apprendre à programmer en ActionScript 3, paru aux éditions Eyrolles.

www.editions-eyrolles.com

Anne Tasso

Le livre de
Java
premier langage

8e édition

ÉDITIONS EYROLLES

61, bd Saint-Germain

75240 Paris Cedex 05

www.editions-eyrolles.com

En application de la loi du 11 mars 1957, il est interdit de reproduire intégralement ou partiellement le présent ouvrage, sur quelque support que ce soit, sans l’autorisation de l’Éditeur ou du Centre Français d’exploitation du droit de copie, 20, rue des Grands Augustins, 75006 Paris.

© Groupe Eyrolles, 2000-2012, ISBN : 978-2-212-13538-1

CHEZ LE MÊME ÉDITEUR

Du même auteur

A. TASSO. – Apprendre à programmer en ActionScript 3 (3e édition).

N°12778, 2010, 574 pages.

Autres ouvrages sur Java

C. DELANNOY. – Programmer en Java (8e édition).

N°13566, 2012, 896 pages + DVD-Rom.

C. DELANNOY. – Programmer en Java (6e édition). Java 5 et 6.

N°13443, 2012, 788 pages (format semi-poche).

C. DELANNOY. – Exercices en Java.

N°13358, 2011, 330 pages.

J.-B. BOICHAT. – Apprendre Java et C++ en parallèle (4e édition).

N°12403, 2008, 600 pages + CD-Rom.

J. BOUGEAULT. – Java - La maîtrise. Java 5 et 6.

N°12250, 2008, 550 pages.

A. PATRICIO. – Java Persistence et Hibernate

N°12259, 2008, 364 pages.

E. PUYBARET. – Les Cahiers du programmeur Java (3e édition). Java 1.4 et 5.0.

N°11916, 2006, 370 pages + CD-Rom.

R. FLEURY. – Les Cahiers du programmeur Java/XML.

N°11316, 2004, 218 pages.

P. HAGGAR. – Mieux programmer en Java. 68 astuces pour optimiser son code.

N°9171, 2000, 256 pages.

J.-P. RETAILLÉ....

Avec cette huitième édition, je tiens à remercier tous mes nombreux lecteurs pour leurs félicitations qui me vont droit au cœur et leurs remarques toujours constructives.

Je remercie également tous mes étudiants qui par leurs incompréhensions, leurs questions et leur curiosité m’ont permis d’écrire ce livre avec le désir d’apporter des explications claires et lisibles.

Merci aussi à Sylvain Roby pour son aide ponctuelle et très efficace.

Et enfin, un merci tout particulier à Antoine Derouin qui m’offre le temps de faire naître chaque livre avec beaucoup d’esprit, d’attention et de patience.

Avant-propos

Organisation de l’ouvrage

Ce livre est tout particulièrement destiné aux débutants qui souhaitent aborder l’apprentissage de la programmation en utilisant le langage Java comme premier langage.

Les concepts fondamentaux de la programmation y sont présentés de façon évolutive, grâce à un découpage de l’ouvrage en trois parties, chacune couvrant un aspect différent des outils et techniques de programmation.

Le chapitre introductif, « Naissance d’un programme », constitue le préalable nécessaire à la bonne compréhension des parties suivantes. Il introduit aux mécanismes de construction d’un algorithme, compte tenu du fonctionnement interne de l’ordinateur, et explique les notions de langage informatique, de compilation et d’exécution à travers un exemple de programme écrit en Java.

La première partie concerne l’étude des « Outils et techniques de base » :

• Le chapitre 1, « Stocker une information », aborde la notion de variables et de types. Il présente comment stocker une donnée en mémoire, calculer des expressions mathématiques ou échanger deux valeurs, et montre comment le type d’une variable peut influencer le résultat d’un calcul.

• Le chapitre 2, « Communiquer une information », explique comment transmettre des valeurs à l’ordinateur par l’intermédiaire du clavier et montre comment l’ordinateur fournit des résultats en affichant des messages à l’écran.

• Le chapitre 3, « Faire des choix », examine comment tester des valeurs et prendre des décisions en fonction du résultat. Il traite de la comparaison de valeurs ainsi que de l’arborescence de choix. Avec en exemple, la nouvelle structure de test switch de la version 7 de Java.

• Le chapitre 4, « Faire des répétitions », est consacré à l’étude des outils de répétition et d’itération. Il aborde les notions d’incrémentation et d’accumulation de valeurs (compter et faire la somme d’une collection de valeurs).

La deuxième partie, « Initiation à la programmation orientée objet », introduit les concepts fondamentaux indispensables à la programmation objet.

• Le chapitre 5, « De l’algorithme paramétré à l’écriture de fonctions », montre l’intérêt de l’emploi de fonctions dans la programmation. Il examine les différentes étapes de leur création.

• Le chapitre 6, « Fonctions, notions avancées », décrit très précisément comment manipuler les fonctions et leurs paramètres. Il définit les termes de variable locale et de classe, et explique le passage de paramètres par valeur.

• Le chapitre 7, « Les classes et les objets », explique à partir de l’étude de la classe String, ce que sont les classes et les objets dans le langage Java. Il montre ensuite comment définir de nouvelles classes et construire des objets propres à l’application développée. Avec en exemple, une nouvelle façon de comparer des chaînes de caractères grâce à la nouvelle structure de test switch de la version 7 de Java.

• Le chapitre 8, « Les principes du concept d’objet », développe plus particulièrement comment les objets se communiquent l’information, en expliquant notamment le principe du passage de paramètres par référence. Il décrit ensuite les principes fondateurs de la notion d’objet, c’est-à-dire l’encapsulation des données (protection et contrôle des données, constructeur de classe) ainsi que l’héritage entre classes et la notion d’interfaces.

La troisième partie, « Outils et techniques orientés objet », donne tous les détails sur l’organisation, le traitement et l’exploitation intelligente des objets.

• Le chapitre 9, « Collectionner un nombre fixe d’objets », concerne l’organisation des données sous la forme d’un tableau de taille fixe.

• Le chapitre 10, « Collectionner un nombre indéterminé d’objets », présente les différents outils qui permettent d’organiser dynamiquement en mémoire les ensembles de données de même nature. Il est également consacré aux différentes techniques d’archivage et à la façon d’accéder aux informations stockées sous forme de fichiers.

• Le chapitre 11, « Dessiner des objets », couvre une grande partie des outils graphiques proposés par le langage Java (bibliothèques AWT et Swing). Il analyse le concept événement-action.

• Le chapitre 12, « Créer une interface graphique », expose dans un premier temps le fonctionnement de base de l’environnement de programmation NetBeans. Puis, à travers trois exemples très pratiques, il montre comment concevoir des applications munies d’interfaces graphiques conviviales.

• Le chapitre 13, « Développer une application Android », décrit comment créer votre toute première application Android, tout en expliquant la structure de base nécessaire au déploiement de cette application. Il présente ensuite le développement d’une application plus élaborée ainsi que sa mise à disposition sur un serveur dédié.

Ce livre contient également en annexe :

• un guide d’installation détaillé des outils nécessaires au développement des applications Java (Java, NetBeans), sous Linux, Mac OS X et sous Windows 2000, NT, XP et Vista ;

• toutes les explications nécessaires pour construire votre environnement de développement d’applications Java ou Android, que ce soit en mode commande ou en utilisant la plateforme NetBeans ;

• un index, qui vous aidera à retrouver une information sur le thème que vous recherchez (les mots-clés du langage, les exemples, les principes de fonctionnement, les classes et leurs méthodes, etc.).

Chaque chapitre se termine sur une série d’exercices offrant au lecteur la possibilité de mettre en pratique les notions qui viennent d’être étudiées. Un projet est également proposé au fil des chapitres afin de développer une application de gestion d’un compte bancaire. La mise en œuvre de cette application constitue un fil rouge qui permettra au lecteur de combiner toutes les techniques de programmation étudiées au fur et à mesure de l’ouvrage, afin de construire une véritable application Java.

Les codes sources des exemples, des exercices et du projet sont téléchargeables depuis l’extension Web...

Introduction

Naissance d’un programme

Aujourd’hui, l’informatique en général et l’ordinateur en particulier sont d’un usage courant. Grâce à Internet, l’informatique donne accès à une information mondiale. Elle donne aussi la possibilité de traiter cette information pour analyser, gérer, prévoir ou concevoir des événements dans des domaines aussi divers que la météo, la médecine, l’économie, la bureautique, etc.

Cette communication et ces traitements ne sont possibles qu’au travers de l’outil informatique. Cependant, toutes ces facultés résultent davantage de l’application d’un programme résidant sur l’ordinateur que de l’ordinateur lui-même. En fait, le programme est à l’ordinateur ce que l’esprit est à l’être humain.

Créer une application, c’est apporter de l’esprit à l’ordinateur. Pour que cet esprit donne sa pleine mesure, il est certes nécessaire de bien connaître le langage des ordinateurs, mais, surtout, il est indispensable de savoir programmer. La programmation est l’art d’analyser un problème afin d’en extraire la marche à suivre, l’algorithme susceptible de résoudre ce problème.

C’est pourquoi ce chapitre commence par aborder la notion d’algorithme. À partir d’un exemple tiré de la vie courante, nous déterminons les étapes essentielles à l’élaboration d’un programme (voir section « Construire un algorithme »). À la section suivante, « Qu’est-ce qu’un ordinateur ? », nous examinons le rôle et le fonctionnement de l’ordinateur dans le passage de l’algorithme au programme. Nous étudions ensuite, à travers un exemple simple, comment écrire un programme en Java et l’exécuter (voir section « Un premier programme en Java, ou comment parler à un ordinateur »). Enfin, nous décrivons, à la section « Le projet : Gestion d’un compte bancaire », le cahier des charges de l’application projet que le lecteur assidu peut réaliser en suivant les exercices décrits à la fin de chaque chapitre.

Construire un algorithme

Un ordinateur muni de l’application adéquate traite une information. Il sait calculer, compter, trier ou rechercher l’information, dans la mesure où un programmeur lui a donné les ordres à exécuter et la marche à suivre pour arriver au résultat.

Cette marche à suivre s’appelle un algorithme.

Déterminer l’algorithme, c’est trouver un cheminement de tâches à fournir à l’ordinateur pour qu’il les exécute. Voyons comment s’y prendre pour construire cette marche à suivre.

Ne faire qu’une seule chose à la fois

Avant de réaliser une application concrète, telle que celle proposée en projet dans cet ouvrage, nécessairement complexe par la diversité des tâches qu’elle doit réaliser, simplifions-nous la tâche en ne cherchant à résoudre qu’un problème à la fois.

Considérons que créer une application, c’est décomposer cette dernière en plusieurs sousapplications qui, à leur tour, se décomposent en micro-applications, jusqu’à descendre au niveau le plus élémentaire. Cette démarche est appelée analyse descendante. Elle est le principe de base de toute construction algorithmique.

Pour bien comprendre cette démarche, penchons-nous sur un problème réel et simple à résoudre : comment faire un café chaud non sucré ?

Exemple : l’algorithme du café chaud

Construire un algorithme, c’est avant tout analyser l’énoncé du problème afin de définir l’ensemble des objets à manipuler pour obtenir un résultat.

Définition des objets manipulés

Analysons l’énoncé suivant :

Comment faire un café chaud non sucré ?

Chaque mot a son importance, et « non sucré » est aussi important que « café » ou « chaud ». Le terme « non sucré » implique qu’il n’est pas nécessaire de prendre du sucre ni une petite cuillère.

Notons que tous les ingrédients et ustensiles nécessaires ne sont pas cités dans l’énoncé. En particulier, nous ne savons pas si nous disposons d’une cafetière électrique ou non. Pour résoudre notre problème, nous devons prendre certaines décisions, et ces dernières vont avoir une influence sur l’allure générale de notre algorithme.

Supposons que, pour réaliser notre café, nous soyons en possession des ustensiles et ingrédients suivants :

café moulu

filtre

eau

pichet

cafetière électrique

tasse

électricité

table

En fixant la liste des ingrédients et des ustensiles, nous définissons un environnement, une base de travail. Nous sommes ainsi en mesure d’établir une liste de toutes les actions à mener pour résoudre le problème et de construire la marche à suivre permettant d’obtenir un café.

Liste des opérations

Verser l'eau dans la cafetière, le café dans la tasse, le café dans le filtre.

Remplir le pichet d'eau.

Prendre du café moulu, une tasse, de l'eau, une cafetière électrique, un filtre, le pichet de la cafetière.

Brancher, allumer ou éteindre la cafetière électrique.

Attendre que le café remplisse le pichet.

Poser la tasse, la cafetière sur la table, le filtre dans la cafetière, le pichet dans la cafetière.

Cette énumération est une description de toutes les actions nécessaires à la réalisation d’un café chaud.

Chaque action est un fragment du problème donné et ne peut plus être découpée. Chaque action est élémentaire par rapport à l’environnement que nous nous sommes donné.

En définissant l’ensemble des actions possibles, nous créons un langage minimal qui nous permet de réaliser le café. Ce langage est composé de verbes (Prendre, Poser, Verser, Faire, Attendre, etc.) et d’objets (Café moulu, Eau, Filtre, Tasse, etc.).

La taille du langage, c’est-à-dire le nombre de mots qu’il renferme, est déterminée par l’environnement. Pour cet exemple, nous avons, en précisant les hypothèses, volontairement choisi...

Partie I

Outils et techniques de base

Chapitre 1

Stocker une information

En décrivant, au chapitre introductif, « Naissance d’un programme », l’algorithme de confection d’un café chaud non sucré, nous avons constaté que la toute première étape pour élaborer une marche à suivre consistait à déterminer les objets utiles à la résolution du problème. En effet, pour faire du café, nous devons prendre le café, l’eau, le filtre, etc.

De la même façon, lorsqu’un développeur d’applications conçoit un programme, il doit non pas « prendre », au sens littéral du mot, les données numériques mais définir ces données ainsi que les objets nécessaires à la réalisation du programme. Cette définition consiste à nommer ces objets et à décrire leur contenu afin qu’ils puissent être stockés en mémoire.

C’est pourquoi nous étudions dans ce chapitre ce qu’est une variable et comment la définir (voir section « La notion de variable »). Nous examinons ensuite, à la section « L’instruction d’affectation », comment placer une valeur dans une variable, par l’intermédiaire de l’instruction d’affectation. Enfin, nous analysons l’incidence du type des variables sur le résultat d’un calcul arithmétique (voir section « Les opérateurs arithmétiques »).

Afin de clarifier les explications, vous trouverez tout au long du chapitre des exemples simples et concis. Ces exemples ne sont pas des programmes complets mais de simples extraits, qui éclairent un point précis du concept abordé. Vous trouverez en fin de chapitre (voir section « Calculer des statistiques sur des opérations bancaires »), un programme entier qui aborde et résume toutes les notions rencontrées au fil de ce chapitre.

La notion de variable

Une variable permet la manipulation de données et de valeurs. Elle est caractérisée par les éléments suivants :

• Un nom, qui sert à repérer un emplacement en mémoire dans lequel une valeur est placée. Le choix du nom d’une variable est libre. Il existe cependant des contraintes, que nous présentons à la section « Les noms de variables ».

• Un type, qui détermine la façon dont est traduite la valeur en code binaire ainsi que la taille de l’emplacement mémoire. Nous examinons ce concept à la section « La notion de type ». Plusieurs types simples sont prédéfinis dans le langage Java, et nous en détaillons les caractéristiques à la section « Les types de base en Java ».

Les noms de variables

Le choix des noms de variables n’est pas limité. Il est toutefois recommandé d’utiliser des noms évocateurs. Par exemple, les noms des variables utilisées dans une application qui gère les codes-barres de produits vendus en magasin sont plus certainement article, prix, codebarre que xyz1, xyz2, xyz3. Les premiers, en effet, évoquent mieux l’information stockée que les seconds.

Les contraintes suivantes sont à respecter dans l’écriture des noms de variables :

• Le premier caractère d’une variable doit obligatoirement être différent d’un chiffre.

• Aucun espace ne peut figurer dans un nom.

• Les majuscules sont différentes des minuscules, et tout nom de variable possédant une majuscule est différent du même nom écrit en minuscule.

• Les caractères &, ~, ", #, ', {, }, (, ), [, ], -, |, `, \, ^, @, =, %, *, ?, :, /, §, !, <, >, ainsi que ; et , ne peuvent être utilisés dans l’écriture d’un nom de variable.

Tout autre caractère peut être utilisé, y compris les caractères accentués, le caractère de soulignement (_), les caractères grecs (µ) et les symboles monétaires $, _, £, etc.).

Le nombre de lettres composant le nom d’une variable est indéfini. Néanmoins, l’objectif d’un nom de variable étant de renseigner le programmeur sur le contenu de la variable, il n’est pas courant de rencontrer des noms de variables de plus de trente lettres.

Parmi les variables suivantes quelles sont celles dont le nom n’est pas autorisé, et pourquoi ?

Compte, pourquoi#pas, Num_2, -plus, Undeux, 2001espace, @adresse, VALEUR_temporaire, ah!ah!, Val$solde

Les noms des variables suivantes ne sont pas autorisés :

pourquoi#pas, -plus, @adresse, ah!ah!, car les caractères #, -, @ et ! sont interdits.

2001espace car, il n’est pas possible de placer un chiffre en début de variable.

Par contre les noms de variable autorisés sont :

Compte, Num_2 (" _ " et non pas " – "), Undeux ( et non pas un deux ), VALEUR_temporaire, Val$solde.

La notion de type

Un programme doit gérer des informations de nature diverse. Ainsi, les valeurs telles que 123 ou 2.4 sont de type numérique tandis que Spinoza est un mot composé de caractères. Si l’être humain sait, d’un simple coup d’œil, faire la distinction entre un nombre et un mot, l’ordinateur n’en est pas capable. Le programmeur doit donc « expliquer » à l’ordinateur la nature de chaque donnée. Cette explication passe par la notion de type.

Le type d’une valeur permet de différencier la nature de l’information stockée dans une variable. À chaque type sont associés les éléments suivants :

• Un code spécifique permettant la traduction de l’information en binaire et réciproquement.

• Un ensemble d’opérations réalisables en fonction du type de variable utilisé. Par exemple, si la division est une opération cohérente pour deux valeurs numériques, elle ne l’est pas pour deux valeurs de type caractère.

• Un intervalle de valeurs possibles dépendant du codage utilisé. Par définition, à chaque type correspond un même nombre d’octets et, par conséquent, un nombre limité de valeurs différentes.

En effet, un octet est un regroupement de 8 bits, sachant qu’un bit ne peut être qu’un 0 ou un 1. Lorsqu’une donnée est codée sur 1 octet, elle peut prendre les valeurs 00000000 (8 zéros), ou encore 111111111 (8 un) et toutes les valeurs intermédiaires entre ces deux extrêmes (par exemple 10101010, 11110000 ou...

Chapitre 2

Communiquer une information

Un programme n’a d’intérêt que s’il produit un résultat. Pour communiquer ce résultat, l’ordinateur utilise l’écran. Cette action, qui consiste à afficher un message, est appelée opération de sortie, ou d’écriture, de données.

Parallèlement, un programme ne produit de résultats que si l’utilisateur lui fournit au préalable des informations. Ces informations, ou données, sont transmises au programme le plus souvent par l’intermédiaire d’un clavier. Dans le jargon informatique, cette opération est appelée opération de saisie, d’entrée ou encore de lecture de données.

Dans ce chapitre, nous commençons par étudier les fonctionnalités proposées par le langage Java pour gérer les opérations d’entrée-sortie (voir section « La bibliothèque System »).

À la section « L’affichage de données », nous examinons ensuite comment afficher à l’écran des messages et des données. Enfin, à la section « La saisie de données », nous proposons une technique de saisie de valeurs au clavier.

La bibliothèque System

Nous l’avons vu dans les exemples des chapitres précédents, l’affichage de valeurs ou de texte est réalisé par l’utilisation d’une fonction prédéfinie du langage Java. Cette fonction a pour nom d’appel System.out.print().

Pourquoi un nom si complexe, pour réaliser une action aussi « simple » que l’affichage de données ?

Le langage Java est accompagné d’un ensemble de bibliothèques de programmes préécrits, qui épargnent au programmeur d’avoir à réécrire ce qui a déjà été fait depuis les débuts de l’ère informatique. Ces bibliothèques portent chacune un nom qui renseigne sur leur fonctionnalité. Ainsi, la bibliothèque où se trouve l’ensemble des fonctions de calcul mathématique s’appelle Math, et celle relative à la gestion des éléments de bas niveau (écran, clavier, etc.) impliquant le système de l’ordinateur s’appelle System.

La gestion de l’affichage d’un message à l’écran ou la saisie de valeurs au clavier fait partie des fonctions impliquant le système de l’ordinateur. C’est pourquoi le nom d’appel de telles fonctions a pour premier terme System.

Les opérations d’entrée ou de sortie de données impliquent le système de l’ordinateur mais sont en rapport inverse l’une de l’autre. Pour dissocier ces opérations, la bibliothèque System est composée de deux sous-ensembles, in et out. L’affichage est une opération de sortie et fait donc partie des éléments out de la classe System. Le point (.) qui relie le mot System à out permet d’expliquer à l’ordinateur que l’on souhaite accéder au sous-ensemble out de la bibliothèque System plutôt qu’au sous-ensemble in. Pour finir, nous faisons appel, dans le sous-ensemble out, à la fonction print(), qui affiche un message à l’écran. Le nom de la fonction print() signifie imprimer, car,...

Chapitre 3

Faire des choix

Une fois les variables définies et les valeurs stockées en mémoire, l’ordinateur est capable de les tester ou de les comparer de façon à réaliser une instruction plutôt qu’une autre, suivant le résultat de la comparaison.

Le programme n’est alors plus exécuté de façon séquentielle (de la première ligne jusqu’à la dernière). L’ordre est rompu, une ou plusieurs instructions étant ignorées en fonction du résultat du test. Le programme peut s’exécuter, en tenant compte de contraintes imposées par le programmeur.

Dans ce chapitre, nous abordons la notion de choix ou de test, en reprenant l’algorithme du café chaud, pour le transformer en un algorithme du café chaud sucré ou non (voir section « L’algorithme du café chaud, sucré ou non »).

Ensuite, à la section « L’instruction if-else », nous étudions la structure if-else proposée par le langage Java, qui permet de réaliser des choix.

Enfin, à la section « L’instruction switch, ou comment faire des choix multiples », nous examinons le concept de choix multiples par l’intermédiaire de la structure switch.

L’algorithme du café chaud, sucré ou non

Pour mieux comprendre la notion de choix, nous allons reprendre l’algorithme du café chaud pour le transformer en algorithme du café chaud, sucré ou non. L’énoncé ainsi transformé nous oblige à modifier la liste des objets manipulés, ainsi que celle des opérations à réaliser.

Définition des objets manipulés

Pour obtenir du café sucré, nous devons ajouter à notre liste un nouvel ingrédient, le sucre, et un nouvel ustensile, la petite cuillère.

café moulu

filtre

eau

cafetière électrique

tasse

électricité

table

sucre

petite cuillère

Liste des opérations

De la même façon, nous devons modifier la liste des opérations, de façon qu’elle prenne en compte les nouvelles données :

Verser l'eau dans la cafetière, le café dans la tasse, le café dans le filtre.

Prendre du café moulu, une tasse, de l'eau, une cafetière électrique, un filtre, un morceau de sucre, une petite cuillère.

Brancher, allumer ou éteindre la cafetière électrique.

Attendre que le café soit prêt.

Poser la tasse, la cafetière sur la table, le filtre dans la cafetière, le sucre dans la tasse, la petite cuillère dans la tasse.

Ordonner la liste des opérations

Ainsi modifiée, la liste des opérations doit être réordonnée afin de rechercher le moment le mieux adapté pour ajouter les nouvelles opérations :

• En décidant de prendre le sucre et la petite cuillère en même temps que le café et le filtre, nous plaçons les nouvelles instructions "prendre…" entre les instructions 2 et 3 définies à la section « Ordonner la liste des opérations » du chapitre introductif, « Naissance d’un programme ».

• En décidant de poser le sucre et la petite cuillère dans la tasse avant d’y verser le café, nous écrivons les nouvelles instructions " poser…" avant l’instruction 15 du même exemple.

Nous obtenons la liste des opérations suivantes :

0. Prendre une cafetière.

1. Poser la cafetière sur la table.

2. Prendre du café.

3. Prendre un morceau de sucre.

4. Prendre une petite cuillère.

5. Prendre un filtre.

6. Verser le café dans le filtre.

7. Prendre de l'eau.

8. Verser l'eau dans la cafetière.

9. Brancher la cafetière.

10. Allumer la cafetière.

11. Attendre que le café soit prêt.

12. Prendre une tasse.

13. Poser la tasse sur la table.

14. Poser le sucre dans la tasse.

15. Poser la petite cuillère dans la tasse.

16. Éteindre la cafetière.

17. Verser le café dans la tasse.

Écrite ainsi, cette marche à suivre nous permet d’obtenir un café chaud...

Chapitre 4

Faire des répétitions

La notion de répétition est une des notions fondamentales de la programmation. En effet, beaucoup de traitements informatiques sont répétitifs. Par exemple, la création d’un agenda électronique nécessite de saisir un nom, un prénom et un numéro de téléphone autant de fois qu’il y a de personnes dans l’agenda.

Dans de tels cas, la solution n’est pas d’écrire un programme qui comporte autant d’instructions de saisie qu’il y a de personnes mais de faire répéter par le programme le jeu d’instructions nécessaires à la saisie d’une seule personne. Pour ce faire, le programmeur utilise des instructions spécifiques, appelées structures de répétition, ou boucles, qui permettent de déterminer la ou les instructions à répéter.

Dans ce chapitre, nous abordons la notion de répétition à partir d’un exemple imagé (voir section « Combien de sucres dans votre café »).

Nous étudions ensuite les différentes structures de boucles proposées par le langage Java (sections « La boucle do…while », « La boucle while » et « La boucle for »). Pour chacune de ces structures, nous présentons et analysons un exemple afin d’examiner les différentes techniques de programmation associées aux structures répétitives.

Combien de sucres dans votre café ?

Pour bien comprendre la notion de répétition ou de boucle, nous allons améliorer l’algorithme du café chaud sucré, de sorte que le programme demande à l’utilisateur de prendre un morceau de sucre autant de fois qu’il le souhaite. Pour cela, nous reprenons uniquement le bloc d’instructions II Préparer le sucre (voir, au chapitre 3, « Faire des choix », la section « L’algorithme du café chaud, sucré ou non »).

Instructions
Bloc d’instructions

Si (café sucré)

1. Prendre une petite cuillère.

2. Poser la petite cuillère dans la tasse.

3. Prendre un morceau de sucre.

4. Poser le sucre dans la tasse.

II Préparer le sucre

L’exécution du bloc d’instructions II Préparer le sucre nous permet de mettre un seul morceau de sucre dans la tasse. Si nous désirons mettre plus de sucre, nous devons exécuter les instructions 3 et 4 autant de fois que nous souhaitons de morceaux de sucre. La marche à suivre devient dès lors :

Prendre une petite cuillère.

Poser la petite cuillère dans la tasse.

Début répéter :

1. Prendre un morceau de sucre.

2. Poser le sucre dans la tasse.

3. Poser la question : "Souhaitez-vous un autre morceau de sucre ?"

4. Attendre la réponse.

Tant que la réponse est OUI, retourner à Début répéter.

Analysons les résultats possibles de cette nouvelle marche à suivre :

• Dans tous les cas, nous prenons et posons une petite cuillère.

• Ensuite, nous entrons sans condition dans une structure de répétition.

• Nous prenons et posons un morceau de sucre, quelle que soit la suite des opérations. De cette façon, si nous sortons de la boucle, le café est quand même sucré.

• Puis le programme nous demande si nous souhaitons à nouveau un morceau de sucre.

• Si notre réponse est OUI, le programme retourne au début de la structure répétitive, place le sucre dans la tasse et demande de nouveau si nous souhaitons du sucre, etc.

• Si la réponse est négative, la répétition s’arrête, ainsi que la marche à suivre.

Pour écrire une boucle, il est nécessaire de déterminer où se trouve le début de la boucle et où se situe la fin (Début répéter et Tant que pour notre exemple).

La sortie de la structure répétitive est soumise à la réalisation ou non d’une condition (la réponse fournie est-elle affirmative ou non ?).

Le résultat du test de sortie de boucle est modifiable par une instruction placée à l’intérieur de la boucle (la valeur de la réponse est modifiée par l’instruction 4. Attendre la réponse).

Que se passe-t-il si l’on place les instructions :

Prendre une petite cuillère.

Poser la petite cuillère dans la tasse.

à l’intérieur de la structure de répétition :

Début répéter :

…

Tant que la réponse est OUI, retourner à Début répéter.

Les deux instructions sont répétées autant de fois que l’on souhaite ajouter un morceau de sucre. Nous aurons donc autant de petites cuillères que de morceaux de sucre.

Dans le langage informatique, la construction d’une répétition ou boucle suit le même modèle. Dans le langage Java, il existe trois types de boucles, qui sont décrites par les constructions suivantes :

do…while | Faire… tant que
while | Tant que
for | Pour

Dans la suite de ce chapitre, nous allons, pour chacune de ces boucles :

• Étudier la syntaxe.

• Analyser les principes de fonctionnement.

• Donner un exemple qui introduise un concept fondamental de la programmation, à savoir le compteur de boucle, l’accumulation de valeurs ou la recherche d’une donnée parmi un...

Partie II

Initiation à la programmation orientée objet

Partie III

Outils et techniques orientés objet

Index

.class 25

.java 24

= 50

A

accès

données 211

en consultation 238, 280, 309

en modification 208, 238

méthode 212

accesseur 238

accumulation 112, 115, 122, 133

action 350

actionPerformed 400

adresse 10, 15, 192, 203, 233

affectation 47, 51, 63

afficher 16

algorithme 5, 8, 31

paramétré 144, 161

analyse descendante 6

Android

AndroidManifest 494

background 485

Bundle 479

CheckBox 491, 495

drawable 477

fill_parent 474

finish() 497

id 485

ImageView 491

Intent 493

isChecked() 496

layout 475, 479

layout_width 476

Log.i() 497

openFileInput() 498

orientation 475, 491

read() 498

setChecked() 499

setContentView() 479

setOnClickListener() 488

tActivity 481

text 486

tfindViewById() 488

Toast 489

values 476

view 481

wrap_content 474

write() 497

application 209

exemple 212, 230, 236, 239

multifichier 213

archivage 318

ArrayList 429

syntaxe 302

Voir liste 302

ASCII 42

attribut 216

AWT package 304

B

bibliothèque

Voir package 304

binaire

Voir code 22

bloc 21

if-else 98, 104

instruction 88, 110, 143, 167, 171, 185

Bloc-notes 323

boolean 40

bouton

Voir Classe Button 351

break 101...