Pensez en Java

Un programme est une suite d'instructions qui spécifie comment effectuer une opération. L’opération peut être un calcul mathématique, comme résoudre un système d'équations ou trouver les racines d'un polynôme, mais il peut aussi être un calcul symbolique tel que la recherche et le remplacement de texte dans un document ou quelque chose de graphique, comme le traitement d'une image ou la lecture d'une vidéo.

Les détails diffèrent d'un langage à un autre, mais quelques instructions de base apparaissent dans presque tous les langages :

• entrée : obtenir des données à partir du clavier, d'un fichier, du réseau ou un autre dispositif ;
• sortie : afficher des données à l'écran, les enregistrer dans un fichier, les envoyer sur le réseau, etc. ;
• maths : effectuer des opérations mathématiques de base, comme l'addition et la multiplication ;
• exécution conditionnelle : vérifier certaines conditions et exécuter le code approprié ;
• répétition : effectuer une action à plusieurs reprises, le plus souvent avec une certaine variation.

Croyez-le ou non, c'est à peu près tout ce qu'il y a à faire. Chaque programme que vous avez déjà utilisé, quelle que soit sa complexité, est constitué d'instructions qui ressemblent à peu près à celles-ci. Alors, vous pouvez percevoir la programmation comme un processus de division d'une grande tâche complexe en sous-tâches de plus en plus petites, jusqu'à ce que les sous-tâches soient assez simples pour être effectuées en utilisant l'une de ces instructions de base.

L'un des aspects les plus intéressants de la programmation est que nous pouvons décider de comment résoudre un problème particulier lorsqu'il existe plusieurs solutions. Par exemple, il existe plusieurs façons de trier une liste de numéros, et chaque façon a ses avantages. Afin de déterminer quel est le meilleur moyen pour une situation donnée, nous avons besoin de techniques pour décrire et analyser les solutions de manière formelle.

L'informatique est la science des algorithmes, y compris leur découverte et leur analyse. Un algorithme est une séquence d'étapes qui spécifie comment résoudre un problème. Certains algorithmes sont plus rapides que d'autres et certains utilisent moins d'espace mémoire. Au fur et à mesure que vous apprenez à développer des algorithmes pour des problèmes que vous n'avez pas résolus auparavant, vous apprenez aussi à penser comme un informaticien.

Concevoir des algorithmes et écrire du code est difficile et sujet aux erreurs. Pour des raisons historiques, les erreurs de programmation sont appelées bogues (ou bugs, en anglais), et le processus de suivi et de correction est appelé débogage. Au fur et à mesure que vous apprendrez à déboguer vos programmes, vous développerez de nouvelles compétences en résolution de problèmes. Vous devrez penser de façon créative lorsque des erreurs inattendues se produiront.

Bien que cela puisse être frustrant, le débogage est une partie intellectuellement riche, stimulante et intéressante de la programmation informatique. À certains égards, le débogage est comme un travail de détective. Vous êtes confronté à des indices, et vous devez déduire les processus et les événements qui ont conduit aux résultats que vous voyez. Penser à corriger des programmes et améliorer leurs performances conduit parfois même à la découverte de nouveaux algorithmes.

Dans ce cours, Java est le langage de programmation que nous allons aborder. Java est un langage de haut niveau. Python, C et C ++, Ruby et JavaScript sont d'autres langages de haut niveau dont vous avez peut-être entendu parler.

Avant de pouvoir fonctionner, les programmes écrits dans les langages de haut niveau doivent être traduits dans un langage de bas niveau, également appelé "langage machine". Cette traduction prend du temps, ce qui est un petit inconvénient des langages de haut niveau. Mais les langages de haut niveau ont deux avantages :

• il est beaucoup plus facile de programmer dans un langage de haut niveau. L’écriture des programmes prend moins de temps, ils sont plus courts et plus faciles à lire, et ils sont plus susceptibles d'être corrects ;
• les langages de haut niveau sont portables, ce qui signifie qu'ils peuvent fonctionner sur différents types d'ordinateurs avec peu ou pas de modifications. Les programmes de bas niveau ne peuvent fonctionner que sur un type d'ordinateur et doivent être réécrits pour fonctionner sur un autre.

Deux types de programmes traduisent des langages de haut niveau en langages de bas niveau : les interpréteurs et les compilateurs. Un interpréteur lit un programme de haut niveau et l'exécute, ce qui signifie qu'il fait ce que dit le programme. Il traite le programme progressivement, en alternant la lecture des lignes de code et l'exécution des calculs. La figure 1.1 montre la structure d'un interpréteur.

En revanche, un compilateur lit le programme entier et le traduit complètement avant l’exécution du programme. Dans ce contexte, le programme de haut niveau est appelé le code source, et le programme traduit est quant à lui appelé le code objet ou l'exécutable. Une fois qu'un programme est compilé, vous pouvez l'exécuter à plusieurs reprises sans autre traduction. Par conséquent, les programmes compilés s'exécutent souvent plus vite que les programmes interprétés.

Java est à la fois compilé et interprété. Au lieu de traduire les programmes directement en langage machine, le compilateur Java génère du bytecode. Similaire au langage machine, le bytecode est facile et rapide à interpréter. Mais il est également portable, il est donc possible de compiler un programme Java sur une machine, de transférer le bytecode vers une autre machine et de l'y exécuter. L'interpréteur qui exécute le bytecode est appelé "Java Virtual Machine" (JVM).

La figure 1.2 montre les étapes de ce processus. Bien que cela puisse sembler compliqué, ces étapes sont automatisées pour vous dans la plupart des environnements de développement. Habituellement, vous n'avez qu'à appuyer sur un bouton ou taper une seule commande pour compiler et exécuter votre programme. D'un autre côté, il est important de savoir quelles sont les étapes en arrière-plan, afin de comprendre les différentes erreurs.

Traditionnellement, le premier programme que vous écrivez lors de l'apprentissage d'un nouveau langage de programmation, s'appelle le programme Hello World. Tout ce qu'il fait est d’afficher « hello world » à l'écran. En Java, cela ressemble à ceci :

public class Hello {
  public static void main(String[] args) {
    // Affiche un résultat simple
    System.out.println("Hello, World!");  
  }
}

Lorsque ce programme s'exécute, il affiche :

Hello, World!

Notez que la sortie n'inclut pas les guillemets.

Les programmes Java sont constitués de définitions de classes et de méthodes, et les méthodes sont constituées d'instructions. Une instruction est une ligne de code qui effectue une opération de base. Dans le programme Hello, World! ; la ligne suivante est une instruction d'impression qui affiche un message à l'écran :

System.out.println("Hello, World!");

System.out.println affiche les résultats sur l'écran ;

println signifie « impression de la ligne ». Ce terme peut être source de confusion : impression peut signifier à la fois « afficher à l'écran » et « envoyer à l'imprimante ». Dans ce cours, nous allons essayer de dire « afficher » quand nous entendons sortie à l'écran. Comme la plupart des instructions, l'instruction d'impression se termine par un point-virgule (;).

Java est "sensible à la casse", ce qui signifie que les lettres capitales (majuscules) et les minuscules ne sont pas interchangeables. Dans cet exemple, le mot System doit commencer par une lettre majuscule ; system et SYSTEM ne fonctionneront pas.

Une méthode est une suite d'instructions nommées. Ce programme définit une méthode nommée main :

public static void main(String[] args)

Le nom et le format de la méthode main sont spéciaux : lorsque le programme s'exécute, il commence à la première instruction de main et se termine après la dernière instruction. Plus tard, nous verrons des programmes qui définissent non pas une seule, mais plusieurs méthodes.

Une classe est une collection de méthodes. Ce programme définit une classe nommée Hello. Vous pouvez donner un nom quelconque à une classe, mais par convention, le nom des classes commence par une lettre majuscule. Le nom de la classe doit correspondre au nom du fichier dans lequel elle se trouve ; donc cette classe doit être dans un fichier nommé Hello.java.

Java utilise des accolades ({et }) pour regrouper les éléments. Dans Hello.java, les accolades les plus externes contiennent la définition de classe(s) et les accolades internes contiennent la définition de la méthode.

Un commentaire est une ligne qui commence par deux barres obliques (//) ; ce n’est rien d’autre que du texte explicatif du code. Lorsque le compilateur voit //, il ignore tout jusqu'à la fin de la ligne. Les commentaires n'ont aucun effet sur l'exécution du programme, mais ils permettent à d'autres programmeurs (et à vous-même) de comprendre plus facilement ce que vous avez l'intention de faire.

Vous pouvez mettre autant d'instructions que vous le souhaitez dans main. Par exemple, pour afficher plus d'une ligne à l’écran :

public class Hello {
  public static void main(String[] args) {
    // Affiche un résultat simple
    System.out.println("Hello,World!");// Première ligne
    System.out.println("How are you?"); // Une autre ligne
  }
}

Comme le montre cet exemple, vous pouvez placer des commentaires à la fin d'une ligne ou encore sur une ligne entière

Les phrases qui apparaissent entre guillemets sont appelées chaînes de caractères, car elles contiennent une séquence de "caractères" reliés ensemble. Les caractères peuvent être des lettres, des chiffres, des signes de ponctuation, des symboles, des espaces, des tabulations, etc.

System.out.println ajoute une nouvelle ligne qui se situe au début de la ligne suivante. Si vous ne voulez pas de retour à la ligne, vous pouvez utiliser print au lieu de println :

public class Goodbye {
  public static void main(String[] args) {
    System.out.print("Goodbye, ");
    System.out.println("cruel world");
  }
}

Dans cet exemple, la première instruction n'ajoute pas de saut de ligne, donc la sortie apparaît sur une seule ligne, c’est à dire Goodbye, cruel world. Notez qu'il y a une espace à la fin de la première chaîne, qui apparaît à la sortie.

Il est possible d'afficher plusieurs lignes à la sortie avec une seule ligne de code. Il suffit de dire à Java où placer les sauts de ligne.

public class Hello {
  public static void main(String[] args){
    System.out.print("Hello!\nHow are you doing?\n");
  }
}

La sortie est sur deux lignes, chacune se terminant par un caractère de saut de ligne :

Hello!
How are you doing?

Le \n est une séquence d'échappement, c'est-à-dire une suite de caractères représentant un caractère spécial. L’antislash (ou barre oblique inverse) vous permet d'échapper à l'interprétation littérale de la chaîne. Notez qu'il n'y a pas d'espace entre \n et How. Si vous y ajoutez une espace, il y aura en aura une au début de la deuxième ligne.

Une autre utilisation courante des séquences d'échappement est d'avoir des guillemets à l'intérieur des chaînes. Puisque les guillemets doubles indiquent le début et la fin des chaînes, vous devez les échapper avec un antislash.

System.out.println("She said \"Hello!\" to me.");

Le résultat est :

She said "Hello!" to me.

Dans les programmes Java, certaines espaces sont requises. Par exemple, vous avez besoin d'au moins une espace entre les mots, donc ce programme n'est pas correct :

publicclassGoodbye{
  publicstaticvoidmain(String[] args) {
  System.out.print("Goodbye, ");
  System.out.println("cruel world");
}

Mais la plupart des autres espaces sont facultatives. Par exemple, ce programme est correct :

public class Goodbye {
public static void main(String[] args) {
System.out.print("Goodbye, ");
System.out.println("cruel world");
}
}

Aller à la ligne est également facultatif. Donc nous pouvons écrire :

public class Goodbye { public static void main(String[] args) { System.out.print("Goodbye, "); System.out.println ("cruel world");}}

Cela fonctionne toujours, mais le programme devient de plus en plus difficile à lire. Les nouvelles lignes et les espaces sont importantes pour l'organisation visuelle de votre programme, ce qui facilite la compréhension du programme et permet de détecter les erreurs lorsqu'elles se produisent.

De nombreux éditeurs mettent automatiquement en forme le code source avec des indentations cohérentes et des sauts de ligne. Par exemple, dans DrJava, vous pouvez mettre le texte en retrait en sélectionnant tout le texte (Ctrl + A) et en appuyant sur la touche Tabulation.

Les organisations qui développent beaucoup de logiciels ont généralement des règles strictes sur la façon de formater le code source. Par exemple, Google publie ses normes de codage Java pour les projets Open Source : http://google.github.io/styleguide/javaguide.html.

Vous ne comprenez peut-être pas ces instructions pour l'instant, car elles font référence à des fonctionnalités du langage que nous n'avons pas encore vues. Mais vous voudrez peut-être y revenir périodiquement en lisant ce cours.

Il est conseillé de lire ce cours devant un ordinateur pour pouvoir essayer les exemples au fur et à mesure. Vous pouvez exécuter de nombreux exemples directement dans le volet Interactions de DrJava (voir l'annexe A). Mais si vous mettez le code dans un fichier source, il sera plus facile d'essayer les variations.

Chaque fois que vous testez une nouvelle fonctionnalité, vous devriez également essayer de faire des erreurs. Par exemple, dans le programme « Hello World », que se passe-t-il si vous omettez l'un des guillemets ? Et si vous omettez les deux ? Que se passe-t-il si vous orthographiez mal println ? Des tests de ce genre vous aident à vous souvenir de ce que vous avez lu. Ils facilitent également le débogage, car vous apprenez ce que signifient les messages d'erreur. Il est préférable de faire des erreurs maintenant et intentionnellement plutôt que plus tard et accidentellement.

Le débogage est comparable à une science expérimentale : une fois que vous avez une idée de ce qui ne va pas, vous modifiez votre programme et réessayez. Si votre hypothèse était correcte, vous pouvez prédire le résultat de la modification et vous rapprocher d'un programme qui fonctionne. Si votre hypothèse était fausse, vous devez en trouver une nouvelle.

La programmation et le débogage doivent aller de pair. N'écrivez pas simplement un tas de code pour ensuite déboguer et tester à l'aveuglette afin d'éliminer les erreurs jusqu'à ce que tout fonctionne. Au lieu de cela, commencez par un programme qui fait quelque chose et faites de petites modifications, en les déboguant au fur et à mesure, jusqu'à ce que le programme fasse ce que vous voulez. De cette façon, vous aurez toujours un programme qui fonctionne, et il sera plus facile d'isoler les erreurs.

Un bon exemple de ce principe est le système d'exploitation Linux, qui contient des millions de lignes de code. Linux a commencé comme un programme simple que Linus Torvalds utilisait pour explorer la puce Intel 80386. Selon Larry Greenfield dans le Linux Users 'Guide, « l'un des projets antérieurs de Linus était un programme qui permutait entre l'impression AAAA et BBBB. Cela a évolué plus tard vers Linux. »

Enfin, la programmation apporte parfois des émotions fortes. Si vous êtes aux prises avec une situation difficile, vous pourriez vous sentir en colère, découragé ou vexé. Rappelez-vous que vous n'êtes pas seul et que la plupart des programmeurs, sinon tous, ont eu des expériences similaires. N'hésitez pas à contacter un ami et posez des questions !

Tout au long du cours, nous essayons de définir chaque terme la première fois que nous l'utilisons. À la fin de chaque chapitre, nous incluons les nouveaux termes et leurs définitions dans l'ordre d'apparition. Si vous passez du temps à apprendre ce vocabulaire, vous aurez plus de facilité à lire les chapitres suivants.

Résolution de problème :

le processus de formulation d'un problème, de trouver une solution et d'exprimer la solution.

Programme :
une séquence d'instructions qui spécifie comment effectuer des tâches sur un ordinateur.

La programmation :
l'application de la résolution de problèmes à la création de programmes informatiques exécutables.

L'informatique :
l'approche scientifique et pratique du calcul et de ses applications.

Algorithme :
une procédure ou une formule pour résoudre un problème, avec ou sans ordinateur.

Bogue :
une erreur dans un programme.

Débogage :
le processus de recherche et de suppression des erreurs

Langage de haut niveau :
Un langage de programmation conçu pour être facile à lire et à écrire pour les humains.

Langage de bas niveau :
un langage de programmation conçu pour être facile à utiliser pour un ordinateur. Aussi appelé « langage machine » ou « assembleur ».

Portabilité :
la capacité d'un programme à fonctionner sur plus d'un type d'ordinateur.

Interpréter:
exécuter un programme écrit dans un langage de haut niveau en le traduisant ligne par ligne et en exécutant immédiatement les instructions correspondantes.

Compiler :
traduire un programme écrit dans un langage de haut niveau en un langage de bas niveau, en vue d'une exécution ultérieure.

Code source :
un programme écrit dans un langage de haut niveau avant compilation.

Code objet :
programme à la sortie du compilateur, après la traduction.

Exécutable :

un autre nom pour le code objet qui est prêt à fonctionner sur un matériel spécifique.

Byte code :
un type spécial de code objet utilisé pour les programmes Java. Le byte code est similaire à un langage de bas niveau, mais il est portable comme un langage de haut niveau.

Instruction :
partie d'un programme qui spécifie une étape d'un algorithme.

Instruction d'impression :
une instruction qui entraîne un affichage à l'écran.

Méthode :
une séquence d'instructions nommée.

Classe :
pour l'instant, une collection de méthodes connexes. (Nous verrons plus tard que cette notion est plus riche que cela.)

Commentaire :
une partie d'un programme contenant des informations sur le programme mais n'ayant aucun effet sur l’exécution du programme.

Chaîne de caractères :
une séquence de caractères, le type primitif de données pour le texte.

Fin de ligne :
un caractère spécial signifiant la fin d'une ligne de texte. Également appelé saut de ligne ou retour à la ligne.

Séquence d'échappement :
une séquence de code représentant un caractère spécial lorsqu'il est utilisé dans une chaîne de caractères.

Les informaticiens ont la fâcheuse habitude d'utiliser des mots communs pour signifier autre chose que leur sens commun.

• Qu'est-ce qu’un programme portable ?
• Que signifie le mot compilation ?
• Qu'est-ce qu'un exécutable ? Pourquoi l’appelle-t-on ainsi ?
  
  Le glossaire à la fin de chaque chapitre est destiné à mettre en évidence les mots et les expressions ayant une signification particulière en informatique. Quand vous y voyez des mots familiers, ne supposez pas que vous savez ce qu'ils veulent dire !

• Avant toute chose, découvrez comment compiler et exécuter un programme Java. Certains environnements fournissent des exemples de programmes similaires à l'exemple de la section 4.
• Saisissez le programme hello world, compilez-le et exécutez-le.
  Ajoutez une instruction d'impression qui affiche un deuxième message après le "Hello World!". Mettez une phrase du style : "Comment allez-vous ?", compilez et exécutez le programme à nouveau.
• Ajoutez un commentaire au programme (n'importe où), recompilez et ré-exécutez-le. Le nouveau commentaire ne devrait pas affecter le résultat.

Cet exercice peut sembler trivial, mais c'est le point de départ de nombreux programmes avec lesquels nous travaillerons. Pour déboguer en toute confiance, vous devez avoir confiance en votre environnement de programmation.

C'est une bonne idée de commettre des erreurs volontairement afin de voir les messages d'erreur du compilateur. Parfois, le compilateur vous dit exactement ce qui ne va pas, et tout ce que vous avez à faire est de le réparer. Mais parfois, les messages d'erreur sont trompeurs. Au fil du temps, vous saurez quoi faire exactement.

En commençant par le programme Hello World, essayez chacune des erreurs suivantes. Après avoir effectué chaque modification, compilez le programme, lisez le message d'erreur (s'il y en a un), puis corrigez l'erreur.

• Retirez l'une des accolades ouvrantes.
• Retirez l'une des accolades fermantes.
• Au lieu demain, écrivez mian.
• Supprimez le mot static.
• Supprimez le mot public.
• Supprimez le mot System.
• Remplacez println par Println.
• Remplacez println par print.
• Supprimez l'une des parenthèses. Ajoutez-en une autre.