Un survol de java

Cette page propose une première approche de java, sans être exhaustif.

Un premier programme java

Un programme java est constitué de classes, par exemple :
/** 
    Premier exemple
**/
public class HelloWorld {

    /**
        Point d'entrée du programme
        @param  args Tableau de chaînes passé au programme
    **/
    public static void main(String[] args) {
        System.out.println("Hello World!"); // Affiche une chaîne de caractères
    }
}
Ce code contient plusieurs choses : C'est à l'intérieur des méthodes qu'on écrit le code java qui va être exécuté. Un programme java va être une suite d'instructions, qui vont être exécutées séquentiellement (l'une après l'autre).

A retenir :

Exécution

Avant d'exécuter ce programme, on doit le compiler : on se place dans le répertoire contenant HelloWorld.java et on le compile :
javac HelloWorld.java
Cette opération produit un nouveau fichier, HelloWorld.class, qui est exécutable.
On peut maintenant l'exécuter :
java HelloWorld
Bien noter qu'on utilise un premier outil (javac) pour compiler un fichier, et qu'on utilise un autre outil (java) pour exécuter une classe (et non pas un fichier).

Manipuler des variables

Pour faire des choses plus élaborées, on va pouvoir créer des variables et leur affecter des valeurs.

En java, toute variable qu'on utilise doit être déclarée et associée à un type, par exemple :
int a;
String s;
double d;
boolean b;
Une fois qu'une variable est déclarée, on peut lui affecter une valeur :
a = 17;
s = "Bonjour";
b = true;
On peut déclarer et donner une valeur initiale à une variable dans une seule instruction :
int a = 17;
double d = 45.87;
Les principaux types disponibles sont :
boolean Peut prendre 2 valeurs : true ou false
int Nombre entier - il existe aussi d'autres types : byte, short, long
double Nombre à virgule - il existe aussi le type float
String Représente une chaîne de caractères
Une fois qu'une variable est déclarée, on peut lui affecter des valeurs différentes en utilisant des opérateurs.
int a = 17;
a = a + 3; // maintenant a vaut 20

String nom = "toto";
String affichage;
affichage = "Bonjour " + nom;
Les opérateurs disponibles dépendent du type de la variable.
OpérateursTypes concernésCommentaire
+
-
*
/
Nombres Opérateurs arithmétiques habituels
% Nombres entiers Modulo : reste de la division d'un nombre par un autre.
4 % 3 = 1
+ String Concaténation
A noter, deux raccourcis syntaxiques souvent utilisés :
++ i++ signifie i = i + 1
+= i+=3 signifie i = i + 3
Les mêmes raccourcis existent aussi avec - (l'opérateur moins).
Exercice : Déclaration, affectation

Effectuer des tests

Deux mots-clés du langages permettent de tester des conditions : if et else.
if(une condition){
    faire des choses
}
else {
    faire autre chose
}
Les conditions sont exprimées par des expressions ayant une valeur de type boolean (expressions booléennes).
boolean a = true;
if(a) { ... }
Les expressions booléennes utilisées dans les tests sont souvent le résultat d'opérateurs de comparaison :
== Renvoie true si deux variables sont égales, false sinon.
!= Renvoie true si deux variables sont différentes, false sinon.
>
>=
<
<=
int a = 10, b = 12;
if(a == b) {
    System.out.println("a et b sont égaux");
}
else {
    System.out.println("a et b sont différents");
}
Les instructions if et else peuvent s'enchaîner :
int a = 10, b = 12;
if(a == b) {
    System.out.println("a et b sont égaux");
}
else if(a > b) {
    System.out.println("a est supérieur à b");
}
else {
    System.out.println("a est inféreieur à b");
}
Elles peuvent aussi s'emboîter :
int a = 10, b = 12;
if(a == b) {
    System.out.println("a et b sont égaux");
}
else {
    if(a > b){
        System.out.println("a est supérieur à b");
    }
    else {
        System.out.println("a est inféreieur à b");
    }
}
Les conditions (expressions booléennes) peuvent être combinées avec des opérateurs booléens.
&& et and Evalué à true si les deux opérandes sont évaluées à true.
if(12 > 10 && "a" < "b"){ ... }
|| ou or Evalué à true si une des deux opérandes sont évaluées à true.
if(12 > 10 || "a" > "b"){ ... }
! négation not Evalué à true si l'opérande est évaluée à false.
if(!(12 > 14)){ ... }
Exercice Test de l'âge
Exercice Année bissextile

Ecrire des boucles

On peut demander d'exécuter certaines instructions plusieurs fois.
L'instruction for est la plus fréquemment utilisée.
for(int i=0; i < 10; i++){
    System.out.println(i);
}
Signification :
for(initialisation; condition d'arrêt; update){ ... }
Exercice : Ecrire un programme qui affiche les nombres pairs, de 2 à 20.
On peut aussi écrire des boucles de deux autres manières :
int i = 0;
while(i < 10){
    System.out.println(i);
    i++;
}
int i = 0;
do{
    System.out.println(i);
} while(i < 10)
Deux instructions importantes permettent de modifier le cours d'une boucle : break et continue.

break

break permet de sortir de l'instruction qui la contient.
for(int i = 0; i < data.length; i++) {
    if (data[i] == target) {
        index = i;
        break;
    }
} // l'interpreteur arrive ici après le break

continue

Passe à l'itération suivante de la boucle
for(int i = 0; i < data.length; i++) {
    if(data[i] == false){
        continue;
    }
    process(data[i]);
}
Exercice Multiples1
Exercice TableMultiplication

Créer et appeler des méthodes

La très grande majorité du code qu'on écrit se trouve dans des méthodes (terminologie objet pour désigner une fonction).
Les méthodes se trouvent à l'intérieur de classes, comme la méthode main() qu'on a déjà vu.
Au sein d'une classe, une méthode doit avoir une signature unique. Voir page Méthodes.

Application : L'exemple HelloWorld pourrait être modifié pour déporter l'affichage dans une méthode :
Voir l'exemple HelloWorld2.java
Une variante pourrait passer en agrument la chaîne à afficher.
Voir l'exemple HelloWorld3.java
Exercice : Reprendre l'exercice Test de l'âge et écrivez une méthode qui effectue le test.
En entrée, elle prend en paramètre un int.
En sortie, elle renvoie un boolean.

Utiliser des tableaux

Voir page Tableaux
Exercice Max et moyenne
Exercice : Voitures
Exercice : Nombres premiers

Créer des objets

Jusqu'à présent, on a créé des classes qui ne contenaient que des méthodes de classe (déclarées static).
Travailler uniquement avec des méthodes static revient finalement à programmer de manière classique (impératif non-objet), et les classes fournissent juste un moyen commode de "ranger" les méthodes.
Voir les pages Introduction à l'objet (sans la partie sur l'héritage) et Classes, interfaces.
A retenir :
Exercice : Personnes

Travailler avec des packages

Voir page "Packages, application java