Java procédural - noelno/dovelei GitHub Wiki

Comment s’exécute un programme : le microprocesseur lit uniquement les instructions machine. Quand on programme en Java par exemple, le programme est compilé en bytecode, puis traduit en instructions machine par une machine virtuelle.

Comment programme t-on ?

Réfléchir au problème donné
Concevoir la séquence d'instructions (algo)
Coder son algo
Compiler
Tester
Revoir la séquence d'instructions (2.) en cas de gros souci

Code de base :

public class HelloWorld
{
    public static void main(String[] args)
    {
        System.out.println(“Hello, world!”);
    }
}

Que faire en cas d'erreur à la compilation ?
Souvent plusieurs erreurs de compilation sont dues à une seule erreur se situant plus haut dans le code

Corriger la première erreur et recompiler
Vérifier la ligne indiquée par le compilateur et la ligne qui précède, comprendre le message d'erreur fourni par le compilateur pour corriger la ligne fautive

Variables

Les traitements (instructions) opèrent sur des données (ex : modifier des valeurs)
Les données influencent les traitements (en fonction des valeurs, conditions d'exécution)

Une variable = zone mémoire ayant son nom (identificateur) où l’on peut stocker une valeur et à laquelle on doit spécifier un type.

Déclarer une variable avec la syntaxe suivante : type nom = valeur; ou type nom; (on n’est pas obligé d’attribuer immédiatement une valeur à la variable déclarée)
Initialiser une variable c’est faire la déclaration + l’attribution de valeur.
On n'est pas obligé d'initialiser une variable tant que l'on ne s'en sert pas.

Les types courants :
int = un nombre entier ; double = un nombre décimal; char = un caractère

Le type de la variable ne change plus après déclaration.

On peut déclarer plusieurs variables du même type sur une même ligne, même avec des valeurs différentes (ex int p=1, q = 0, y;\\y n'a pas de valeur mais est quand même déclaré) mais ce type de rédaction est déconseillé.

Conventions pour nommer ses variables : les caractères autorisés sont les alphadécimaux et _$ sauf pour le premier caractère qui doit forcément être alphadécimal . Java est sensible à la casse (variable et Variable sont deux noms de variables différents). Ce ne doit pas être un mot clé Java existant. Les mêmes conventions que PHP s’appliquent : 1er mot en minuscule, mots suivants avec 1ere lettre majuscule (lowerCamelCase).

Déclarer une constante = le mot clé final précède la déclaration. Les CONSTANTES s'écrivent en majuscule avec des tirets bas (_) pour séparer les mots. (ex : final int VITESSE_DE_LA_LUMIERE = 27;)

Affectation : elle s’effectue avec l’opérateur = (donc le signe = n’est pas un signe d’égalité en Java !)
Syntaxe : nomVariable = valeur ;
La valeur de droite est copiée et enregistrée dans la case mémoire de la variable à gauche. Pour que cela fonctionne correctement la valeur doit correspondre au type de la variable (exception cependant avec les types de nombres, voir la suite).

Exemple :

public class Affectation
{
    public static void main(String[] args)
    {
        int a = 1;
        int b = 2;
        int c = 3;

        a = b ;
        b = a ;
        c = c + 1 ;

    System.out.print("a = "+a+", b = "+b+" et c = "+c) ;
    } 
}

Dans ce programme a prend la valeur de b, donc a = 2.
Ensuite b, qui est toujours égal à 2 prend la valeur de a. a étant désormais égal à 2, b est toujours égal à 2.
On peut écrire c = c +1 car le programme calcule d’abord l’expression c + 1 et affecte le résultat à c, ce qui donne ici 2 + 1 = 3, affecté à la variable c qui vaut désormais 3.

#Expressions

Expression : valeur littérale (un nombre. Ex : 2) ou une formule mettant en œuvre des opérateurs (un calcul ex : 2 * 2 ; a * a ;…)

Valeurs des expressions : 1 est de type int, 1.0 est de type double
Notation scientifique : syntaxe = 2e3 = 2x10^3 (aeb = ax10^b)
1.3e-3 = 1.3x10^-3
En notation scientifique le type est celui du chiffre précédant le e (ici 1.3 donc double).
/ !\ A savoir pour la division : s’il s’agit d’une division deux entiers (de type int), la division sera une division euclidienne. ex : Si j'affecte 1/2 à x, initialisé double, (double x ; x = 1 /2 ;), le résultat sera 0.0 et pas 0.5 car 1/2 = 0 reste 1 en division euclidienne.

Opérateurs :

les classiques + - * / (addition soustraction multiplication division)
les opérateurs d’assignations combinés +=, -=, *=, /=, %=
l’opérateur modulo (%) pour le type int uniquement
ex : 11%4=3 (car 11=2x4+3)
les opérateurs d'incrémentation et de décrémentation ++ et --
++23==24
++variable==variable+1
Si je veux affecter la valeur d'un double à un int, le programme affiche un message d'erreur signalant une éventuelle perte de précision.
En revanche si j’affecte la valeur d'un int à un double il n’y a aucun problème le programme fait la conversion tout seul.

Fonctions mathématiques : Syntaxe : Math.nomFonction(expression1, expression2,...)
Entre parenthèses les valeurs nécessaires au calcul s’il y en a. Ex : Math.min(a, b) retourne la plus petite des valeurs envoyées (les valeurs de a et de b). Les deux valeurs doivent être de même type.
La liste des noms de fonctions mathématiques est ici : http://docs.oracle.com/javase/7/docs/api/java/lang/Math.html
Syntaxe pour une constante mathématique : Math.nomConstante
ex Math.PI retourne la valeur du nombre pi (type double)

#Variables : lecture et écriture

Pour écrire à l’écran :

  System.out.print("Bonjour vous avez "+age+"ans.") ;

System.out désigne la sortie (out) terminal qui est l’écran. Ici on demande au programme d’envoyer la chaîne de caractère à la sortie terminal et l’y afficher (print). Il existe aussi la méthode println : System.out.println() ; qui fait la même chose mais effectue ensuite un retour à la ligne.

est l’opérateur de concaténation en Java: quand on veut afficher une variable ou la valeur d’une expression dans une chaîne de caractère on doit la laisser hors des guillemets mais il faut la rattacher à la chaine en utilisant des opérateurs + au niveau des guillemets. La variable ou l’expression est évaluée avant l’affichage. ex : System.out.println("Le carre de "+n+" est "+n*n) ; Attention : si l’expression est une somme, la placer entre parenthèse pour éviter que le programme n’interprète le + comme un caractère de concaténation. ex : System.out.println("3 + 3 = "+(3+3)) ;

Quand on veut afficher une variable seule, pas besoin de guillemets : System.out.println(nomVariable) ; Pour intervertir les valeurs de deux variables a et b, deux possibilités :

utiliser une variable temporaire qui va stocker la valeur de a, a prendra la valeur de b et b va récupérer l’ancienne valeur de a dans la variable temporaire.
utiliser la méthode de l’interversion sans mémoire avec ces trois instructions : b = a – b ; a = a – b ; b = a + b ;

Test :

public class interversion { public static void main(String[] args) { int a = 3; int b = 5; System.out.println("a = "+a+", b = "+b) ;

        b = a - b ;
        a = a - b ;
        b = a + b ; 
        System.out.println("a = "+a+", b = "+b) ;
    }
}

Dans l’exemple qui précède le résultat affiché sera : a = 3, b = 5 a = 5, b = 3

Pour lire une valeur au clavier :

Importer la classe Scanner : import java.util.Scanner ; (la majuscule à Scanner est importante, on rappelle que Java est sensible à la casse)
Créer un objet Scanner, c'est-à-dire affecter à une variable nomVariable de classe « Scanner » la valeur new.Scanner() ayant pour paramètre l’entrée système, c'est-à-dire le clavier (System.in). C’est cet objet qui va lire l’entrée clavier.
Pour récupérer une valeur il faut utiliser la méthode nomVariable.nextInt(), qui va retourner la prochaine valeur entière saisie au clavier après avoir appuyé sur entrée. Cette valeur doit être stockée dans une variable pour pouvoir être réutilisée ensuite.

Codé cela donne par exemple : import java.util.Scanner; public class coursera { public static void main(String[] args) { Scanner nomVariable = new Scanner(System.in); System.out.print("Saissisez une valeur : "); int n = nomVariable.nextInt(); System.out.println("Le carre de "+n+" est "+n*n) ;

}
}

On peut donc initialiser la variable stockant la valeur saisie qu’au moment de la saisie (ici on initialise n entier et la valeur est l’entier saisi). Evidemment il y a autant de méthodes que de types : nextInt, nextFloat, nextChar… Le type String (chaîne de caractère) a la méthode nextLine (et non pas nextString comme on pourrait le déduire) pour récupérer une chaîne de caractère jusqu’à la fin de la ligne.

Exemple : je code ceci import java.util.Scanner; public class coursera { public static void main(String[] args) { Scanner nomVariable = new Scanner(System.in); System.out.print("Saissisez une valeur : "); int a = nomVariable.nextInt(); String b = nomVariable.nextLine(); System.out.println("Vous avez saisi "+a+b) ;

}
}

Si l’utilisateur écrit en une seule fois "23 francs" et appuie sur entrée, le 23 sera stocké dans a et le " francs" (espace compris) sera stocké dans b. / !\ Le retour chariot est compté comme chaîne de caractère : Si l’utilisateur écrit en deux fois "23 francs" (il saisit "23", appuie sur entrée et s’apprête à saisir "francs"), 23 sera stocké dans a mais le retour chariot sera stocké dans b, et donc l’utilisateur ne pourra pas écrire "francs".

Les parades possibles :

ajouter un nextLine spécifiquement pour le retour chariot
utiliser une structure conditionnelle qui va vérifier si la chaine est vide ou pas, et dans le cas où elle l’est, faire un nextLine avec la même variable qui va stocker la chaine de caractère suivante.