Java 02 : De l'algorithmique au Java

Maintenant que tu as écrit et exécuté ton premier programme en Java, tu vas pouvoir te lancer dans des créations plus complexes.

Tu possèdes déjà des connaissances algorithmiques et tu sais peut-être écrire du code dans un autre langage, mais Java a sa propre syntaxe, que tu vas découvrir dans cette quête.

Objectifs

• Connaître la syntaxe du Java
• Réaliser un traitement en Java

Variables, types et affectation

1. Variable

Rappel : une variable permet de stocker une valeur et d'en modifier son état. Si tu as réalisé quelques algorithmes, tu as eu l'occasion d'utiliser des valeurs entières, réelles, du texte et des valeurs vraies et fausses.

En Java, la déclaration d'une variable se fait de la façon suivante :

type nomVariable;

Le point virgule termine chaque opération en Java. Si tu l'oublies, le compilateur te grondera !

Une variable doit être en anglais et écrite en CamelCase commençant par une minuscule.

2. Type

Le type d'une variable correspond à la nature de la valeur stockée. En Java, une variable ne peut pas changer de type une fois qu'elle a été déclarée.

Les principaux types sont les suivants (tu auras l'occasion d'en découvrir d'autres plus tard) :

• int : entier, par exemple 42

• double : réel, par exemple 3.14

• String : texte, entre guillemets, par exemple "tacos"

• boolean : contient les valeurs booléennes true et false, respectivement vrai et faux

3. Affectation

int life = 42;
double badPi = 3.14;
String food = "tacos";
boolean hasLegalAge = false;

Dans l'exemple précédent, tu as dû remarquer l'utilisation du signe égal : c'est un opérateur d'affectation. Il sert à assigner une valeur à une variable.

Il est possible d'affecter plusieurs valeurs à une même variable, mais la valeur la plus récente écrasera les autres :

int age;
age = 12;
age = 18;
System.out.println(age); // 18

Conditions, opérateurs de test et de logique

1. Condition

Rappel : une condition est un embranchement qui exécute des instructions différentes en fonction de la valeur du test.

En algorithmique, cela se présente sous la forme suivante :

Si age > 17
    afficher "Majeur"
Sinon
    afficher "Mineur"
Fin Si

Voici le même exemple de condition en Java :

if (age > 17) {
    System.out.println("Majeur");
} else {
    System.out.println("Mineur");
}

2. Opérateurs de test

La condition doit être un booléen, c'est avoir les valeurs vrai ou faux.

Il est donc possible d'assigner le résultat d'un test à un booléen, et d'effectuer une condition dessus :

boolean hasLegalAge = age > 17;
if (hasLegalAge) {
    // ...
}

Il existe plusieurs opérateurs de test, en voici quelques-uns :

• == : est égal à

• != : est différent de

• > : est supérieur à

• < : est inférieur à

• >= : est supérieur ou égal

• <= : est inférieur ou égal

Attention à ne pas confondre l'affectation = avec l'égalité == !

if (age == 18) {} // ne sera vrai que si age est égal à 18

if (age = 18) {} // sera toujours vrai, car le résultat d'une affectation est vrai

3. Opérateurs logiques

Il est possible de combiner des booléens dans une condition, en utilisant des opérateurs logiques.

En algorithmique, cela ressemble à ça :

    Si age > 12 ET age < 18
        ...
    Sinon
        ...

Et en Java, l'équivalent sera :

    if (age > 12 && age < 18) {
        // ...
    } else {
        // ...
    }

Voici les opérateurs logiques les plus utilisés et leurs fonctionnements respectifs :

• && : ET logique // (true && false) == false

• || : OU logique // (true || false) == true

• ! : NON logique // true != false && !true == false

    boolean isTeenager = age > 12 && age < 18;

    // pareil que isTeenager == false
    if (isTeenager != true) {
        System.out.println("Not a teenager");
    }
    // et la même chose que :
    if (!isTeenager) { // tu préfèreras cette écriture
        System.out.println("Not a teenager");
    }

Boucles

Rappel : une boucle est une répétition d'instructions, qui possède une condition d'arrêt de type booléen.

Il existe plusieurs formes de boucles. Voici *TANT QUE *:

    Tant que age < 18
        age ← age + 1
    Fin Tant que

Soit en Java :

    while (age < 18) {
        age = age + 1;
    }

Attention à ta condition d'arrêt ! Si la condition reste vraie, tu rentres dans une boucle infinie, qui fera crasher la JVM.

    int age = 10;
    while (age < 18) {
        age = age - 1;
        // boucle infinie, crash en vue car
        // la condition sera toujours vraie !
    }

Challenge

Achat de bonbons

Voici l'algorithme suivant :

   réel money ← 12.4; 
   réel price ← 1.2
   entier candies ← 0
   Si money > 0 ET price > 0
       Tant que (money - price) >= 0
           candies ← candies + 1
           money ← money - price
       Fin Tant que
   Fin Si
   afficher candies

1. Crée un nouveau dossier dans JavaProjects, que tu nommeras Candies.
2. Dans le dossier Candies, crée la classe CandyCount.java.
3. Déclare ta classe CandyCount et ajoute une méthode main(), telle qu'elle est montrée dans la Java - Introduction.
4. Dans ta méthode main(), écris en Java le code de l'algorithme du challenge.
5. Compile et exécute le code afin de tester qu'il fonctionne correctement.
6. Copie ton code dans un Gist et partage le fichier CandyCount.java en solution.

Critères de validation

• Le fichier doit bien s'appeler CandyCount.java et la classe CandyCount.
• La classe doit se compiler sans message d'erreur.
• À l'exécution de la classe compilée, le chiffre 10 doit apparaître dans le terminal.