Computer Science: An Interdisciplinary Approach est un ouvrage de référence destiné à

fournir une introduction complète à l'informatique en mettant l'accent sur son rôle
interdisciplinaire. Il est conçu pour offrir aux étudiants une compréhension fondamentale de
l'informatique en abordant non seulement les concepts théoriques et pratiques de l'informatique,
mais aussi en montrant comment ces concepts s'appliquent dans des contextes variés, allant des
sciences fondamentales aux applications technologiques avancées.

Objectifs du livre :

L'objectif principal de ce livre est de donner aux étudiants une base solide en informatique tout en
illustrant son importance et son impact dans d'autres domaines scientifiques. L'ouvrage couvre
une gamme de sujets allant de la programmation de base aux concepts plus avancés comme les
algorithmes, la théorie de l'informatique, et les systèmes informatiques. Le livre adopte une
approche interdisciplinaire pour aider les étudiants à comprendre non seulement comment
l'informatique fonctionne, mais aussi comment elle peut être utilisée pour résoudre des problèmes
dans des domaines comme la biologie, la physique, l'ingénierie, les sciences sociales, et bien
d'autres.

Contenu du livre :

1. Introduction à la programmation : Les premiers chapitres abordent les concepts

fondamentaux de la programmation, notamment l'utilisation des langages de
programmation (comme Java et Python), les structures de données de base (tableaux,
listes, piles), les fonctions, et les principes de la programmation orientée objet.
2. Algorithmes et structures de données : Une attention particulière est donnée aux
algorithmes classiques (tri, recherche, etc.) et aux structures de données utilisées pour
organiser et traiter l'information de manière efficace.
3. Théorie de l'informatique : Le livre explore des sujets théoriques comme les automates,
les langages formels, la complexité algorithmique et les problèmes NP-complets, en
fournissant une base de connaissances essentielle pour toute personne souhaitant se
spécialiser en informatique.
4. Applications interdisciplinaires : L'un des points forts du livre est son approche
interdisciplinaire, qui montre comment l'informatique s'applique à des domaines variés
tels que la biologie (par exemple, la bioinformatique), la physique (simulation de
systèmes physiques), l'ingénierie (conception de systèmes et d'algorithmes), et même les
sciences sociales (analyse de données et systèmes complexes).
5. Machine-learning et intelligence artificielle : Le livre explore également des sujets
modernes comme l'intelligence artificielle et le machine learning, en mettant en lumière la
manière dont ces technologies transforment de nombreux domaines scientifiques.
6. Conception de systèmes informatiques : La dernière partie du livre aborde la conception
et l'architecture des systèmes informatiques, y compris la programmation bas niveau, la
gestion des ressources, et les bases de la conception des systèmes distribués.

Public cible :
  Étudiants en informatique : Bien que le livre soit principalement destiné aux étudiants
en informatique, il est également adapté aux étudiants d'autres disciplines qui souhaitent
comprendre le rôle de l'informatique dans leur domaine.
 Interdisciplinarité : Le livre est particulièrement bénéfique pour les étudiants en
biologie, en physique, en ingénierie, en sciences sociales, et dans d'autres domaines où la
technologie et l'informatique jouent un rôle clé.
 Formations spécialisées : Il peut également servir de manuel de cours pour des
formations d'introduction à l'informatique dans les écoles d'ingénieurs ou les universités,
ainsi que pour des programmes destinés à des étudiants débutants en informatique.

Approche pédagogique :

L'approche interdisciplinaire permet de motiver les étudiants en leur montrant des applications
concrètes de l'informatique dans des contextes réels. Chaque concept est illustré par des exemples
tirés de différentes disciplines, ce qui aide les étudiants à comprendre l'importance et l'impact de
l'informatique au-delà des frontières traditionnelles de la science informatique.

Versions et extensions :

 Le livre existe en plusieurs éditions et a été traduit en plusieurs langues.

 Une version de ce livre est également disponible en se concentrant spécifiquement sur la
programmation en Java ou Python, selon l'orientation du cours ou des besoins des
étudiants.

En résumé, Computer Science: An Interdisciplinary Approach offre une base complète en

informatique tout en soulignant son rôle central dans le monde moderne, avec une approche qui
relie les concepts informatiques à des applications pratiques dans des domaines scientifiques
divers. C’est un ouvrage de référence qui permet aux étudiants de comprendre l'informatique
dans un contexte global et interconnecté.

La base de l'éducation au cours du dernier millénaire était "lire, écrire et compter" ;

aujourd'hui, elle est "lire, écrire et calculer". Apprendre à programmer est une partie
essentielle de l'éducation de chaque étudiant dans les sciences et l'ingénierie.

Au-delà des applications directes, cela constitue la première étape pour comprendre l'impact
indéniable de l'informatique sur le monde moderne. Ce livre vise à enseigner la programmation à
ceux qui en ont besoin ou qui souhaitent l'apprendre, dans un contexte scientifique.

Notre objectif principal est d'autonomiser les étudiants en leur fournissant l'expérience et les
outils de base nécessaires pour utiliser l'informatique de manière efficace. Notre approche
consiste à enseigner aux étudiants que composer un programme est une expérience naturelle,
satisfaisante et créative.
Nous introduisons progressivement des concepts essentiels, utilisons des applications classiques
des mathématiques appliquées et des sciences pour illustrer ces concepts, et offrons aux étudiants
des occasions d'écrire des programmes pour résoudre des problèmes intéressants.

Nous utilisons le langage de programmation Java pour tous les programmes de ce livre — nous
mentionnons "Java" après "programmation" dans le titre pour souligner que ce livre traite des
concepts fondamentaux de la programmation, et non spécifiquement de Java. Ce livre enseigne
les compétences de base pour la résolution de problèmes informatiques qui sont applicables dans
de nombreux environnements informatiques modernes, et constitue un ouvrage autonome destiné
aux personnes n'ayant aucune expérience préalable en programmation.

Ce livre adopte une approche interdisciplinaire du programme traditionnel de CS1, en mettant en

lumière le rôle de l'informatique dans d'autres disciplines, de la science des matériaux à la
génomique, de l'astrophysique aux systèmes de réseaux. Cette approche souligne auprès des
étudiants l'idée essentielle que les mathématiques, les sciences, l'ingénierie et l'informatique sont
interconnectées dans le monde moderne. Bien qu'il s'agisse d'un manuel de CS1 conçu pour tous
les étudiants de première année universitaire, ce livre peut également être utilisé pour l'auto-
apprentissage ou comme complément dans un cours qui intègre la programmation avec un autre
domaine.

Couverture

Le livre est organisé autour de quatre étapes de l'apprentissage de la programmation : les

éléments de base, les fonctions, la programmation orientée objet, et les algorithmes (avec les
structures de données). Nous fournissons les informations de base dont les lecteurs ont besoin
pour renforcer leur confiance en leur capacité à composer des programmes à chaque niveau,
avant de passer au niveau suivant. Une caractéristique essentielle de notre approche est
l'utilisation de programmes exemples qui résolvent des problèmes fascinants, accompagnés
d'exercices allant des exercices d'auto-apprentissage aux problèmes plus complexes nécessitant
des solutions créatives.

Les éléments de base incluent les variables, les instructions d'affectation, les types de données
intégrés, le contrôle de flux, les tableaux, et l'entrée/sortie, y compris les graphiques et le son.

Les fonctions et les modules constituent la première exposition de l'étudiant à la programmation

modulaire. Nous nous appuyons sur la familiarité avec les fonctions mathématiques pour
introduire les fonctions Java, puis nous abordons les implications de la programmation avec des
fonctions, y compris les bibliothèques de fonctions et la récursion. Nous insistons sur l'idée
fondamentale de diviser un programme en composants qui peuvent être débogués, maintenus et
réutilisés indépendamment.

La programmation orientée objet est notre introduction à l'abstraction des données. Nous mettons
l'accent sur les concepts de types de données et leur implémentation à l'aide du mécanisme des
classes en Java. Nous enseignons aux étudiants comment utiliser, créer et concevoir des types de
données. La modularité, l'encapsulation et d'autres paradigmes modernes de programmation sont
les concepts centraux de cette étape.
Les algorithmes et les structures de données combinent ces paradigmes modernes de
programmation avec les méthodes classiques d'organisation et de traitement des données qui
restent efficaces pour les applications modernes. Nous fournissons une introduction aux
algorithmes classiques de tri et de recherche, ainsi qu'aux structures de données fondamentales et
à leurs applications, en mettant l'accent sur l'utilisation de la méthode scientifique pour
comprendre les caractéristiques de performance des implémentations.

Les applications en science et en ingénierie sont une caractéristique clé du texte. Nous motivons
chaque concept de programmation que nous abordons en examinant son impact sur des
applications spécifiques. Nous tirons des exemples des mathématiques appliquées, des sciences
physiques et biologiques, et de l'informatique elle-même, et incluons des simulations de systèmes
physiques, des méthodes numériques, de la visualisation de données, de la synthèse sonore, du
traitement d'images, des simulations financières et des technologies de l'information. Des
exemples spécifiques incluent une présentation, dès le premier chapitre, des chaînes de Markov
pour le classement des pages web, ainsi que des études de cas traitant du problème de
percolation, de la simulation à n-corps et du phénomène de petits mondes. Ces applications font
partie intégrante du texte. Elles engagent les étudiants dans le contenu, illustrent l'importance des
concepts de programmation et fournissent des preuves convaincantes du rôle essentiel joué par
l'informatique dans les sciences et l'ingénierie modernes.

Notre objectif principal est d'enseigner les mécanismes spécifiques et les compétences
nécessaires pour développer des solutions efficaces à tout problème de programmation.
Nous travaillons avec des programmes Java complets et encourageons les lecteurs à les
utiliser. Nous nous concentrons sur la programmation individuelle, et non sur la
programmation à grande échelle.

Textes associés

Ce livre est la deuxième édition de notre texte de 2008, qui intègre des centaines d'améliorations
découvertes après une autre décennie d'enseignement du contenu, y compris, par exemple, un
nouveau traitement des algorithmes de hachage.
Les quatre chapitres de ce livre sont identiques aux quatre premiers chapitres de notre ouvrage
Computer Science: An Interdisciplinary Approach. Ce livre est un cours d'introduction complet à
l'informatique, contenant des chapitres supplémentaires sur la théorie de l'informatique, la
programmation en langage machine et l'architecture des machines. Nous avons publié ce livre
séparément pour répondre aux besoins des personnes intéressées uniquement par le contenu sur la
programmation en Java. Nous avons également publié une version de ce livre basée sur la
programmation en Python.

Les chapitres de ce volume constituent une préparation appropriée pour notre livre Algorithms,
Fourth Edition, qui propose un traitement approfondi des algorithmes les plus importants utilisés
aujourd'hui.

Utilisation dans le programme

Ce livre est adapté pour un cours de première année universitaire destiné à enseigner la
programmation aux débutants dans le contexte des applications scientifiques. Un étudiant
universitaire qui suit un cours basé sur ce livre apprendra à programmer dans un contexte
familier. Les étudiants qui terminent un cours basé sur ce livre seront bien préparés à appliquer
leurs compétences dans des cours ultérieurs de leur spécialité et sauront reconnaître quand une
formation supplémentaire en informatique pourrait être bénéfique.

Les enseignants intéressés par un cours d'un an (ou un cours accéléré d'un semestre avec une
couverture plus large) devraient envisager d'adopter Computer Science: An Interdisciplinary
Approach.

Les futurs étudiants en informatique, en particulier, peuvent tirer profit de l'apprentissage de la

programmation dans le contexte des applications scientifiques. Un informaticien a besoin du
même bagage de base en méthode scientifique et de la même exposition au rôle du calcul dans les
sciences qu'un biologiste, un ingénieur ou un physicien.
En effet, notre approche interdisciplinaire permet aux collèges et universités d'enseigner aux
futurs étudiants en informatique ainsi qu'à ceux des autres disciplines dans le même cours. Nous
couvrons le matériel prescrit par le programme CS1, mais notre accent sur les applications donne
vie aux concepts et motive les étudiants à les apprendre. Notre approche interdisciplinaire expose
les étudiants à des problèmes dans de nombreuses disciplines différentes, les aidant ainsi à choisir
leur spécialité plus judicieusement.

Positionnement du livre dans le programme

Quelle que soit la spécificité du mécanisme, l'utilisation de ce livre est idéale au début du
programme d'études. Cette position permet de tirer parti des connaissances préalables en
mathématiques et en sciences acquises au lycée. De plus, les étudiants qui apprennent à
programmer tôt dans leur cursus universitaire seront ensuite en mesure d'utiliser les ordinateurs
de manière plus efficace lorsqu'ils suivront des cours dans leur spécialité. Tout comme la lecture
et l'écriture, la programmation est destinée à devenir une compétence essentielle pour tout
scientifique ou ingénieur. Les étudiants ayant maîtrisé les concepts de ce livre continueront à
développer cette compétence tout au long de leur vie, récoltant les bénéfices de l'exploitation de
l'informatique pour résoudre ou mieux comprendre les problèmes et projets qui surgiront dans
leur domaine choisi.

Prérequis

Ce livre est adapté aux étudiants de première année universitaire classiques. Autrement dit, nous
n'attendons pas de préparation au-delà de celle généralement requise pour les autres cours
d'introduction aux sciences et aux mathématiques.

Une certaine maturité mathématique est importante. Bien que nous n'insistions pas sur les
concepts mathématiques, nous faisons référence au programme de mathématiques que les
étudiants ont suivi au lycée, y compris l'algèbre, la géométrie et la trigonométrie. La plupart des
étudiants de notre public cible satisfont automatiquement ces prérequis. En fait, nous tirons parti
de cette familiarité avec le programme pour introduire les concepts de base de la programmation.

La curiosité scientifique est également un ingrédient essentiel. Les étudiants en sciences et en

ingénierie arrivent souvent avec un sens de fascination pour la capacité de l'enquête scientifique à
aider à expliquer ce qui se passe dans la nature. Nous exploitons cette tendance en proposant des
exemples de programmes simples qui révèlent des aspects fascinants du monde naturel. Nous ne
supposons aucune connaissance spécifique au-delà de celle fournie par les cours typiques de
lycée en mathématiques, physique, biologie ou chimie.

Expérience en programmation

Aucune expérience en programmation n'est nécessaire, mais elle n'est pas non plus nuisible.
L'enseignement de la programmation est notre objectif principal, donc nous ne supposons aucune
expérience préalable en programmation. Toutefois, composer un programme pour résoudre un
nouveau problème est une tâche intellectuelle stimulante. Ainsi, les étudiants ayant déjà écrit de
nombreux programmes au lycée peuvent bénéficier de suivre un cours d'introduction à la
programmation basé sur ce livre.

Ce livre peut soutenir l'enseignement à des étudiants de niveaux variés, car ses applications
intéressent à la fois les novices et les experts.

Expérience avec un ordinateur

L'expérience avec un ordinateur n'est pas nécessaire, mais elle n'est pas non plus un problème.
Les étudiants universitaires utilisent régulièrement des ordinateurs — pour communiquer avec
leurs amis et leur famille, écouter de la musique, traiter des photos, et dans bien d'autres activités.
La prise de conscience qu'ils peuvent exploiter la puissance de leur propre ordinateur de manière
intéressante et importante est une leçon passionnante et durable.

Objectifs

Nous couvrons le programme CS1, mais toute personne ayant enseigné un cours d'introduction à
la programmation sait que les attentes des enseignants dans les cours ultérieurs sont généralement
élevées : chaque professeur attend des étudiants qu'ils soient familiers avec l'environnement
informatique et l'approche qu'il ou elle souhaite utiliser. Par exemple, un professeur de physique
pourrait s'attendre à ce que les étudiants conçoivent un programme durant le week-end pour
réaliser une simulation ; un professeur de biologie pourrait attendre des étudiants qu'ils soient
capables d'analyser des génomes ; ou un professeur d'informatique pourrait attendre une
connaissance approfondie d'un environnement de programmation particulier. Est-il réaliste de
répondre à de telles attentes diverses ? Est-il réaliste de proposer un seul cours d'introduction à
l'informatique pour tous les étudiants, au lieu de proposer un cours d'introduction différent pour
chaque groupe d'étudiants ?

Avec ce livre, et des décennies d'expérience à Princeton et dans d'autres institutions ayant adopté
les versions précédentes, nous répondons à ces questions par un « oui » retentissant. La raison
principale d'adopter cette approche est qu'elle favorise la diversité. En maintenant des
applications intéressantes en avant, nous pouvons garder les étudiants avancés engagés, et en
évitant de classifier les étudiants dès le début, nous pouvons nous assurer que chaque étudiant qui
maîtrise ce matériel est prêt pour des études plus approfondies.
Que peuvent attendre les enseignants de cours avancés des étudiants ayant suivi un cours
basé sur ce livre ?

Il s'agit d'un traitement introductif courant de la programmation, qui est analogue aux cours
d'introduction généralement acceptés en mathématiques, physique, biologie, économie ou chimie.
An Introduction to Programming in Java s'efforce de fournir la préparation de base nécessaire à
tous les étudiants universitaires, tout en envoyant le message clair qu'il y a bien plus à
comprendre en informatique que simplement la programmation. Les enseignants qui travaillent
avec des étudiants ayant étudié à partir de ce livre peuvent s'attendre à ce qu'ils possèdent les
connaissances et l'expérience nécessaires pour exploiter efficacement les ordinateurs dans des
applications diverses.

Que peuvent accomplir les étudiants ayant suivi un cours basé sur ce livre dans les cours
ultérieurs ?

Notre message est que la programmation n'est pas difficile à apprendre et que maîtriser la
puissance de l'ordinateur est une expérience gratifiante. Les étudiants qui maîtrisent le matériel de
ce livre sont prêts à relever des défis computationnels, où qu'ils se présentent plus tard dans leur
carrière. Ils apprennent que les environnements de programmation modernes, comme celui fourni
par Java, ouvrent la porte à tous les problèmes computationnels qu'ils pourraient rencontrer par la
suite, et ils acquièrent la confiance nécessaire pour apprendre, évaluer et utiliser d'autres outils
computationnels.

Les étudiants intéressés par l'informatique seront bien préparés à poursuivre cet intérêt, et les
étudiants dans d'autres disciplines seront prêts à intégrer la computation dans leurs études.

Cours en ligne

Un ensemble complet de vidéos produites en studio, qui peuvent être utilisées en complément de
ce texte, est disponible à l'adresse suivante :
http://www.informit.com/title/9780134493831.
Tout comme les conférences traditionnelles en direct, l'objectif est d'informer et d'inspirer, en
motivant les étudiants à étudier et à apprendre à partir du texte. Notre expérience montre que
l'engagement des étudiants avec ce type de matériel en ligne est bien meilleur que celui observé
lors des conférences en direct, en raison de la possibilité de lire les vidéos à la vitesse choisie et
de les revoir à tout moment.

Site associé au livre

Une large quantité d'informations supplémentaires complétant ce texte peut être trouvée sur le
site web suivant :
http://introcs.cs.princeton.edu/java.
Pour des raisons de concision, nous nous référons à ce site sous le nom de booksite tout au long
du texte. Il contient du matériel destiné aux enseignants, aux étudiants et aux lecteurs
occasionnels du livre. Bien qu'il soit préférable de parcourir directement le site pour le découvrir,
voici une brève description des contenus disponibles :
  Une version condensée du texte pour référence en ligne.
 Des centaines d'exercices et de problèmes de programmation (certains avec solutions).
 Des centaines de programmes Java facilement téléchargeables.
 Des ensembles de données réelles.
 Nos bibliothèques d'entrée/sortie (I/O) pour traiter du texte, des graphiques et du son.

Le booksite est la présence en ligne associée au livre et constitue un document vivant, accessible
des millions de fois chaque année. C’est une ressource essentielle pour toute personne possédant
ce livre et est cruciale pour notre objectif de faire de l'informatique une composante intégrale de
l'éducation des étudiants universitaires.

Implications du booksite

L'une des implications les plus importantes du booksite est qu'il permet aux enseignants et aux
étudiants d'utiliser leurs propres ordinateurs pour enseigner et apprendre le matériel. N'importe
qui disposant d'un ordinateur et d'un navigateur peut commencer à apprendre à programmer en
suivant quelques instructions disponibles sur le booksite. Le processus est aussi simple que
télécharger un lecteur multimédia ou une chanson.

Ressources pour les enseignants

Pour les enseignants, le booksite contient des ressources pédagogiques qui, combinées au livre et
aux vidéos produites en studio, sont suffisamment flexibles pour soutenir de nombreux modèles
d'enseignement qui émergent à mesure que les enseignants adoptent la technologie au 21e siècle.
Par exemple, à Princeton, notre style d'enseignement a été pendant de nombreuses années basé
sur deux conférences par semaine destinées à un large public, complétées par deux sessions de
classe hebdomadaires où les étudiants se réunissent en petits groupes avec des instructeurs ou des
assistants d'enseignement.
Notre objectif dans ce chapitre est de vous convaincre que l'écriture d'un programme est plus
facile que l'écriture d'un texte, tel qu'un paragraphe ou un essai. Écrire de la prose est difficile :
nous passons de nombreuses années à l'école pour apprendre à le faire. En revanche, quelques
blocs de base suffisent pour écrire des programmes capables de résoudre des problèmes
fascinants mais autrement inaccessibles. Dans ce chapitre, nous allons vous guider à travers ces
éléments de base, vous aider à commencer à programmer en Java, et examiner une variété de
programmes intéressants. Vous serez capable de vous exprimer (en écrivant des programmes) en
seulement quelques semaines. Tout comme la capacité d’écrire de la prose, la capacité de
programmer est une compétence de toute une vie que vous pourrez continuellement affiner à
l'avenir.

Dans ce livre, vous apprendrez le langage de programmation Java. Cette tâche sera beaucoup plus
facile pour vous que, par exemple, l'apprentissage d'une langue étrangère. En effet, les langages
de programmation se caractérisent par seulement quelques dizaines de mots de vocabulaire et des
règles grammaticales simples. Une grande partie du matériel que nous couvrons dans ce livre
pourrait être exprimée en Python ou C++, ou dans plusieurs autres langages de programmation
modernes. Nous décrivons tout spécifiquement en Java afin que vous puissiez commencer à créer
et exécuter des programmes immédiatement. D'une part, nous nous concentrerons sur
l'apprentissage de la programmation, plutôt que sur l'apprentissage des détails du langage Java.
D'autre part, une partie du défi de la programmation consiste à savoir quels détails sont pertinents
dans une situation donnée. Java est largement utilisé, donc apprendre à programmer dans ce
langage vous permettra d’écrire des programmes sur de nombreux ordinateurs (le vôtre, par
exemple). De plus, apprendre à programmer en Java vous facilitera l'apprentissage d'autres
langages, y compris des langages de bas niveau comme le C et des langages spécialisés comme
Matlab.

1.1 Votre premier programme

Dans cette section, notre objectif est de vous introduire dans le monde de la programmation en
Java en vous guidant à travers les étapes de base nécessaires pour faire fonctionner un
programme simple. La plateforme Java (ci-après abrégée en Java) est un ensemble d'applications,
semblable à beaucoup d'autres applications que vous utilisez habituellement (comme votre
traitement de texte, votre programme de messagerie électronique ou votre navigateur web).
Comme pour toute application, vous devez vous assurer que Java est correctement installé sur
votre ordinateur. Il est souvent préinstallé sur de nombreux ordinateurs, ou vous pouvez
facilement le télécharger. Vous aurez également besoin d'un éditeur de texte et d'une application
terminale. Votre première tâche consiste à trouver les instructions pour installer un
environnement de programmation Java sur votre ordinateur en visitant
http://introcs.cs.princeton.edu/java.

Nous appelons ce site le booksite. Il contient une grande quantité d'informations supplémentaires
concernant le matériel de ce livre, pour votre référence et votre utilisation lors de la
programmation.
Programmer en Java

Pour vous introduire au développement de programmes Java, nous divisons le processus en trois
étapes. Pour programmer en Java, vous devez :

1. Créer un programme en le tapant dans un fichier nommé, par exemple,

MyProgram.java.
2. Compiler le programme en tapant javac MyProgram.java dans une fenêtre de terminal.
3. Exécuter (ou lancer) le programme en tapant java MyProgram dans la fenêtre de
terminal.

Dans la première étape, vous commencez avec un écran vierge et vous terminez avec une
séquence de caractères tapés à l'écran, tout comme lorsque vous composez un message
électronique ou un essai. Les programmeurs utilisent le terme "code" pour désigner le texte du
programme, et "coder" pour désigner l'acte de créer et d'éditer ce code. Dans la deuxième étape,
vous utilisez une application système qui compile votre programme (le traduit dans une forme
plus adaptée à l'ordinateur) et place le résultat dans un fichier nommé MyProgram.class. Dans la
troisième étape, vous transférez le contrôle de l'ordinateur du système vers votre programme (qui
rend ensuite le contrôle au système une fois terminé).

Beaucoup de systèmes ont plusieurs façons de créer, compiler et exécuter des programmes. Nous
choisissons la séquence décrite ici car elle est la plus simple à décrire et à utiliser pour de petits
programmes.

Création d'un programme

Un programme Java n'est rien de plus qu'une séquence de caractères, comme un paragraphe ou un
poème, stockée dans un fichier avec l'extension .java. Pour en créer un, vous devez donc
simplement définir cette séquence de caractères, de la même manière que vous le faites pour
rédiger un email ou utiliser n'importe quelle autre application informatique. Vous pouvez utiliser
n'importe quel éditeur de texte pour cette tâche, ou bien choisir l'un des environnements de
développement intégrés (EDI) plus sophistiqués décrits sur le booksite. Bien que ces
environnements soient souvent plus complexes que nécessaires pour les programmes de ce livre,
ils sont faciles à utiliser, offrent de nombreuses fonctionnalités utiles et sont largement utilisés
par les professionnels.

Compiler un programme

Au début, il pourrait sembler que Java est conçu pour être mieux compris par l'ordinateur. Au
contraire, le langage est conçu pour être compris avant tout par le programmeur — c'est-à-dire
vous. Le langage de l'ordinateur est beaucoup plus primitif que Java. Un compilateur est une
application qui traduit un programme du langage Java vers un langage plus adapté à l'exécution
sur l'ordinateur. Le compilateur prend un fichier avec une extension .java (votre programme) et
produit un fichier avec le même nom mais une extension .class (la version du programme dans
le langage de l'ordinateur).

Pour utiliser votre compilateur Java, tapez la commande javac suivie du nom du fichier de votre
programme dans une fenêtre de terminal.

Exécuter (lancer) un programme

Une fois que vous avez compilé le programme, vous pouvez l'exécuter (ou le lancer). C'est la
partie excitante, où votre programme prend le contrôle de votre ordinateur (dans les limites
permises par Java). Il serait peut-être plus juste de dire que c'est votre ordinateur qui suit vos
instructions. Il est encore plus précis de dire qu'une partie de Java, appelée la machine virtuelle
Java (JVM pour Java Virtual Machine), dirige votre ordinateur pour qu'il suive vos instructions.

Pour utiliser la JVM pour exécuter votre programme, tapez la commande java suivie du nom du
programme dans une fenêtre de terminal.

Développement d'un programme Java

1. Créer votre programme (un fichier texte) : Utilisez n'importe quel éditeur de texte pour
rédiger votre programme Java. Sauvegardez-le avec l'extension .java. Par exemple, créez
un fichier appelé HelloWorld.java.
2. Compiler votre programme : Ouvrez un terminal et tapez la commande suivante pour
compiler votre programme :

bash
Copier le code
javac HelloWorld.java

Cela génère un fichier HelloWorld.class, qui contient le programme dans un format que
l'ordinateur peut exécuter.

3. Exécuter votre programme : Toujours dans le terminal, tapez la commande suivante

pour exécuter votre programme :

bash
Copier le code
java HelloWorld

Si votre programme contient une instruction pour afficher quelque chose à l'écran, vous
verrez la sortie s'afficher dans le terminal.

Résumé de l'approche de développement Java

1. Écrire le programme dans un fichier .java.

 2. Compiler le programme en utilisant la commande javac.
3. Exécuter le programme avec la commande java.

Exemple visuel du processus

1. Votre programme (fichier texte .java)

o Exemple : HelloWorld.java
2. Version en langage machine (fichier .class)
o Exemple : HelloWorld.class
3. Commandes terminal :
o Pour compiler : javac HelloWorld.java
o Pour exécuter : java HelloWorld
4. Sortie (résultat à l'écran)
o Exemple : Affichage de "Hello, World!"

En suivant ces étapes simples, vous pouvez commencer à programmer en Java et à exécuter vos
premiers programmes, un pas à la fois.

Program 1.1.1 Hello, World

public class HelloWorld { public static void main(String[] args) {
// Prints "Hello, World" in the terminal window.
System.out.println("Hello, World"); } }

Ce code est un programme Java qui accomplit une tâche simple. Il est
traditionnellement le premier programme que l'on écrit lorsqu'on débute. Le
cadre ci-dessous montre ce qui se passe lorsque vous compilez et exécutez
le programme. L'application terminale affiche une invite de commande (%
dans ce livre) et exécute les commandes que vous tapez (d'abord javac, puis
java dans l'exemple ci-dessous). Notre convention est de mettre en gras le
texte que vous tapez et d'afficher les résultats en texte normal. Dans ce cas,
le résultat est que le programme affiche le message "Hello, World !" dans la
fenêtre du terminal.

PROGRAMME 1.1.1 est un exemple de programme Java complet. Son nom

est HelloWorld, ce qui signifie que son code se trouve dans un fichier nommé
HelloWorld.java (par convention en Java). L'unique action du programme est
d'afficher un message dans la fenêtre du terminal. Pour la continuité, nous
utiliserons certains termes standards de Java pour décrire le programme,
mais nous ne les définirons que plus tard dans le livre : PROGRAMME 1.1.1
consiste en une seule classe nommée HelloWorld qui possède une seule
méthode nommée main(). (Lorsque nous faisons référence à une méthode
dans le texte, nous utilisons les parenthèses () après le nom pour la
distinguer des autres types de noms.) Jusqu'à la SECTION 2.1, toutes nos
classes auront cette même structure. Pour le moment, vous pouvez
considérer "classe" comme signifiant "programme".

La première ligne d'une méthode spécifie son nom et d'autres informations ; le reste est une
séquence d'instructions encadrées par des accolades, chaque instruction étant généralement suivie
d'un point-virgule. Pour le moment, vous pouvez considérer que "programmer" signifie "spécifier
un nom de classe et une séquence d'instructions pour sa méthode main()", le cœur du programme
étant constitué par la séquence d'instructions dans la méthode main() (son corps).
PROGRAMME 1.1.1 contient deux instructions de ce type :

• La première instruction est un commentaire, qui sert à documenter le programme. En Java, un

commentaire sur une seule ligne commence par deux caractères '/' et se poursuit jusqu'à la fin de
la ligne. Dans ce livre, nous affichons les commentaires en gris. Java ignore les commentaires —
ils sont présents uniquement pour les lecteurs humains du programme.

• La deuxième instruction est une instruction d'affichage. Elle appelle la méthode nommée
System.out.println() pour afficher un message texte — celui spécifié entre les guillemets
correspondants — dans la fenêtre du terminal.

Dans les deux prochaines sections, vous apprendrez à utiliser différents types d'instructions pour
créer des programmes. Pour le moment, nous n'utiliserons que des commentaires et des
instructions d'affichage, comme celles dans HelloWorld.

Lorsque vous tapez java suivi d'un nom de classe dans votre fenêtre de terminal, le système
appelle la méthode main() que vous avez définie dans cette classe et exécute ses instructions dans
l'ordre, une par une. Ainsi, en tapant java HelloWorld, le système appelle la méthode main()
dans PROGRAMME 1.1.1 et exécute ses deux instructions. La première instruction est un
commentaire, que Java ignore. La deuxième instruction affiche le message spécifié dans la
fenêtre du terminal.

Anatomie d'un programme

Fichier texte nommé HelloWorld.java

java
Copier le code
public class HelloWorld
{
public static void main(String[] args)
{
// Affiche "Hello, World" dans la fenêtre du terminal.
System.out.print("Hello, World");
}
}
Depuis les années 1970, il est de tradition que le premier programme d'un débutant imprime
"Hello, World". Ainsi, vous devriez taper le code du PROGRAMME 1.1.1 dans un fichier, le
compiler et l'exécuter. En faisant cela, vous suivrez les traces de nombreux autres qui ont appris à
programmer. Vous vérifierez également que vous disposez d'un éditeur et d'une application de
terminal fonctionnels. Au début, réaliser la tâche d'afficher quelque chose dans une fenêtre de
terminal peut ne pas sembler très intéressant ; mais après réflexion, vous verrez que l'une des
fonctions les plus basiques qu'un programme doit accomplir est sa capacité à nous dire ce qu'il est
en train de faire.

Pour l'instant, tout notre code de programme sera semblable à celui du PROGRAMME 1.1.1,
sauf qu'il contiendra une séquence différente d'instructions dans la méthode main(). Vous n'avez
donc pas besoin de commencer avec une page blanche pour écrire un programme. Vous pouvez
plutôt :

 Copier HelloWorld.java dans un nouveau fichier avec un nom de programme de votre

choix, suivi de l'extension .java.
 Remplacer HelloWorld dans la première ligne par le nouveau nom du programme.
 Remplacer les instructions de commentaire et d'affichage par une nouvelle séquence
d'instructions.

Votre programme est défini par sa séquence d'instructions et son nom. Chaque programme Java
doit être stocké dans un fichier dont le nom correspond à celui après le mot class dans la
première ligne, et il doit également avoir l'extension .java.

Erreurs

Il est facile de mélanger les distinctions entre l'édition, la compilation et l'exécution des
programmes. Vous devriez garder ces processus séparés dans votre esprit lorsque vous apprenez
à programmer, afin de mieux comprendre les effets des erreurs qui surviendront inévitablement.

Vous pouvez corriger ou éviter la plupart des erreurs en examinant attentivement votre
programme au fur et à mesure de sa création, de la même manière que vous corrigez les fautes
d'orthographe et de grammaire lorsque vous rédigez un message électronique. Certaines erreurs,
appelées erreurs de compilation, sont identifiées lorsque vous compilez le programme, car elles
empêchent le compilateur de faire la traduction. D'autres erreurs, appelées erreurs d'exécution,
n'apparaissent qu'une fois que vous exécutez le programme.

En général, les erreurs dans les programmes, aussi appelées bugs, sont le fléau de l'existence d'un
programmeur : les messages d'erreur peuvent être déroutants ou trompeurs, et la source de l'erreur
peut être très difficile à trouver. L'une des premières compétences que vous apprendrez sera
d'identifier les erreurs ; vous apprendrez également à être suffisamment prudent lorsque vous
écrivez du code pour éviter d'en commettre beaucoup dès le départ. Vous trouverez plusieurs
exemples d'erreurs dans les Questions et Réponses à la fin de cette section.

Program 1.1.2 Using a command-line argument

public class UseArgument { public static void main(String[] args) { System.out.print("Hi, ");
System.out.print(args[0]); System.out.println(". How are you?"); } }

Entrée et sortie

Typiquement, nous voulons fournir des données d'entrée à nos programmes, c'est-à-dire des
informations qu'ils peuvent traiter pour produire un résultat. La manière la plus simple de fournir
des données d'entrée est illustrée dans le programme UseArgument (PROGRAMME 1.1.2).
Chaque fois que vous exécutez le programme UseArgument, il accepte l'argument de ligne de
commande que vous tapez après le nom du programme et le renvoie dans la fenêtre du terminal
comme partie du message. Le résultat de l'exécution de ce programme dépend de ce que vous
tapez après le nom du programme. En exécutant le programme avec différents arguments de ligne
de commande, vous produisez différents résultats affichés. Nous discuterons plus en détail du
mécanisme que nous utilisons pour passer des arguments de ligne de commande à nos
programmes plus tard, dans la SECTION 2.1.

Pour l'instant, il suffit de comprendre que args[0] correspond au premier argument de ligne de
commande que vous tapez après le nom du programme, args[1] est le second, et ainsi de suite.
Ainsi, vous pouvez utiliser args[0] dans le corps de votre programme pour représenter la
première chaîne que vous tapez dans la ligne de commande lorsqu'il est exécuté, comme dans
l'exemple de UseArgument.

Exemple d'exécution :
shell
Copier le code
% javac UseArgument.java
% java UseArgument Alice
Hi, Alice. How are you?
% java UseArgument Bob
Hi, Bob. How are you?

Ce programme montre comment nous pouvons contrôler les actions de nos programmes : en
fournissant un argument dans la ligne de commande. Cela nous permet d'adapter le
comportement de nos programmes.

En plus de la méthode System.out.println(), le programme UseArgument appelle également la

méthode System.out.print(). Cette méthode est similaire à System.out.println(), mais elle
imprime uniquement la chaîne spécifiée, sans ajouter de caractère de nouvelle ligne (retour à la
ligne).

Au début, obtenir un programme qui répète simplement ce que nous tapons ne semble pas très
intéressant, mais en y réfléchissant, vous réaliserez qu'une autre fonction de base d'un programme
est sa capacité à répondre aux informations de base de l'utilisateur pour contrôler ce que le
programme fait. Le modèle simple que UseArgument représente est suffisant pour nous
permettre de considérer le mécanisme de base de la programmation en Java et d'aborder une
grande variété de problèmes informatiques intéressants.

En prenant un peu de recul, nous pouvons voir que UseArgument ne fait ni plus ni moins que
d'implémenter une fonction qui mappe une chaîne de caractères (l'argument de la ligne de
commande) vers une autre chaîne de caractères (le message imprimé dans la fenêtre du terminal).
Lorsque nous l'utilisons, nous pouvons penser à notre programme Java comme une "boîte noire"
qui transforme une chaîne d'entrée en une chaîne de sortie.

Ce modèle est attractif car il est non seulement simple, mais aussi suffisamment général pour
permettre, en principe, l'accomplissement de toute tâche informatique. Par exemple, le
compilateur Java lui-même n'est rien de plus qu'un programme qui prend une chaîne de caractères
en entrée (un fichier .java) et produit une autre chaîne de caractères en sortie (le fichier .class
correspondant).

Plus tard, vous pourrez écrire des programmes qui accomplissent une variété de tâches
intéressantes (bien que nous ne nous aventurerons pas jusqu'à des programmes aussi complexes
qu'un compilateur). Pour l'instant, nous vivrons avec certaines limitations concernant la taille et le
type des entrées et sorties de nos programmes. Dans la SECTION 1.5, vous découvrirez
comment intégrer des mécanismes plus sophistiqués pour l'entrée et la sortie de données dans un
programme. En particulier, vous verrez que nous pouvons travailler avec des chaînes d'entrée et
de sortie de longueur arbitraire ainsi que d'autres types de données, tels que le son et les images.
Q&A (Questions et Réponses)

Q. Pourquoi Java ?
R. Les programmes que nous écrivons sont très similaires à ceux écrits dans d'autres langages,
donc le choix du langage n'est pas crucial. Nous utilisons Java car il est largement disponible,
offre un ensemble complet d'abstractions modernes et dispose de diverses vérifications
automatiques pour détecter les erreurs dans les programmes, ce qui le rend adapté à
l'apprentissage de la programmation. Il n'existe pas de langage parfait, et vous serez certainement
amené à programmer dans d'autres langages à l'avenir.

Q. Est-ce que je dois vraiment taper les programmes du livre pour les essayer ? Je crois que
vous les avez exécutés et qu'ils produisent la sortie indiquée.
R. Tout le monde devrait taper et exécuter HelloWorld. Votre compréhension sera
considérablement améliorée si vous exécutez également UseArgument, que vous testez avec
diverses entrées et que vous le modifiez pour essayer différentes idées. Pour vous faire gagner du
temps, vous pouvez trouver tout le code du livre (et bien plus encore) sur le booksite. Ce site
contient également des informations sur l'installation et l'exécution de Java sur votre ordinateur,
des réponses à certains exercices, des liens web, et d'autres informations utiles lors de la
programmation.

Q. Que signifient les mots public, static et void ?

R. Ces mots-clés spécifient certaines propriétés de la méthode main() que vous apprendrez plus
en détail plus tard dans le livre. Pour l'instant, nous incluons ces mots-clés dans le code (car ils
sont nécessaires), mais nous ne les expliquons pas dans le texte immédiatement.

Q. Que signifient les séquences de caractères //, /* et */ dans le code ?

R. Ce sont des commentaires, que le compilateur ignore. Un commentaire est soit du texte entre
/* et */, soit à la fin d'une ligne après //. Les commentaires sont indispensables car ils aident les
autres programmeurs à comprendre votre code et peuvent même vous aider à comprendre votre
propre code en rétrospective. En raison des contraintes du format du livre, nous utilisons les
commentaires avec parcimonie dans nos programmes. Les programmes sur le booksite sont
commentés dans une mesure plus réaliste.

Q. Quelles sont les règles de Java concernant les tabulations, espaces et caractères de
nouvelle ligne ?
R. Ces caractères sont appelés des caractères d'espace blanc. Les compilateurs Java considèrent
tous les espaces blancs dans le texte du programme comme équivalents. Par exemple, nous
pourrions écrire HelloWorld de la manière suivante :

java
Copier le code
public class HelloWorld { public static void main(String[] args)
{ System.out.println("Hello, World"); } }
Mais nous adhérons généralement aux conventions de mise en espace et d'indentation lorsque
nous écrivons des programmes Java, tout comme nous utilisons des indentations cohérentes pour
les paragraphes et lignes lorsque nous écrivons un texte ou un poème.

Q. Quelles sont les règles concernant les guillemets ?

R. Le texte à l'intérieur des guillemets doubles constitue une exception à la règle définie dans la
question précédente : typiquement, les caractères entre guillemets sont pris littéralement afin que
vous puissiez spécifier précisément ce qui doit être imprimé. Si vous mettez un nombre
quelconque d'espaces successifs dans les guillemets, vous obtenez ce nombre d'espaces dans la
sortie. Si vous oubliez accidentellement un guillemet, le compilateur peut se retrouver très
confus, car il a besoin de ces guillemets pour distinguer les caractères dans la chaîne de caractères
et les autres parties du programme.

Q. Que se passe-t-il si vous omettez une accolade ou si vous faites une erreur d'orthographe
sur l'un des mots comme public, static, void ou main ?
R. Cela dépend de l'erreur précise. De telles erreurs sont appelées des erreurs de syntaxe et sont
généralement détectées par le compilateur. Par exemple, si vous créez un programme Bad qui est
exactement le même que HelloWorld, mais que vous omettez la ligne contenant la première
accolade gauche (et que vous changez le nom du programme en Bad), vous obtiendrez le
message suivant :

bash
Copier le code
% javac Bad.java
Bad.java:1: error: '{' expected
public class Bad
^
1 error

De ce message, vous pouvez correctement supposer qu'il vous manque une accolade gauche.
Mais le compilateur peut ne pas être capable de vous dire exactement quelle erreur vous avez
faite, ce qui rend le message d'erreur difficile à comprendre. Par exemple, si vous omettez la
deuxième accolade gauche au lieu de la première, vous obtiendrez le message suivant :

bash
Copier le code
% javac Bad.java
Bad.java:3: error: ';' expected
public static void main(String[] args)
^
Bad.java:7: error: class, interface, or enum expected
}
^
2 errors

Une manière de vous habituer à ces messages d'erreur est d'introduire intentionnellement des
erreurs dans un programme simple, puis d'observer ce qui se passe. Quel que soit le message
d'erreur, vous devez traiter le compilateur comme un ami, car il essaie simplement de vous
indiquer qu'il y a quelque chose de mal dans votre programme.
Q. Quelles méthodes Java puis-je utiliser ?
R. Il y en a des milliers. Nous vous les introduirons progressivement (à partir de la section
suivante) afin de ne pas vous submerger avec trop de choix.

Q. Lorsque j'ai exécuté UseArgument, j'ai reçu un message d'erreur étrange. Quel est le
problème ?
R. Il est probable que vous avez oublié d'inclure un argument de ligne de commande :

bash
Copier le code
% java UseArgument
Hi, Exception in thread "main"
java.lang.ArrayIndexOutOfBoundsException: 0
at UseArgument.main(UseArgument.java:6)

Java se plaint que vous avez exécuté le programme sans fournir d'argument de ligne de
commande, comme il l'attendait. Vous apprendrez plus de détails sur les indices de tableau dans
la SECTION 1.4. N'oubliez pas ce message d'erreur, car même les programmeurs expérimentés
oublient parfois de taper des arguments de ligne de commande.

Exercices

1.1.1 Écrivez un programme qui imprime le message Hello, World 10 fois.

1.1.2 Décrivez ce qui se passe si vous omettez les éléments suivants dans HelloWorld.java : a.
public
b. static
c. void
d. args

1.1.3 Décrivez ce qui se passe si vous faites une faute d'orthographe (par exemple, si vous
omettez la deuxième lettre) sur les éléments suivants dans HelloWorld.java : a. public
b. static
c. void
d. args

1.1.4 Décrivez ce qui se passe si vous placez les guillemets dans l'instruction print de
HelloWorld.java sur des lignes différentes, comme dans ce fragment de code :

java
Copier le code
System.out.println("Hello,
World");

1.1.5 Décrivez ce qui se passe si vous essayez d'exécuter UseArgument avec chacune des lignes
de commande suivantes : a. java UseArgument java
b. java UseArgument @!&^%
c. java UseArgument 1234
d. java UseArgument.java Bob
e. java UseArgument Alice Bob

1.1.6 Modifiez UseArgument.java pour créer un programme UseThree.java qui prend trois
noms comme arguments de ligne de commande et imprime une phrase appropriée avec les noms
dans l'ordre inverse de celui donné, de sorte que, par exemple, java UseThree Alice Bob
Carol imprime :

"Hi Carol, Bob, and Alice."

1.2 Types de Données Intégrés (Built-in Types)

Lors de la programmation en Java, il est essentiel de toujours être conscient du type de données
que votre programme traite. Les programmes de la SECTION 1.1 traitent des chaînes de
caractères, beaucoup des programmes de cette section traiteront des nombres, et nous explorerons
d'autres types de données plus tard dans le livre. Comprendre les distinctions entre les types de
données est tellement important que nous devons définir formellement l'idée suivante : un type
de données est un ensemble de valeurs et un ensemble d'opérations définies sur ces valeurs.

Vous êtes déjà familiers avec différents types de nombres, comme les entiers et les nombres réels,
ainsi qu'avec des opérations définies sur ces nombres, telles que l'addition et la multiplication. En
mathématiques, nous avons l'habitude de considérer les ensembles de nombres comme étant
infinis. Cependant, dans les programmes informatiques, nous devons travailler avec un nombre
fini de possibilités. Chaque opération que nous effectuons est bien définie uniquement pour un
sous-ensemble fini des valeurs d'un type de données associé.

Types de Données Primitifs en Java

Il existe huit types de données primitifs en Java, principalement pour différents types de nombres.
Parmi ces huit types primitifs, nous utilisons fréquemment les suivants :

 int : pour les entiers.

 double : pour les nombres réels (décimaux).
 boolean : pour les valeurs booléennes (vrai ou faux).

Ces types primitifs sont directement supportés par le langage Java. D'autres types de données
sont également disponibles dans les bibliothèques Java. Par exemple, les programmes de la
SECTION 1.1 utilisent le type String pour représenter des chaînes de caractères. Bien que
String soit techniquement un type de données dans les bibliothèques Java, Java le traite
différemment des autres types primitifs. En effet, il est essentiel pour les entrées et sorties
(input/output) dans les programmes. Par conséquent, String partage certaines caractéristiques
des types primitifs, comme le fait que certaines de ses opérations sont intégrées directement dans
le langage Java.

Types de Données Intégrés (Built-in Types)

Pour plus de clarté, nous faisons référence collectivement aux types primitifs et au type String
comme des types de données intégrés. Pour l'instant, nous allons nous concentrer sur les
programmes qui utilisent des types de données intégrés. Plus tard, vous apprendrez à utiliser des
types de données de bibliothèques Java et même à créer vos propres types de données. En réalité,
la programmation en Java consiste souvent à construire des types de données, comme vous le
verrez dans CHAPITRE 3.

Exemples et Applications
Après avoir défini ces termes de base, nous examinerons plusieurs programmes et fragments de
code qui illustrent l'utilisation de différents types de données. Ces fragments de code ne réalisent
pas de calculs complexes, mais vous rencontrerez bientôt des codes similaires dans des
programmes plus longs. Comprendre les types de données (leurs valeurs et les opérations qui leur
sont associées) est une étape essentielle pour débuter en programmation. Cela pose les bases pour
commencer à travailler sur des programmes plus complexes dans la section suivante. En effet,
chaque programme que vous écrivez utilisera du code similaire à ces petits fragments montrés
dans cette section.

type set of values common operators sample literal

values
int integers +-*/%

double floating-point numbers +-*/

boolean boolean values && || ! true false

char characters 'A' '1' '%' '\n'

String sequences of + "AB" "Hello" "2.5"

characters

Terminologie des Types de Données en Java

Pour parler des types de données, nous devons introduire quelques termes clés. Pour ce faire,
nous commencerons par le fragment de code suivant :

java
Copier le code
int a, b, c;
a = 1234;
b = 99;
c = a + b;
Déclaration et Affectation

 La première ligne est une instruction de déclaration qui déclare

les noms de trois variables (a, b, c) et leur type (int).
 Les trois lignes suivantes sont des instructions d'affectation qui
changent les valeurs des variables, en utilisant les littéraux 1234 et 99,
ainsi que l'expression a + b, ce qui donne finalement à c la valeur 1333.

Littéraux (Literals)

Un littéral est une représentation en code Java d'une valeur d'un type de données. En Java, un
littéral est une manière d'indiquer directement une valeur dans le programme. Voici quelques
exemples :
  int : Une séquence de chiffres, comme 1234 ou 99, représente des
valeurs de type int (entiers).
 double : Une valeur à virgule flottante, comme 3.14159 ou 2.71828,
représente des valeurs de type double.
 boolean : Les valeurs true et false représentent les deux valeurs
possibles du type boolean.
 String : Une séquence de caractères, entre guillemets (par exemple
"Hello, World"), représente une valeur de type String.

Les littéraux sont donc les valeurs elles-mêmes utilisées dans les expressions ou affectées à des
variables.

Opérateurs (Operators)

Un opérateur est une représentation en code Java d'une opération appliquée à des valeurs d'un
type de données. Voici quelques exemples d'opérateurs courants utilisés en Java :

 Opérateurs arithmétiques : + (addition) et * (multiplication) sont utilisés pour les

opérations sur les types numériques comme les entiers (int) et les nombres à virgule
flottante (double).
 Opérateurs logiques pour le type boolean :
o && : "et" logique (AND)
o || : "ou" logique (OR)
o ! : "non" logique (NOT)

Ces opérateurs permettent de manipuler les valeurs des types de données en effectuant des
opérations. Nous aborderons plus en détail les opérateurs les plus utilisés plus tard dans cette
section.

Identifiants (Identifiers)

Un identifiant est une représentation en code Java d'un nom, par exemple pour une variable, une
méthode, ou une classe. Un identifiant est une séquence de caractères qui peut inclure des
lettres, des chiffres, des underscores (_) et des symboles monétaires ($), mais ne peut pas
commencer par un chiffre.

Voici quelques exemples d'identifiants valides :

 a, b, c : des identifiants simples pour des variables.

 totalAmount, sum_of_numbers : des identifiants plus complexes, souvent
utilisés pour nommer des variables ou des méthodes de façon plus
descriptive.
 _value, $price : des identifiants valides, bien que leur usage soit
souvent limité ou spécifique dans certaines conventions de nommage.

Récapitulatif
En résumé, dans ce fragment de code Java :

 Littéraux : 1234, 99, a + b (qui est une expression, donc une

combinaison de littéraux et d'opérateurs).
 Opérateurs : + pour l'addition et l'opérateur d'assignation =.
 Identifiants : a, b, c sont les noms des variables.

La distinction entre ces éléments — littéraux, opérateurs et identifiants — est essentielle pour
comprendre comment Java traite les valeurs et les opérations. Ces concepts seront utilisés dans la
création de programmes plus complexes à mesure que vous progressez dans l'apprentissage de la
programmation.

Identifiants, Variables et Conventions de Nommage en Java

En Java, les identifiants et les variables sont des concepts essentiels, car ils sont utilisés pour
représenter et manipuler les données dans un programme. Voici une explication détaillée de ces
éléments :

Identifiants (Identifiers)

Un identifiant en Java est un nom que l'on donne à une variable, une méthode, une classe, ou un
autre élément de programme. Voici quelques règles et détails concernant les identifiants :

1. Règles de validité :
o Un identifiant doit commencer par une lettre, un caractère de
soulignement (_), ou un symbole monétaire ($).
o Il ne peut pas commencer par un chiffre. Par exemple, 1abc
est invalide.
o Les lettres (a-z, A-Z), les chiffres (0-9), les underscores (_) et
les symbôles monétaires ($) peuvent apparaître dans
l'identifiant après le premier caractère.
o Les identifiants sont sensibles à la casse : abc, Ab$, abc123 et a_b
sont tous valides, mais Ab*, 1abc, et a+b sont des identifiants
invalides.

2. Réservations :
o Certaines mots-clés sont réservés en Java et ne peuvent pas
être utilisés comme identifiants. Par exemple, public, static, int,
double, String, true, false, null sont des mots réservés, et leur
usage comme identifiants est interdit.

3. Exemples d'identifiants valides :

o abc, Ab$, abc123, a_b
 4. Exemples d'identifiants invalides :
o Ab*, 1abc, a+b

Variables

Une variable en Java est une entité qui contient une valeur d'un type de données spécifique.
Cette valeur peut changer au cours de l'exécution du programme. Les variables sont utilisées
pour stocker des informations qui peuvent être manipulées par le programme.

1. Types des variables :

o Une variable en Java a un type qui définit les valeurs qu'elle
peut contenir. Par exemple, une variable de type int peut
contenir des entiers, mais pas des nombres à virgule flottante ou
des chaînes de caractères.
o Exemple : Une variable de type int pourrait contenir une valeur
comme 99 ou 1234, mais pas 3.14159 (qui est de type double) ou
"Hello, World" (qui est de type String).

2. Changement de valeur :
o Une variable peut changer de valeur au cours du programme, d'où son nom de
"variable". Par exemple, une variable nommée sum pourrait être utilisée pour
garder la somme cumulative d'une séquence de nombres.
o Exemple d'utilisation :

java
Copier le code
int sum = 0;
sum = sum + 10; // La valeur de 'sum' change ici

Déclarations de Variables

Pour créer une variable en Java, vous devez utiliser une instruction de déclaration. Une
déclaration spécifie le type de la variable suivi du nom de la variable.

1. Déclaration simple :

java
Copier le code
int a; // Déclare une variable nommée 'a' de type int

Cette déclaration réserve de l'espace mémoire pour stocker une valeur de type int et
associe l'identifiant a à cet espace mémoire.

2. Déclaration multiple : Vous pouvez déclarer plusieurs variables de même type en une
seule ligne. Par exemple :

java
 Copier le code
int a, b, c; // Déclare trois variables de type int

Cela déclare trois variables : a, b et c, toutes de type int.

Conventions de Nommage des Variables

Les programmeurs suivent souvent des conventions stylistiques pour nommer les variables. Ces
conventions permettent de rendre le code plus lisible et compréhensible. Voici les conventions de
nommage utilisées dans ce livre :

1. Camel Case : Le style camel case consiste à écrire les noms de variables avec un premier
mot en minuscules et les mots suivants en majuscules, sans espaces ni caractères
spéciaux. Par exemple :
o i, x, y, sum, isLeapYear, outDegrees

Dans ce style, la première lettre de chaque mot à part le premier est en majuscule.

2. Exemples de noms de variables respectant la convention camel case :

o i, sum, totalAmount, isLeapYear

Variables Constantes

Une variable constante est une variable dont la valeur ne change pas pendant l'exécution du
programme. Bien qu'elle soit appelée "variable", la valeur qu'elle contient reste fixe.

1. Nom des variables constantes :

o Par convention, le nom d'une constante est en majuscules, avec
des underscores (_) pour séparer les mots.
o Par exemple :
 SPEED_OF_LIGHT
 DARK_RED

2. Exemple d'utilisation :

java
Copier le code
final double SPEED_OF_LIGHT = 299792458; // Valeur constante de la
vitesse de la lumière en m/s

Récapitulatif

 Les identifiants sont des noms donnés aux variables, méthodes,

classes, etc., et doivent suivre des règles strictes en Java. Ils ne
peuvent pas commencer par un chiffre et ne peuvent pas être des
mots-clés réservés.
  Une variable est une entité qui peut stocker une valeur d'un type
spécifique. Elle peut changer de valeur au cours de l'exécution du
programme.
 Les déclarations de variables sont utilisées pour créer des variables,
et plusieurs variables du même type peuvent être déclarées dans une
seule instruction.
 En Java, il est courant de suivre des conventions de nommage pour
rendre le code plus lisible, comme le camel case pour les variables et
les constantes en majuscules avec des underscores.

Ces concepts sont fondamentaux pour commencer à programmer en Java, et ils seront utilisés
dans la majorité des programmes que vous écrirez.