Apprenez à programmer en Java

Alors que le projet Epicrafter’s Journey vit ses premiers jours, une équipe a été constituée. Laissez-moi vous présenter ses membres :

• Jenny est une professionnelle expérimentée dans le domaine de la gestion de projet. Elle a travaillé dans plusieurs entreprises de développement de jeux vidéo avant de rejoindre votre équipe.

• Marc est un développeur senior avec une expertise approfondie dans la programmation Java. Il a une solide expérience dans la gestion d'équipes techniques et la direction de projets de grande envergure.

Après votre première rencontre, Marc souhaite vous faire monter en compétences avant de vous lancer concrètement dans le bain. Jenny décale donc le planning et vous laisse quelques jours pour vous préparer avant le lancement des grandes manœuvres !

Marc vous explique :

Tu vas te préparer une boîte à outils. Tu sais, un développeur est comme un artisan. Face à un nouveau chantier, l'artisan va préparer ses outils pour réaliser son travail, et pour cela il fera le tour de son atelier pour vérifier ce qu’il a à disposition.

L’idée est saisie ! Faisons le tour de l’atelier Java dans ses premiers chapitres afin de nous permettre le moment venu de choisir le bon outil pour la bonne tâche.

Découvrez les variables

Quel est le premier outil de notre atelier qui mérite d’être examiné ? Pour cela demandons-nous ce que fait fondamentalement un programme ?

Bonne tentative ! Je ne peux pas vous donner tort, mais soyons plus précis. Répondre à cette question n’est pas si simple, voilà mon avis : fondamentalement, un programme traite des données.

Cette définition me plaît car elle fait ressortir deux points :

1. Un programme implique des données.

2. Un programme implique des traitements.

Commençons par parler des données. Les programmes que nous développons doivent être en mesure de manipuler de l’information ou bien de la donnée. En tant qu’être humain, nous sommes constamment en train de traiter de l’information. Nos différents sens nous permettent de capter l’information puis notre cerveau l'interprète ce qui nous amène à agir d’une façon ou d’une autre. Nous retenons très brièvement certaines informations tandis que nous gardons précisément en mémoire d’autres informations.

Un programme devra se comporter comme notre cerveau et donc manipuler de l’information.

Premièrement grâce à des variables ! Voilà le premier outil que nous devons savoir utiliser. Une variable est un espace mémoire du système d'exploitation qui contient une information.

Comparons les variables à des boîtes. Imaginez une boîte dans laquelle nous allons ranger quelque chose et celle-ci sera étiquetée avec un nom.

Étant donné que le langage Java est typé, nous ne pourrons pas nous contenter de donner uniquement une étiquette (un nom) à notre boîte. Nous allons devoir également indiquer sa forme, autrement dit son type.

Retenez d’ores et déjà ce point clé, une variable se définit par un nom et un type.

Maintenant j’attire votre attention sur 3 aspects : la déclaration, l’affectation et l’initialisation d’une variable.

• Déclarer une variable correspond au moment où l’on indique le type et le nom de la variable. Pour reprendre notre exemple, on choisit la forme de la boîte et on y colle l’étiquette avec le nom.

• Affecter une donnée à une variable c’est lorsque l’on met un objet dans la boîte. C’est possible grâce à l’opérateur d’affectation :=.

• Initialiser une variable correspond au moment où l’on insère une donnée pour la première fois. C’est donc la première affectation.

Enfin une variable possède une portée, ce qui signifie qu’elle sera utilisable uniquement dans une certaine zone de code. Notre boîte est rangée dans une pièce. En dehors de la pièce on ne la voit plus et on pourrait dire qu’elle est hors de notre portée. De la même façon, lorsqu'une variable est déclarée dans un bloc de code, elle est ensuite disponible uniquement dans ce bloc.

Vous avez raison, j’y arrive. Pour ce faire, laissez-moi vous présenter les types primitifs.

Comprenez les types primitifs

Un type permet de définir, symboliquement parlant, la forme de notre variable. Java nous offre 8 types dits primitifs. Retenons que c’est la façon la plus simple de typer une donnée. Mais assez parler, retrouvez-moi dans la démonstration ci-dessous :

Que pouvons-nous retenir de cette démonstration ?

• Eclipse nous permet de créer rapidement un projet minimal où nos fichiers Java seront organisés dans des packages. Un package est comme un dossier où l’on range nos fichiers.

• Chaque instruction Java se termine par le caractère ;.

• La fonction public static void main(String[] args) { } est le point d’entrée de notre programme. Une fonction est un bloc de code permettant d’exécuter un traitement.

• On déclare une variable avec la syntaxe suivante :int valeur

• Les variables qui utilisent un type primitif possèdent une valeur par défaut. Ainsi une variable de type int vaut 0 par défaut.

• On déclare et initialise une variable avec la syntaxe suivante : int valeur = 5;

• On change la valeur d'une variable avec la syntaxe suivante : valeur = 10;

• Le mot-clé final permet de rendre immuable une variable. La valeur de la variable est définie une fois et ne peut plus être changée ensuite.

Tandis que nous parlons de variables numériques sachez que l’on peut y appliquer les opérateurs arithmétiques habituels : +, -, *, /

Par exemple :

int nombreUn = 2;
Int nombreDeux = 5;
Int numbreTrois = nombreUn + nombreDeux;

Voici un tableau reprenant les 8 types et une description associée :

Bonne remarque ! C’est en effet insuffisant, allons découvrir les types complexes.

Comprenez les types complexes

Comment gérer tous les types d’information possibles et inimaginables ? La solution qu'apporte un langage de programmation à cette problématique sera des plus importantes.

Il est certain qu’il faut une solution dynamique. Autrement dit, puisqu’il serait impossible de définir à l’avance tous les types de données possibles, il est crucial de pouvoir définir ses propres types au fur et à mesure. Et Java nous fournit un tel outil !

Le langage Java applique le paradigme de programmation objet. Bien que je ne veuille pas trop anticiper sur la seconde partie du cours qui va expliquer ce paradigme en long et en large, sachez qu’un objet est un ensemble de données et de traitements.  

Dans le contexte des variables, le point clé est l’expression “ensemble de données”. En fait, un objet peut assembler plusieurs données ensemble. On peut ainsi définir des données complexes et ainsi des types complexes. Le point étant qu’un objet est un type.

Voyez cela ensemble dans la démonstration suivante :

Qu’avons-nous pu voir ensemble ?

• L’instruction  String langage = “Java”  permet de déclarer et initialiser en une seule fois une variable contenant une chaîne de caractères.

• L’instruction  String phrase = langage + " est un langage de programmation.";  permet de concaténer la variable  langage  avec une autre chaîne de caractères.

• L’instruction  System.out.println(phrase);  permet d’afficher la chaîne de caractères dans la console.

Ce simple exemple est pertinent pour découvrir les types complexes. Mais c’est bien dans la deuxième partie de ce cours que nous verrons toute la puissance de ces types grâce à la programmation orientée objet !

Utilisez un tableau de variables

Pour gérer un ensemble de données d’un même type, le langage Java comme de nombreux autres langages de programmation implémente les tableaux (array en anglais).

Un tableau possède un nombre défini d’éléments. Chaque case du tableau peut contenir un élément. Chaque élément est du même type.

Observez le code suivant :  int[] unTableauDEntier = {5,10,15,20};

• J’ai déclaré un tableau nommé unTableauDEntier contenant des entiers.

• J’ai affecté 4 valeurs de type int, à savoir 5, 10, 15 et 20.

Je peux accéder à une case du tableau en indiquant l’indice de cette dernière grâce à la notation suivante :  unTableauDentier[0];

Il est également possible de déclarer et initialiser un tableau où chaque case est vide avec la notation suivante :  char[] unTableauDeChar = new char[3];

• J’ai déclaré un tableau nommé unTableauDeChar contenant des caractères.

• J’ai utilisé le mot-clé new pour initialiser 3 cases dans le tableau.

Nous pouvons ensuite affecter une valeur à chaque case. Par exemple :

unTableauDeChar[0] = ‘a’;
unTableauDeChar[1] = ‘b’;
unTableauDeChar[2] = ‘c’;

Avant de conclure cette section, sachez que pour être précis il s’agit ici d’un tableau unidimensionnel. Il est possible de créer des tableaux à plusieurs dimensions. Voyez la notation suivante : 

int[][] unTableauBiDimentionnel = new int[2][3];

Dans cet exemple il y a donc 6 cases avec pour indices : [0][0], [0][1], [0][2], [1][0], [1][1], [1][2].

Voyons désormais ensemble la dernière notion liée aux variables pour ce chapitre.

Utilisez le mot-clé var pour définir vos variables

Une des caractéristiques du Java est que c’est un langage typé. Nous l’avons bien vu dans les sections précédentes, impossible de déclarer une variable sans indiquer le type. Cette contrainte a l’avantage de forcer le développeur à mieux comprendre ce qu’il code mais il faut reconnaître que cela peut aussi alourdir le code.

Ainsi depuis la version 10 de Java le mot-clé var a été introduit pour simplifier l’écriture du code.

Ce mot-clé peut se substituer au type lors de la déclaration de la variable. Par exemple :

var unEntier = 5;

Pour la bonne raison qu’il faut utiliser cette possibilité avec précaution. Dans le bytecode généré, le compilateur aura défini le bon type à la place du mot-clé var. La condition est que lors de la déclaration de la variable cette dernière soit également initialisée pour permettre au compilateur de déterminer le type correspondant.

Au vu de cette particularité, soyez intransigeants sur les deux points suivants concernant l’utilisation du mot-clé var :

• Les variables doivent être utilisées dans un bloc de code restreint pour limiter la confusion dans la lecture du code.

• Les variables doivent avoir un nom à forte valeur sémantique pour compenser l’indication que fournit habituellement le type.

À vous de jouer

Contexte

Marc :

Est-ce que tu connais le fameux Hello World ? C’est la première chose que fait généralement un développeur avec un nouveau langage de programmation. Je te laisse me montrer ça !

Enthousiaste de cette première tâche qui vous est confiée, vous créez un projet dans le but d’afficher le texte Hello World dans une console.

Consignes

1. Créez un fichier Main.java et ajoutez y le code minimal : 

   public class Main {
   }

2. Puis ajouter la fonction main qui est le point d’entrée de tout projet Java.

3. Au sein de cette fonction déclarez une variable nommée texte de type String et affectez y la valeur “Hello World”. 

4. Ensuite affichez cette valeur dans la console.

En résumé

• Une variable permet de contenir une donnée.

• Une variable est déclarée grâce au type et au nom de cette dernière.

• Il existe les types primitifs (int, boolean, char, etc.) et les types complexes.

• Le mot-clé var permet de ne pas spécifier le type lors de la déclaration de la variable.  

Nous avons terminé pour ce qui est de ce chapitre sur les données. Dans le prochain chapitre, abordons le thème du traitement avec les fonctions !