Ce cours vous introduit au Java dans sa dimension procédurale. Le but de ce cours est de vous familiariser avec les instructions de base avant d’aborder les concepts de la programmation objet.
Pour le moment, nous appellerons classe un programme Java. Une classe se présente de la sorte :
class NomClasse
{
/*
Class contents
*/
}
Vous remarquez que de façon analogue au C, une classe est un bloc délimité par des accolades et que les commentaires d’écrivent de la même façon. On ecrit les noms des classes en concaténant les mots composant ce nom et en faisant commencer chacun d’eux par une majuscule. N’oubliez pas de ne mettre qu’une seule classe par fichier et de donner au fichier le même nom que celui de cette classe.
Nous disposons en Java des mêmes types qu’en C. Tous les types mis à votre
disposition par Java sont appelé
types primitifs.
L’un deux nous servira toutefois à écrire des choses que l’on rédige
habituellement de façon crade en C :
boolean. Une variable de
type
boolean peut prendre une des deux valeurs
true
et
false, et seulement une de ces deux valeurs. On déclare et
utilise les variables exactement de la même façon qu’en C.
Il existe un type chaîne de caractères en C. Nous l’examinerons plus
détails ultérieurement. Les deux choses à savoir est que le type
chaîne de caractères est
String, et que l’opérateur de
concaténation est
+.
finalLes variables dont la déclaration de type est précédée du
mot-clé
final sont non-modifiables. Une fois qu’une valeur
leur a été affecté, il n’est plus possible de les modifier. On s’en
sert pour représenter des constantes. Les règles typographiqus sont
les mêmes : toutes les lettres en majuscules et les mots séparés par
des
\_. Par exemple,
final int TAILLE = 100;
Déclare une constante
TAILLE de type
int initialisée
à 100.
La saisie de variables est un calvaire inutile en Java, nous nous en
passerons pour le moment. Pour afficher un message, quel que soit son
type, on utilise le sous-programme
System.out.print. Par
exemple,
System.out.print("Hello World\n");
Le sous-programme
System.out.println ajoute automatiquement
un retour à la ligne après l’affichage. On aurait donc pu écrire :
System.out.println("Hello World");
Il est aussi possible d’intercaler valeurs de variables et chaînes de
caractères constantes, on sépare les arguments par des
+. Par
exemple,
System.out.println("La valeur de a est " + a +
"et celle de b est " + b);
On définit en Java des sous-programmes de la même façon qu’en C,
attention toutefois, les sous-programmes que nous définirons dans ce
cours seront déclarés avec le mot-clé
static. Par exemple, si
je veux faire un sous-programme qui retourne le successeur de la valeur
passée en argument cela donne
class TestJavaProcedural
{
static int succ(int i)
{
return i + 1;
}
/*
Autres sous-programmes
*/
}
Si vous oubliez le mot clé
static, le compilateur vous
enverra des insultes. Nous verrons plus tard ce que signifie ce mot et
dans quels cas il est possible de s’en passer. Attention : Tous les
types primitifs en Java se passent en paramètre par valeur, et cette
fois-ci je ne vous mens pas !
Lorsque vous invoquez la machine virtuelle, elle part à la recherche
d’un sous-programme particulier appelé
main. Il est impératif
qu’il soit défini comme suit :
public static void main(String[] args)
{
/*
instructions
*/
}
La signification du mot-clé
public vous sera expliquée
ultérieurement. La seule chose dont il faut prendre note est que vous
ne devez pas l’oubliez, sinon la machine virtuelle vous enverra des
insultes !
En Java, les instructions
if,
switch,
for,
while et
do ... while se comportent de la même façon
qu’en C. Donc, pas d’explications complémentaires...
Nous avons maintenant tout ce qu’il faut pour écrire un petit programme :
package procedural;
public class Exemple
{
/*
* Retourne le nombre b eleve a la puissance n.
*/
static int puissance(int b, int n)
{
int res = 1;
for (int i = 1; i <= n; i++)
res *= b;
return res;
}
/*
* Affiche {2^k | k = 0, ..., 30}.
*/
public static void main(String[] args)
{
for (int k = 0; k <= 30; k++)
System.out.println("2^" + k + " = " + puissance(2, k));
}
}
L’instruction
import que vous utilisez depuis le début sert à
localiser une classe parmi les packages standard de Java. Si par
exemple vous importez
import java.awt.event.*, cela signifie
que vous allez utiliser les classes se trouvant dans le package
qui se trouve dans le package
event qui se trouve dans
le package
awt qui se trouve dans le package
java
(qui est la bibliothèque standard).
Il possible pour un programmeur de créer ses propres packages, deux choses sont nécessaires :
Par exemple,
package procedural;
public class ExemplePackage
{
public static void presenteToi()
{
System.out.println("Je suis collections.ExemplePackage");
}
public static void main(String[] args)
{
presenteToi();
}
}
On exécute et compile ce fichier en se plaçant non pas dans le
répertoire où se trouve les source, mais dans le répertoire ou se
trouve le package. Par conséquent, l’exécution en ligne de commande se
fait avec
javac procedural.ExemplePackage
Vos packages s’utilisent comme les packages de la bibliothèque
standard. Si le
main se trouve en dehors de votre package,
la variable d’environnement
CLASSPATH sera utilisée pour
localiser votre package.