Plan

Introduction à JAVA

Le langage

1.1 Les types de base

1.1.1. Les identificateurs

A chaque objet, variable, programme, on associe un nom.
Sont admis tous les caractères alphanumériques , le signe souligné _ et le caractère $. Le premier caractère d'un identificateur ne peut pas être un chiffre.

JAVA est sensible à la casse des lettres .

Un identificateur ne doit pas appartenir à la liste des mots réservés du langage.

abstract

boolean

break

byte

byvalue

case

catch

char

class

const

continue

default

do

double

else

extends

false

finally

float

for

goto

if

implements

import

instanceof

int

interface

long

native

new

null

package

private

protected

public

return

short

static

super

switch

synchronized

this

threadsafe

throws

transient

true

try

void

while

1.1.2. Commentaires

Trois possibilités de délimiter les commentaires existent :
Le symbole //  : ce qui suit ce symbole dans la ligne est considéré comme commentaire.
Les symboles /* et */  : ce qui est entre les symboles est considéré comme commentaire.
Les symboles /** et */ qui permettent avec un utilitaire de SUN de générer des commentaires au format html.

1.1.3. Variables

En JAVA, il faut déclarer toute les variables en précisant leur type . On peut éventuellement ajouter des modificateurs. Ainsi déclarer une variable « final » revient à créer une constante car le compilateur refusera toutes les instructions modifiant la valeur de cette variable.
On peut effectuer une affectation ou assignation (donner une valeur) en déclarant une variable.
Lors de sa création une variable reçoit toujours une valeur par défaut . (0 pour les entiers, 0.0 pour les flottants, false pour les booléens, null pour les objets).

Le signe égal ( = ) est le symbole d'assignation.

Le point virgule ( ; ) est le terminateur d'instruction.

int i;
double a,b,c;
final float PI = 3.14159f;

1.1.4. Les littéraux

Les littéraux définissent les valeurs qui sont utilisées par les programmes. Il en existe trois catégories les booléens, les nombres et les caractères.

1.1.4.1 Booléens

Deux valeurs possibles true (vrai) et false (faux).

1.1.4.2 Entiers

Il est possible d'exprimer les entiers en décimal, octal et hexadécimal.

int i = 10 ; //format décimal
int i = 010; //format octal : le nombre commence par un zéro.
int i = 0x10; /*format hexadécimal : le nombre commence par un zéro suivi d'un x (majuscule ou minuscule)*/
long k = 123L //forçage au type long par ajout d'un L (ou l) à la fin .

Il en existe 4 types qui différent par la taille : byte (1 octet), short (2 octets), int (4 octets), long (8 octets).

    Attention aux débordements  :
    short i = 20000, j = 20000, k ; //k = i + j vaut -25536 !

    Sur les 16 bits du type short, le bit de poids fort est le bit de signe et les 15 bits restants contiennent la valeur.

1.1.4.3 Flottants

    Deux types de flottants existent : simple précision (float) ou double précision (double).
    Diverses écritures sont possibles :
    float x = 10.0f; // nombre suivi par F ou f (obligatoire)
    double z = 1.0d; / / nombre suivi par D ou d (facultatif)
    double y = -1E-5, t = 8.4E5, h = .25;

1.1.4.4 Caractères

La représentation d'un caractère est un caractère placé entre deux apostrophes ( ' ). Les caractères de JAVA respectent le codage « Unicode » sur 2 octets.

char x = 'x';
char omega = (char)969 ; //affiche le caractère grec ω .

Tableau des types de JAVA

Type

Taille

Genre

Gamme des valeurs possibles

boolean

8 bits

Booléen

true et false

byte

8 bits

Entier

-128 à +127

short

16 bits

Entier

-32768 à +32767

int

32 bits

Entier

-2147483648 à 2147483647

long

64 bits

Entier

-9223372036854775808  à 9223372036854775807

float

32 bits

Flottant

1.401E-45 à 3.4028235E+38

double

64 bits

Flottant

5E-324 à 1.7976931348623157E+308

char

16 bits

caractère

Tout caractère unicode

1.1.4.5 Chaînes de caractères

Les chaînes de caractères sont formées par une succession de caractères entourés par des guillemets ( " ). Elles correspondent au type String qui est une classe à part entière dotée de constructeurs et de méthodes spécifiques.

    String s = "ceci est une chaîne";

1.1.5. Les tableaux

1.1.5.1 Tableaux simples

Les tableaux sont déclarés en post-fixant soit le type des variables du tableau soit le nom de celui-ci avec des crochets.

int i[];
int[] i;

Ce genre de déclarations est insuffisant pour pouvoir utiliser le tableau.

Il est nécessaire de préciser sa dimension (pour que le compilateur réserve la mémoire nécessaire)

Ceci est réalisé au moyen de l'instruction new .

int i[] = new int[10];

Cette instruction crée un tableau de 10 entiers dont les indices vont de 0 à 9.
Il est aussi possible d'initialiser un tableau lors de sa création :

int impairs[] = {1,3,5,7,9,11}; //tableau à 6 éléments .
int x = impairs[2] ; // x = 5

Le séparateur des valeurs est la virgule.

1.1.5.2 Tableaux multidimensionnels

La syntaxe est la même que pour les tableaux à une dimension :

int tab[][] = new int[4][3]; //indices 0, 1, 2, 3 et 0, 1, 2
float mat[][] = new float[3][3];

Comme pour les tableaux à une dimension, Il est possible d'initialiser un tableau lors de sa création :

int carre = {{11,12,13},{21,22,23},{31,32,33}};
int x =carre[1][2] ; //x = 23

Dans un bloc de valeurs, le séparateur est la virgule. Les blocs sont séparés par des virgules

1.1.6. Portée des variables

1.1.6.1 Blocs d'instructions.

Un bloc est un ensemble d'instructions contenues entre deux accolades { }

Il est possible d'imbriquer des blocs.

1.1.6.2 Portée des variables

L'emplacement de la déclaration de la variable définit sa zone de visibilité.
Une variable est visible dans le bloc dans lequel elle est définie.

class test{ //début du bloc test
int k=5;
void methode1()
{ // début de methode1
float x=4;
...
} //fin de methode1 .

void methode2()
{ // début de methode2
double z;
int k=8;
...
} //fin de methode2 .

void methode3()
{ // début de methode3
double y;
...
} //fin de methode3 .
} //fin de test

Dans le programme ci-dessus, la variable x n'est visible que dans methode1 . La variable z n'est visible que dans methode2 .

Par contre k est visible dans methode1 et methode3 avec la valeur 5. Mais dans methode2 l'affectation int k = 8 masque la variable k définie dans test. Dans le bloc methode2 , la valeur initiale de k est 8.

1.1.7 Arguments des méthodes

Quand l'argument est un type primitif on fait un passage par valeur : c'est la valeur de l'argument qui est transmise à la méthode. Si celle-ci modifie cette valeur la modification n'est pas répercutée sur la variable initiale.
Par contre si l'argument est un objet ou un tableau on fait un passage par adresse : c'est l'adresse de l'objet ou du tableau qui est transmise. Toute modification causée par la méthode est répercutée.

1.1.8 Conversions de types

Les conversions de type doivent être faites explicitement en JAVA.

On encadre l'identificateur du type désiré par des parenthèses ( ) .

char c; double d; int i=64;
c = (char)i; //conversion de la valeur de i en caractère
i = (int) d ; //effectue la troncature de d

Les conversions de type peuvent entraîner des pertes de précision.

De vers

byte

short

int

long

float

double

char

byte

*

*

*

*

*

*

*

short

*

*

*

*

*

*

int

*

*

perte

*

*

long

*

perte

perte

*

float

*

*

*

double

*

*

char

*

Par exemple à la suite de l'instruction char c = (char)64.5f; c est égal à @

1.2. Les opérateurs

1.2.1 Opérateurs numériques

Ils sont classés selon le nombre d'arguments nécessaires en opérateurs unaires et binaires.

1.2.1.1 Opérateurs unaires

Opérateur

Action

Exemple

-

Négation

i = -k ;

++

Incrémentation de 1

i++ ; //i = i + 1

--

Décrémentation de 1

i-- ; //i = i - 1

1.2.1.2 Opérateurs binaires

Opérateur

Action

Exemple

+

Addition

c = a + b ;

+=

i+= j ; //i = i + j

-

Soustraction

c = a - b ;

-=

i -= 2 ; //i = i - 2

*

Multiplication

c = a * b ;

*=

c * = a; //c = c * a

/

Division (entière si arguments entiers)

c = a / b ;

/=

c /= a; //c = c/a

%

Modulo

i = j % n;

%=

i %= 4; //i = i % 4

1.2.2 Opérateurs relationnels

Opérateur

Action

Exemple

<

Plus petit que

a < b ;

>

Plus grand que

a > b ;

<=

Plus petit ou égal à

a <= b ;

>=

Plus grand ou égal à

a >= b ;

==

Egal à

a == b ;

!=

Différent de

a != b ;

Noter la différence entre l'assignation ( = ) et l'égalité ( = = ).

1.2.3 Opérateurs logiques

Opérateur

Action

Exemple

!

Négation (Complément)

c = !c ;

&

ET

a & b;

|

OU

a | (b>3) ;

^

OU exclusif

a ^ b;

~

ÑON logique

a = ~b;

&&

ET évalué

a && b && c ;

||

OU évalué

a || b || c ;

!=

Complément assigné

c != c ;

&=

ET assigné

a &= b ; //a = a & b

|=

OU assigné

a |= b ; //a = a | b

Si on utilise les opérateurs évalués && et || , l'évaluation de l'expression cesse dès qu'une certitude est acquise (premier terme false dans un && , ou premier terme true dans un || ).

1.2.4 Opérateurs de manipulation des binaires

Opérateur

Action

Exemple

<<

Décalage à gauche.

i << k ; décaler i vers la gauche de k bits.

>>

Décalage à droite signé.

i >> k ; décaler i vers la droite de k bits avec son signe

>>>

Décalage à droite non signé

i >>> k; décaler i vers la droite de k bits sans son signe

Ces opérations de manipulation sur les binaires correspondent à des opérations arithmétiques sur des entiers.

~i;       => (i - 1) -1
i >> k  => i / (2 k ) si i>0
i << k    => i * (2 k )

1.2.5 Précédence des opérateurs

Dans le tableau les opérations sont classées par ordre de priorité.

++

--

!

~

*

/

%

+

-

<<

>>

>>>

<

>

<=

>=

==

!=

&

|

^

&&

||

Il est toujours possible de modifier cet ordre en utilisant des parenthèses.