Les bases du javaCe cours présente les bases du fonctionnement d'un programme java et permettra de mieux comprendre quels sont les différents éléments le consituant

Exemple introductif

Exemple de programme

Nous allons commencer par observer un programme Java qui permet d'afficher deux phrases à l'écran

/**
 * Exemple de programme Java. Cette classe permet de lancer un programme d'affichage de lignes
 *
 * @author Julien
 *
 */
public class Affiche {
	public static void main (String[] args)	{
		System.out.println ("Voici un exemple de programme Java.");
		System.out.println ("Deux lignes sont affichées");
	}
}
Une fois ce programme exécuté, nous pourrons voir :
Voici un exemple de programme Java.
Deux lignes sont affichées

Analyse du programme

  • Les six premières lignes du programme, commençant par les caractères /**, sont des commentaires. Ils permettent de décrire le code.
  • De la ligne 7 à la ligne 12, nous sommes dans la classe Affiche. Le corps de la classe se situe entre l'accolade ouvrante et l'accolade fermante.
  • Dans le corps de la classe, on retrouve une méthode. Il 'agit d'un groupe d'instructions auquel on a donné un nom. Dans cet exemple, elle s'appelle main et contient deux instructions (lignes 9 et 10). Toutes les instructions se terminent par un point-virgule ( ; ). Tout programme Java doit comporter une méthode public static void main (String[] args) qui est la méthode principale, le point d'entrée du programme.
  • Les deux instructions de la méthode main font appel à une autre méthode, la méthode println. Cette dernière permet d'afficher des caractères à l'écran. Par contre, elle n'est pas définie dans ce programme, mais fait partie de l'objet System.out que nous examinerons dans le chapitre 3. On voit donc qu'on a des définitions et des appels de méthodes.
Les commentaires

Les commentaires sont très utiles pour le programmeur, mais ne servent à rien pour le fonctionnement du programme.

Il y a plusieurs façons d'insérer des commentaires, chaque façon a une utilité particulière.

Les commentaires par blocs

Les blocs de commentaire permettent de décrire un fonctionnement du programme au sein d'une méthode ou d'une classe. Ils sont précédés par /* et terminent par */

/*
 * Commentaire
 */

La javadoc

La javadoc est un type de commentaire normalié qui permettent de décrire les méthodes, les classes, les constructeurs. Ces blocs sont structurés avec différents identifiants. Ils commencent par /** et terminent par */

/**
 * Cette méthode permet de ...
 * @param p1
 *     description du paramètre p1
 * @return description du résultat de la méthode
 */
public String methode(String p1){}

Les bloqueurs de code

Les bloqueurs de code sont un type de commentaire particulier qui sert à ne pas exécuter une partie de code. Ces commentaires sont précédés de //


// System.out.println("Texte");
// Le code ne sera pas exécuté
Types de données

Types primitifs

Java est un langage orienté objet, c'est-à-dire que les éléments manipulés sont des instances de classes : des objets.

Toutefois ces objets contiennent des données possèdant un type. Ces données sont un ensemble d'éléments stockés en mémoire et baptisés pour l'occasion types primitifs. Les données manipulées avec Java, sont typées, c'est-à-dire que pour chaque donnée que l'on utilise (dans les variables par exemple) il faut préciser le type de donnée, ce qui permet de connaître l'occupation mémoire (le nombre d'octets) de la donnée ainsi que sa représentation.

Voici un tableau répertoriant les primitives (types de données) de Java :

Primitive Signification Taille (en octets) Plage de valeurs acceptée
charCaractère2valeur du jeu de caractères Unicode (65000 caractères possibles)
byteEntier très court1-128 à 127
shortEntier court2-32768 à 32767
intEntier4-2 147 483 648 à 2 147 483 647
longEntier long8-9223372036854775808 à 9223372036854775807
floatflottant (réel)4-1.4*10-45 à 3.4*1038
doubleflottant double84.9*10-324 à 1.7*10308
booleanbooléen1true ou false

Les Wrapper

Les primitives peuvent être "enveloppées" dans un objet provenant d'une classe prévue à cet effet et appelée Wrapper (mot anglais signifiant enveloppeur). Les enveloppeurs sont donc des objets pouvant contenir une primitive et auxquels sont associés des méthodes permettant de les manipuler. Voici la liste des enveloppeurs disponibles avec Java :

Enveloppeur Primitive associé
BigDecimal aucune primitive associée, car cette classe peut contenir des valeurs décimales de précision quelconque
BigInteger aucune primitive associée, car cette classe peut contenir des valeurs entières de précision quelconque
Character char
Byte byte
Short short
Integer int
Long long
Float float
Double double
Boolean boolean

Caractères et chaines de caractères

Le type char (provenant de l'anglais character) permet de stocker la valeur Unicode, codée sur 16 bits, d'un caractère, c'est-à-dire un nombre entier codé sur 16 bits, soit 65000 caractères ! Par conséquent il est possible de stocker un caractère accentué dans une variable de type char.

Si jamais on désire par exemple stocker la lettre B, on pourra définir cette donnée soit par son code Unicode (\u0066), soit en notant 'B' ou les apostrophes simples signifient code ascii de...

Les chaînes de caractères ne correspondent pas à un type de données mais à une classe, ce qui signifie qu'une chaîne de caractère est un objet possèdant des attributs et des méthodes. Une chaîne peut donc être utlisée en utilisant des doubles quotes : "Chaine de caractères";

Quelques opérations courantes sur les chaines de caractères

Comparaisons

On peut être tenté de comparer deux strings à l'aide de l'opérateur ==

if (str1 == str2)

Or, cette comparaison, bien que correcte, ne compare pas si les deux chaînes sont égales, mais si str1 et str2 pointent vers le même objet.

Une comparaison de chaînes s'effectue de la manière suivante :

if (str1.equals(str2))

Concaténations

Pour concaténer des chaînes de caractères, nous utilisons l'opérateur +

String s="chaine1";
String s2="chaine 2";
String res=s+" "+s2;

Autres opérations

Sur une chaine de carctères s

  • s.length() : donne la taille de la chaine de caractères
  • s.substring(a, b) : extrait la chaine de caractères entre les indices a et b
  • s.toLowerCase() : met la chaine en minuscules
  • s.toUpperCase() : met la chaine en majuscules
String s="Chaine de caractères";
System.out.println(s.toLowerCase());//chaine de caractères
System.out.println(s.substring(1, s.length()-2)());//haine de caractère

Tableaux et listes

Les tableaux

Un tableau est un ensemble d'éléments basé sur un même type : par exemple, un tableau d'entiers, un tableau de chaînes de caractères, ...

Pour créer un tableau on utilise les caractères []. Par exemple :

int [] tab1; // Déclaration d'un tableau d'entiers
String[] tab2; // Déclaration d'un tableau de String
int [] tab3 = { 10, 20, 30 }; // Déclaration et valorisation d'un tableau d'entiers

Pour accéder à l'élément i du tableau, on utilise tab[i], et tab.length() retourne ne nombre d'éléments du tableau

int [] tab3 = { 10, 20, 30 };
System.out.println(tab3.length());// 3
System.out.println(tab[1]); // 20

Les listes

Les tableaux sont des éléments de taille fixe, on ne peut ni ajouter ni retirer des éléments. Un objet particulier : les listes permettent de réaliser un certain nombre d'opérations

Pour créer une liste :

ArrayList<String> liste = new ArrayList<>;
liste.add("element1");
liste.add("element2");
System.out.println(liste.size());// Taille de la liste : 2
System.out.println(liste.get(1));// récupération de l'élément 1 : element2
liste.remove(0);// Suppression de l'élément 0
Variables et constantes

Le concept de variable

Une variable est un objet repéré par son nom, pouvant contenir des données, qui pourront être modifiées lors de l'exécution du programme. Les variables en langage Java sont typées, c'est-à-dire que les données contenues dans celles-ci possèdent un type, ainsi elles sont donc stockées à une adresse mémoire et occupent un nombre d'octets dépendant du type de donnée stockée.

Avec Java, les noms de variables peuvent être aussi long que l'on désire, toutefois le compilateur ne tiendra compte "que" des 247 premiers caractères. De plus, elles doivent répondre à certains critères :

  • un nom de variable doit commencer par une lettre (majuscule ou minuscule) ou un "_" (pas par un chiffre)
  • un nom de variables peut comporter des lettres, des chiffres et le caractère _ (les espaces ne sont pas autorisés!)
  • un nom de variable ne peut pas être un mot réservé : class, int, boolean, etc.

Attention : les noms de variables sont sensibles à la casse (Java fait la différence entre un nom en majuscule et un nom en minuscules), il faut donc veiller à utiliser des noms comportant la même casse!

La déclaration de variables

Pour pouvoir utiliser une variable, il faut la définir, c'est-à-dire lui donner un nom, mais surtout un type de donnée à stocker afin qu'un espace mémoire conforme au type de donnée qu'elle contient lui soit réservé.

Une variable se déclare de la façon suivante :

type nomDeLaVariable;

Affectation d'une donnée à une variable

Pour stocker une donnée dans une variable que l'on a initialisée, il faut faire une affectation, c'est-à-dire préciser la donnée qui va être stockée à l'emplacement mémoire qui a été réservé lors de l'initialisation. Pour cela on utilise l'opérateur d'affectation "=" :

nomDeLaVariable = donnée;
Pour stocker le caractère B dans la variable que l'on a appelée Caractere, il faudra écrire :
char caractere;
caractere = 'B';

Initialisation d'une variable

La déclaration d'une variable ne fait que "réserver" un emplacement mémoire où stocker la variable. Tant que l'on ne lui a pas affecté une donnée celle-ci contient ce qui se trouvait précédemment à cet emplacement, que l'on appelle garbage (en français: détritus).

On peut donc affecter une valeur initiale à la variable lors de sa déclaration, on parle alors d'initialisation :

type nomDeLaVariable = donnee;

Par exemple :

float f = 125.36f;

On peut voir une variable comme une boite dans laquelle on peut placer une donnée. Cette boite, on va lui donner un nom afin de l'identifier pour accéder et modifier son contenu.

Portée (visibilité) des variables

Selon l'endroit où on déclare une variable, celle-ci pourra être accessible (visible) de partout dans le code ou bien que dans une portion confinée de celui-ci (à l'intérieur d'une fonction par exemple), on parle de portée (ou visibilité) d'une variable.

Lorsqu'une variable est déclarée dans le code même, c'est-à-dire à l'extérieur de toute fonction ou de tout bloc d'instruction, elle est accessible de partout dans le code (n'importe quelle fonction du programme peut faire appel à cette variable). On parle alors de variable globale

Lorsque l'on déclare une variable à l'intérieur d'un bloc d'instructions (entre des accolades), sa portée se confine à l'intérieur du bloc dans lequel elle est déclarée.

  • Une variable déclarée au début du code, c'est-à-dire avant tout bloc de donnée, sera globale, on pourra alors les utiliser à partir de n'importe quel bloc d'instruction
  • Une variable déclarée à l'intérieur d'un bloc d'instructions (dans une fonction ou une boucle par exemple) aura une portée limitée à ce seul bloc d'instruction, c'est-à-dire qu'elle est inutilisable ailleurs, on parle alors de variable locale

D'une manière générale il est tout de même préférable de donner des noms différents aux variables locales et globales...

Définition de constantes

Une constante est une variable dont la valeur est inchangeable lors de l'exécution d'un programme. Java ne possède pas véritablement de constantes. Toutefois, le mot clé final permet de définir une variable dont la valeur ne peut pas être modifiée après son initialisation.

final int Variable = 12;
Opérateurs

Qu'est-ce qu'un opérateur?

Les opérateurs sont des symboles qui permettent de manipuler des variables, c'est-à-dire effectuer des opérations, les évaluer, ... On distingue plusieurs types d'opérateurs :

  • les opérateurs de calcul
  • les opérateurs d'assignation
  • les opérateurs d'incrémentation
  • les opérateurs de comparaison
  • les opérateurs logiques
  • Les opérateurs de calcul
  • Les opérateurs de calcul permettent de modifier mathématiquement la valeur d'une variable

Nous ne verrons ici que les opérateurs principaux

Les opérateurs de calcul

Les opérateurs de calcul permettent de modifier mathématiquement la valeur d'une variable

Opérateur Dénomination Effet Exemple Résultat (avec x valant 7)
+ opérateur d'addition Ajoute deux valeurs x+3 10
- opérateur de soustraction Soustrait deux valeurs x-3 4
* opérateur de multiplication Multiplie deux valeurs x*3 21
/ plus: opérateur de division Divise deux valeurs x/3 2.3333333
= opérateur d'affectation Affecte une valeur à une variable x=3 Met la valeur 3 dans la variable x

Les opérateurs d'assignation

Ces opérateurs permettent de simplifier des opérations telles que ajouter une valeur dans une variable et stocker le résultat dans la variable. Une telle opération s'écrirait habituellement de la façon suivante par exemple: x=x+2

Avec les opérateurs d'assignation il est possible d'écrire cette opération sous la forme suivante: x+=2. Ainsi, si la valeur de x était 7 avant opération, elle sera de 9 après...

Opérateur Effet
+=addition deux valeurs et stocke le résultat dans la variable (à gauche)
-=soustrait deux valeurs et stocke le résultat dans la variable
*=multiplie deux valeurs et stocke le résultat dans la variable
/=divise deux valeurs et stocke le résultat dans la variable

Les opérateurs d'incrémentation

Ce type d'opérateur permet de facilement augmenter ou diminuer d'une unité une variable. Ces opérateurs sont très utiles pour des structures telles que des boucles, qui ont besoin d'un compteur (variable qui augmente de un en un). Un opérateur de type x++ permet de remplacer des notations lourdes telles que x=x+1 ou bien x+=1

Opérateur Dénomination Effet Syntaxe Résultat (avec x valant 7)
++ Incrémentation Augmente d'une unité la variable x++ 8
-- Décrémentation Diminue d'une unité la variable x-- 6

Les opérateurs de comparaison

Opérateur Dénomination Effet Exemple Résultat
==
opérateur d'égalité Compare deux valeurs et vérifie leur égalité x==3 Retourne True si X est égal à 3, sinon False
< opérateur d'infériorité stricte Vérifie qu'une variable est strictement inférieure à une valeur x<3 Retourne True si X est inférieur à 3, sinon False
<= opérateur d'infériorité Vérifie qu'une variable est inférieure ou égale à une valeur x<=3 Retourne True si X est inférieur ou égal à 3, sinon False
> opérateur de supériorité stricte Vérifie qu'une variable est strictement supérieure à une valeur x>3 Retourne True si X est supérieur à 3, sinon False
>= opérateur de supériorité Vérifie qu'une variable est supérieure ou égale à une valeur x>=3 Retourne True si X est supérieur ou égal à 3, sinon False
!= opérateur de différence Vérifie qu'une variable est différente d'une valeur x!=3 Retourne True si X est différent de 3, sinon False

Les opérateurs logiques

Ce type d'opérateur permet de vérifier si plusieurs conditions sont vraies :

Opérateur Dénomination Effet Syntaxe
|| OU logique Vérifie qu'une des conditions est réalisée ((condition1)||(condition2))
&& ET logique Vérifie que toutes les conditions sont réalisées ((condition1)&&(condition2))
! NON logique Inverse l'état d'une variable booléenne (retourne la valeur True si la variable vaut False, False si elle vaut True) (!condition)