1. Introduction.

2. Les éléments de base du JAVA.

   • Structure du programme en java.

   • Les types primitifs.

   • Les opérateurs.

   • Instructions, portée d'une variable.

3. Structures de contrôle.

   • Structure conditionnelle : if....else.

   • Condition multiple : switch.

   • Les boucles : for, while, do.

4. Fonctions, Procedure, Méthodes.

5. Tableaux.

   • Tableau à une dimension.

   • Tableau à plusieurs dimension.

6. Introduction à la Programmation orienté objet.

7. Les concepts Orienté Objet.

Introduction

Java est un langage nouveau de programmation, basé sur le langage C++, langage connu du plus grand nombre. le langage Java se veut un langage portable et simple dans sa mise au point.

Java permet au programmeur d’écrire une application pour n’importe quelle plate forme (gain de temps de développement) et en même temps de créer des applets qui pourront être intégrées dans des pages web.

Les éléments de base du JAVA

Structure du programme en Java.

Exemple : mon premier programme :

Cette classe permet d'afficher Bonjour dans la Console

class Hello {

// en Java, une application peut être représentée par une seule classe

public static void main(String args[]) {

/*zone de commentaire multilignes

La classe elementaire génère un exécutable grace à la méthode main*/

System.out.println("Bonjour");//affichage de la chaine de caractère Bonjour

} // fin de main, commentaire sur une ligne

} // fin de la définition de la Classe

L’unité de code est la classe : tout le code est encapsulé dans une ou plusieurs classe

La première lettre du nom d'une classe est une majuscule :

Une classe ccc se définit par : class Ccc{ ... /* variables et méthodes */ }

Une classe Ccc se trouve dans un fichier texte dont le nom est Ccc.java.

Une classe peut contenir du code directement exécutable (dans ce cas cette classe possède la fonction main) ou du code qui ne pourra être exécuté que dans une autre classe.

Les types primitifs.

Un programme comporte du code et des données. Les données doivent être définies avant d'être utilisées. Pour cela il existe différents types :

Entiers avec signe :

byte (8 bits), short (16 bits), int (32 bits), long (64 bits).

Réels (représentation en virgule flottante):

float (32 bits), double (64 bits)

Caractères :

char (16 bits, Unicode)

Valeurs logiques true et false

boolean

Domaine de valeurs

Exemple

La déclaration d'une variable peut être faite au début de la méthode ou au moment de l'utilisation de la variable . Au moment de la déclaration de la variable , il est possible d'initialiser cette variable.

Le type caractère

Un caractère est codé sur 16 bits (UNICODE).UNICODE permet d'accéder à n'importe quel caractère, chose impossible avec le code ASCII (codage sur 7 bits) ou bien avec le codage ANSI (fenêtre Windows)ou OEM (fenêtre DOS ). UNICODE pour les 8 bits de poids faible correspond à la norme ANSI. L'initialisation d'un caractère ne peut se faire qu'avec la lettre entre 2 simples cotes ou bien avec la valeur hexadécimale de l'UNICODE.

Le type booléen

Le type booléen (true ou false) ne doit et ne peut être confondu avec un entier (int).

En C le type boolean n'existe pas et est confondu avec un entier (si valeur ==0 alors valeur est FAUX sinon valeur est VRAI).

Exemple de déclaration de booléens :

Définir une variable

Une définition de variable précise le type, l'identificateur et éventuellement une ou plusieurs valeurs d'initialisation :

type identificateur [ = valeur(s)D'initialisation ] ;

Un identificateur est une suite de caractères formée avec des lettres, des chiffres ainsi que les caractères _ (souligné) et $.

Le premier caractère ne peut être un chiffre.

Les minuscules sont distinguées des majuscules.

Les opérateurs.

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 bit-à-bit)

• (les opérateurs de rotation de bit)

L'opérateur d'affectation

L'affectation renvoie la valeur de la variable affectée. On peut ainsi écrire des affectations en cascade :

a = b = c = d = expression;

Opérateurs d'affectation combinés

L'affectation peut être combinée avec un opérateur arithmétique pour for­mer un opérateur combiné. Les affectations suivantes sont équivalentes :

e1 = e1 + 2; // e1 est une variable entière

e1 += 2;

De façon générale, si op est un opérateur arithmétique et expG une expression admise à gauche de l'opérateur d'affection, les deux écritures :

expG = expG op expression

expG op= expression

sont en général équivalentes.

Opérations arithmétiques

Autres opérateurs

Incrémentation et décrémentation

Les opérateurs ++ et – – peuvent être postfixés ou préfixés :

int e1 = 3;

int e2 = e1++; // e1 vaut 4 et e2 vaut 3

int e3 = ++e1; // e1 vaut 5 et e3 vaut 5

Comparaisons

Les opérateurs relationnels dont le résultat est de type boolean sont les opérateurs classiques : < <= == >= > !=

Exemples :

boolean x=(5==7);

boolean x=(5!=3);

L'opérateur ternaire

Symbole

? :

L'opérateur ternaire ?: a le comportement suivant:

si condition alors instruction1 sinon instruction2

Exemple

condition ? instruction1 : instruction2

Opérations sur des booléens

&& et conditionnel : l'évaluation de la condition est finie dès qu'elle devient fausse.

|| ou conditionnel : l'évaluation de la condition est finie dès qu'elle devient vraie.

Exemples :

if( (n != 0) && ( n/3 > 3) ) fonction();

if ((n==3)||(n==5)) fonction();

while ((n<6)&&(n>2)) fonction1();

while((n<6)||(n>2)) fonction2();

Opérations bit à bit

Les opérateurs suivants s'appliquent à des valeurs entières. Ils réalisent des opérations bit à bit et produisent des résultats entiers.

Conversions de types

Promotion entière et conversion implicite

short x = 5, y = 15;

x = x + y; // erreur de compilation

Les deux opérandes x et y sont de type short : pour l’addition, leurs valeurs seront converties au type int (promotion entière) et le résultat sera du même type int. Ce résultat devra alors être affecté à la variable x, de type short : il y a rétrécissement du domaine et donc refus du compilateur.

Dans une opération arithmétique avec des types entiers, Java convertit, pour le calcul, toutes les valeurs au type int.

Le langage définit des conversions de types implicites qui sont automatiquement mises en oeuvre par le compilateur, à condition qu’il n’y ait pas rétrécissement du domaine.

byte b; short s; int i; long l; float f; double d;

d = f = l = i = s = b = 5;

// ok pour toutes les conversions implicites, car il n’y a jamais rétrécissement du domaine

Conversion explicite : le cast

short x = 5, y = 15;

x = (short) (x + y); // OK, grâce au cast

char car = ‘1’; // valeur entière 49 (ascii / unicode)

short z = (short) car; // cast obligatoire

byte x = (byte) car ; // cast obligatoire

cast obligatoire car le type char va de 0 à 65535, alors que short ne va que jusqu’à 32737.

Le transtypage impose la conversion : le programmeur assume le risque de perte d’information :

Attention : le cast explicite est dangereux car il correspond, pour les valeurs entières, à une troncature des octets de poids forts. Si ceux-ci contiennent des chiffres significatifs, le résultat est aberrant,

byte a = (byte) 10, b = (byte) 120; // OK pour 10 et 120 car valeurs comprises entre -128 et +127

a = (byte) (a + b); // le cast supprime l’erreur de compilation mais il est dangereux car (10+120)>127

System.out.println("a=" + a); // affiche a = -126 !

Le transtypage (ou cast) impose la conversion : c’est le programmeur qui assume alors le risque de perte d’information.

Tous les transtypages ne sont pas licites :

boolean trouve = true;

int entier = (int) trouve;// erreur de compilation : aucune conversion admise de boolean vers int

L'opérateur cast a une grande priorité :

short i = 10;

short val = (short) i * 2; // erreur de compilation à remplacer par (short)(i*2) ;

Exemples :

short x=3,y=12;

int z=67000; float a;

a=z+x; // a=67003

x=a; // Erreur de compilation

y=(short)z; // y=1464

x=(short)a; // x=1467

Ecriture de constantes

Par défaut, les constantes entières sont int, les constantes réelles sont double.

Entières

décimale 125

octale 011

hexadécimale 0x15

type long 30l (ou 30L)

Réelles

type float 1.0f 1.e-5f .5f

type double -3.2e21 1.35

Caractères

'a' '\n' '\u0031' '\u06f1'

// 06f1, en base 16, est le code du chiffre 1 arabe oriental

Unicode :

une valeur se code sur quatre chiffres hexadécimaux \uxxxx Unicode, contient ISO-Latin1 qui est l’extension à 8 bits du code ascii (standardisé, lui sur 7 bits). Ainsi les 256 premières valeurs d’Unicode sont l’ISO Latin 1 et les valeurs de 0 à 127 sont l’ascii

Constantes chaînes de caractères

"texte : \"Java\""

"liste des chiffres : 012345\u0036789"

Exemples

long b;

char c='a';

int x=1467;

b=x+40000000000L; // résultat ok : b=4000001467

b=x+40000000000; // dépassement b=1345295803

x+=c; // x=1564

Priorité des opérateurs

Instructions, portée d’une variable

Instructions

Une instruction Java est :

une instruction simple toujours terminée par un point-virgule et pouvant être librement écrite sur plusieurs lignes :

instruction simple;

une instruction composée, encore appelée bloc, qui rassemble des instructions encadrées par des accolades :

{

instruction

...

instruction

}

Portée d’une variable

La portée d'une variable va de la ligne de sa définition jusqu'à la fin du bloc dans lequel elle est définie.

Une variable ne peut pas cacher une autre variable, de même identificateur, définie dans une instruction composée englobante :

{ ... // bloc englobant

short k = -7;

{ // bloc B

int k = 10; // erreur de compilation : définition de k invalide !

... // etc.

} // fin du bloc B

... // etc.

} ... // fin du bloc englobant

Structures de contrôle

Struture conditionnelle : if … else

L'instruction if est la structure de test la plus basique, on la retrouve dans tous les langages . Elle permet d'exécuter une série d'instructions si une condition est réalisée selon l'algoritthme ci-dessous.

if (condition réalisée) { liste d'instructions } else { liste d'instructions }

La condition doit être entre des parenthèses

Il est possible de définir plusieurs conditions à remplir avec les opérateurs ET et OU (&& et ||)

if (condition réalisée) { liste d'instructions } else { autre série d'instructions }

la plupart du temps on aimerait pouvoir choisir les instructions à exécuter en cas de non réalisation de la condition...

L'expression if ... else permet d'exécuter une autre série d'instruction en cas de non-réalisation de la condition.

(condition) ? instruction si vrai : instruction si faux

L'opérateur ternaire permet de faire un test avec une structure beaucoup moins lourde grâce à la structure ci-dessus.

Conditions multiples : switch()

L'instruction switch permet de faire plusieurs tests de valeurs sur le contenu d'une même variable. Ce branchement conditionnel simplifie beaucoup le test de plusieurs valeurs d'une variable, car cette opération aurait été compliquée (mais possible) avec des if imbriqués. Sa syntaxe est la suivante :

Les parenthèses qui suivent le mot clé switch indiquent une expression dont la valeur est testée successivement par chacun des case. Lorsque l'expression testée est égale à une des valeurs suivant un case, la liste d'instruction qui suit celui-ci est exécuté. Le mot clé break indique la sortie de la structure conditionnelle. Le mot clé default précède la liste d'instructions qui sera exécutée si l'expression n'est jamais égale à une des valeurs.

Les Boucles

Les boucles sont des structures qui permettent d'exécuter plusieurs fois la même série d'instructions jusqu'à ce qu'une condition ne soit plus réalisée...

On appelle parfois ces structures instructions répétitives ou bien itérations.

La façon la plus commune de faire une boucle, est de créer un compteur (une variable qui s'incrémente, c'est-à-dire qui augmente de 1 à chaque tour de boucle) et de faire arrêter la boucle lorsque le compteur dépasse une certaine valeur.

Enoncés Itératifs : While() et do While().

L'instruction while représente un autre moyen d'exécuter plusieurs fois la même série d'instructions. Cette instruction exécute la liste d'instructions tant que (while est un mot anglais qui signifie tant que) la condition est réalisée.

L'instruction do while faitt la même chose sauf que la verificattion de la condition se fait après l'execution du lock d'insttructions

Bocle de comptage : for

L'instruction for permet d'exécuter plusieurs fois la même série d'instructions: c'est une boucle!

Dans sa syntaxe, il suffit de préciser le nom de la variable qui sert de compteur (et éventuellement sa valeur de départ, la condition sur la variable pour laquelle la boucle s'arrête (basiquement une condition qui teste si la valeur du compteur dépasse une limite) et enfin une instruction qui incrémente (ou décrémente) le compteur.

Exemple:

Dans cett exemple il est évident que pour x=7 il y aura une erreur. Heureusement, grâce à l'instruction continue il est possible de traiter cette valeur à part puis de continuer la boucle!

x=1;

while (x<=10)

{ if (x == 7)

{ System.out.println("Division par zéro!");

continue;

}

a = 1/(x-7);

System.out.println((char)a);

x++;

}

Fonctions, Procedures, Méthodes.

En informatique Les fonctions correspondent à des morceaux de programmes paramétrés par des valeurs. La procédure est une « fonction » qui ne renvoie aucune valeur, Java ne fait pas vraiment de distinction entre les fonctions et les procédures ; une procédure est tout simplement une méthode qui ne renvoie aucune valeur et qui déclare le type void comme type retour.

Comme Java est un langage objet à classes, il faut envoyer un message à un objet ou à une classe pour lui demander de calculer la valeur d’une fonction, dans ce cas en parle d’une méthode.

Définition d'une fonction

Pour définir une fonction (Méthode) en java Il faut choisir la classe où on va mettre la méthode, pour notre exemple la méthode est déclarée dans la classe principale.

Signature et passage des paramétres.

Chaque fonction a son propre espace mémoire qu’elle utilise pendant son exécution.

Cet espace mémoire peut servir :

• pour les variables locales à la fonction (celles qui sont déclarées dans la fonction).

• pour conserver les valeurs des paramètres passés à la fonction.

Deux possibilités pour passer la valeur d’un paramètre à une fonction :

• passage par valeur

  • Au début de l’exécution de la fonction, les valeurs des paramètres sont recopiées dans l’espace mémoire de la fonction

  • Java n’utilise que le passage par valeur

• passage par adresse

  • Au début de l’exécution de la fonction, l’adresse (en mémoire) du paramètre est passée à la fonction.

  • En ce cas, la fonction peut modifier la valeur qui est enregistrée à cet endroit, qui est utilisée par le code appelant.

Tableaux

Les tableaux sont des structures de données contenant un groupe d'éléments du même type. Le type des éléments peut être un type primitif ou une classe.

Tableau à une dimension

Définition d'un tableau :

Lors de la définition d’un tableau les [] spécifiant qu’il s’agit d’un tableau peuvent être placés avant ou après le nom du tableau :

int tab_i []; char[] tab_c;

Un tableau initialisé :

int tab_i [] = { 1, 2, 3 , 4}; char[] tab_c = {’a’, ’b’, ’c’};

Allocattion de l’espace nécessaire au tableau avec l'insttructtion new :

// tab_i est un tableau à une dimension de 10 int tab_i = new int [10]; // tab_c est un tableau à une dimension de 15 char tab_c = new char [15];

Les éléments d’un tableau sont indicés à partir de 0. Chaque élément peut être accédé individuellement en donnant le nom du tableau

suivi de l’indice entre [ ]

tab_i [0] ;// premier élément du tableau tab_i tab_i [9] ;// dernier élément du tableau tab_i

Un tableau possède un attribut length qui permet de connaître le nombre d’éléments d’un tableau.

tab_i.length vaut 10.

tab_c.length vaut 15.

L'utilisation d'un tableau pour lequel l'espace n'a pas été alloué provoque la levée d'une exception NullPointerException

L’accès à un élément du tableau en dehors des bornes provoque la levée d’une exception ArrayIndexOutOfBoundsException

Tableau à plusieurs dimensions

Lors d’une définition de tableau le nombre de crochets indique le nombre de dimensions du tableau.

Exemple : Définition d'un tableau à deux dimensions

int tab_i[][] = new int[4][4] ;

Exemple : Définition d'un tableau à deux dimensions initialisé

int tab_i[][] = {{1, 2, 3}, {4, 5, 6}};

les lignes d’un tableau à 2 dimensions peuvent avoir un nombre varié d’éléments :

Exemple:

Tableaux en paramètre :

La spécification d’un paramètre tableau se fait en écrivant autant de couples de [] que de dimensions du tableau, mais sans donner la taille de chaque dimension.

Cette taille peut être obtenue dans la méthode à l’aide de l’attribut length. Le contenu des éléments peut être modifié, mais pas le tableau lui-même.

Utilitaires pour les tableaux :

La classe System a une méthode de copie rapide de tableaux : System.arraycopy

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int l)

Copie un tableau depuis src, et partir de la position srcPos, dans la destination dest à partir de destPos et sur une longueur l. La copie n’est pas une copie profonde : seules les références sont copiées.

La classe java.lang.reflect.Array contient des méthodes statiques permettant :

• de récupérer un élément d’un tableau, en le convertissant dans un autre type

• d’affecter un tableau avec un élément

• de créer, à l’exécution, un tableau

Introduction à la programmation orienté objet

Définition.

La Programmation Orienté Objet (POO), c'est tout simplement faire de son programme un ensemble d'objets qui interagissent entre eux. En d'autres termes :

tout est objet. La programmation orientée objet est l'un des outils les plus importants dans le développement logiciel.

C'est une façon de programmer qui permet une meilleure organisation de son code.

Définition d'objet et de classe.

• Un objet en POO reste comme un objet du quotidien. Les objets ont des fonctionnalités et des caractéristiques.

• Une classe est une description abstraite d'un objet. Les fonctions qui opèrent sur les données sont appelées des méthodes. Instancier une classe

consiste à créer un objet sur son modèle. Entre classe et objet il y a, en quelque sorte, le même rapport qu'entre type et variable.

Si vous prenez une voiture, par exemple, il possède avant tout une fonctionnalité : démarrer.

Pour mener à bien cette fonctionnalité, il possède des caractéristiques : Puissance : quantité en nombre des chevaux, Capacité carburant : quantité en litres.

La représentation Graphique est la suivante :

Voiture : le nom du type de l'objet (La classe).

puissance, carburant : les caractéristiques de l'objet (les attributs).

Démarrer : les fonctionnalités de l'objet (les méthodes).

En Java, cela correspondrait à un fichier nommé voiture contenant une classe nommée elle aussi Voiture :

Classe

package pkggv;

public class Voiture {

int puissance;

int capacite_Carburant;

public void demarrer() {

System.out.println("Je cuis démarre");

System.out.println("avec ma capacité de " + capacite_carburant + " litres");

System.out.println("et ma puissance de " + puissance );

}

}

Cette classe n'est pas une voiture, mais la description d'une Voiture. C'est lorsque l'on va créer une variable de type Voiture

que l'on va réellement créer une voiture.

test_voiture

package pkggv;

public class Main {

public static void main(String[] args) {

Voiturer mavoiture = new Voiture();

mavoiture.capacite_carburant = 30;

mavoiture.puissance = 180;

mavoiture.cuire();

System.out.println("");

}

}

Il ne faut surtout pas confondre classe et objet :

• La classe est la description d'un type : de quels éléments ce type est composé.

La durée de vie d'un objet.

Les objets ne sont pas des éléments statiques et leur durée de vie ne correspond pas forcément à la durée d'exécution du programme. La durée de vie d'un objet passe par trois étapes :

• la déclaration de l'objet et l'instanciation grâce à l'opérateur new (Class mon_objet = new Class()).

• l'utilisation de l'objet en appelant ses méthodes

• la suppression de l'objet : elle est automatique en Java grâce à la machine virtuelle.

La restitution de la mémoire inutilisée est prise en charge par le récupérateur de mémoire (garbage collector).

Il n'existe pas d'instruction delete comme en C++.

Les références et la comparaison d'objets

Les variables de type objet que l'on déclare ne contiennent pas un objet mais une référence vers cet objet.

Lorsque l'on écrit obj1 = obj2 (obj1 et obj2 sont des objets), on copie la référence de l'objet obj2 dans obj1.

c1 et c2 font référence au même objet : ils pointent sur le même objet. L'opérateur == compare ces références.

Deux objets avec des propriétés identiques sont deux objets distincts.

Pour comparer l'égalité des variables de deux instances, il faut munir la classe d'une méthode à cet effet : la méthode equals() héritée de Object. Pour s'assurer que deux objets sont de la même classe, il faut utiliser la méthode getClass() de la classe Object dont toutes les classes héritent.

Le littéral null :

Le littéral null est utilisable partout où il est possible d'utiliser une référenc à un objet.

Il n'appartient pas à une classe mais il peut être utilisé à la place d'un objet de n'importe quelle type ou comme paramètre.

null ne peut pas être utilisé comme un objet normal : il n'y a pas d'appel de méthodes et aucune classe ne peut en hériter. Le fait d'affecter null une variable référençant un objet pourra permettre au ramasse-miettes de libérer la mémoire allouée

à l'objet si aucune autre référence n'existe encore sur lui.

Les variables de classes

Elles ne sont définies qu'une seule fois quel que soit le nombre d'objets instanciés de la classe. Leur déclaration est accompagnée

du mot clé static : static int compteur = 0;

La variable this

Cette variable sert à référencer dans une méthode l'instance de l'objet en cours d'utilisation.

this est un objet qui est égal à l'instance de l'objet dans lequel il est utilisé.

private int nombre; public maclasse(int nombre) { this.nombre = nombre; // variable de classe = variable en paramètre du constructeur }

L'opérateur instanceof

L'opérateur instanceof permet de déterminer la classe de l'objet qui lui est passé en paramètre. La syntaxe est objet instanceof classe

if (o instanceof MaClasse ) System.out.println(" o est une instance de la classe MaClasse "); else System.out.println(" o n'est pas un objet de la classe MaClasse ");