Cours caractéristiques générales du langage Java tutoriel & guide de travaux pratiques langage Java en pdf.

Caractéristiques générales du langage Java

Syntaxe
Syntaxe semblable à celle du C. Attention, comme dans C, les ‘ ;’ sont des terminateurs d’instructions et non des séparateurs d’instructions comme en Pascal (en particulier il y a toujours un ‘ ;’ à la fin d’une affectation qu’il y ait un else ou non derrière).
Expressions
La syntaxe d’une expression est la suivante :
<expr> ::= (<expr>) |
<expr> <op-bin> <expr> |
<op-unaire> <expr> |
<ident> |
<litteral> |
<envoi de message avec retour> // voir plus loin dans le cours
Opérateurs
Les mêmes qu’en C :
Relationnel
==, !=, >, <, >=, <=,
Arithmétique
+, *, -, /, % (reste d’une division entière, modulo)
++, — (même règles qu’en C)
 Logique
&&, ||, !
Opérateurs de manipulation de bits
op1 >> op2 shift bits of op1 right by distance op2
op1 << op2 shift bits of op1 left by distance op2
op1 >>> op2 shift bits of op1 right by distance op2 (unsigned)
& op1 & op2 bitwise and
| op1 | op2 bitwise or
^ op1 ^ op2 bitwise xor
~ ~ op bitwise complement
 Instructions
 affectation
Comme dans C :
<var> = <expr>;
il existe aussi la possibilité d’associer un opérateur binaire à une affectation :
<var> += <expr>;
est équivalent à
<var1> = <var1> + <expr>;
Note : Il est généralement préférable d’éviter ce raccourci de notation, car il nuit généralement à la compréhension des programmes sans véritablement leur apporter d’avantages concluants.
 Structures de contrôle
if <expr> <instr1> else <instr2>
if <expr> <instr>
Switch <expr> {
case <cste1> : <instr1> //penser au Break ! ! …
case <csten> : <instrn>
default : <instr par defaut>
}
while <expr> <instr>
do <instr> while <expr>
for(<init> ; <expr tant que> ; <increment>) <instr>
Différences avec C++
• Pas de Goto ! !
• Pas de Macros…
• Pas de struct et d’unions
• Pas de pointeurs
Types de données
Deux types de données : les types primitifs (qui ne sont pas de véritables objets), et les types par référence.
Les types primitifs (commencent par une minuscule)
<type> <variable> = <expression>
Les types « par référence » qui portent sur des classes d’objets.
Variables
Types de variables :
• variable locale
• paramètre de méthodes
• attribut d’objet
• (+ paramètres d’exception, voir plus loin)
Il n’y a plus de variable globale ! ! On les remplace avantageusement par des attributs statiques de classes (voir plus loin).
Les variables peuvent être initialisées au moment de leur déclaration.
Ex :
int age = 1 ;
Portée lexicale des variables : chaque bloc ( {… } ) peut avoir ses propres variables locales.

L’aspect objet du langage Java

Concepts de base des langages objets
Ils sont au nombre de trois:
1. le concept de structuration qui lie entre eux les notions d’objet, de classe et d’instance
2. le concept de communication au travers de l’envoi de message et des méthodes
3. le concept d’héritage.
Objet, classes et instance
Définitions
Objet: un objet ets une structure informatique caractérisée par un état et un ensemble d’opérations exécutables par cet objet qui caractérise son comportement.
Objet = état + opérations applicables.
Exemple:
une Fenêtre
etat: position, taille, bordure, titre, couleur,…
opérations: dessiner, déplacer, agrandir…
un Icône
etat: position, taille, pixels,…
opérations: dessiner, déplacer, agrandir …
un PersonnageDeJeuDeRôle
etat: pièce, force, ptsDeVie, habileté, armes, pouvoirs,…
opérations: allerNord, allerSud, ouvrirPorte, prendre, …
un Fichier
état: nom, directory, id, protections, propriétaire, contenu,.
opérations: ouvrir, fermer, détruire, lireCar, écrireCar,…
On regroupe un ensemble de caractéristiques communes aux objets sous la forme de structures formelles, appelées classes:
Définition: une classe est un modèle de la structure statique (les champs ou attributs) et du comportement dynamique (les opérations ou méthodes) des objets associés à cette classe, que l’on appelle ses instances.
Remarque: les classes n’ont pas nécessairement d’existence physique dans la machine.
Définition: une instance est un objet, occurrence de la classe qui possède la structure définie par la classe et sur lequel les opérations définies dans la classe peuvent être appliquées.
Notation graphique d’une classe
Remarque : La notation utilisée est UML avec de légères variantes : les variantes portent essentiellement sur la définition des instances qui sont représentées ici par un ovale (alors qu’elle sont représentées sous la forme d’un rectangle en UML pratiquement comme les classes ce qui conduit à une certaine confusion) et surtout qui peuvent être placées dans le même diagramme qu’en UML (ce qui est impossible en UML).
Création d’une classe
Syntaxe :
<déclaration> { <corps> }
La partie déclaration :
<modifier> class <nom> extends <nom de superclasse> <modifier> ::= public | final | abstract
• public indique que la classe est acessible en dehors du package (voir plus loin)
• final indique que la classe ne peut plus avoir de sous-classes (classe hyper-concrète)
• abstract indique que la classe ne peut pas être instanciée.
Le corps d’une classe
<corps> ::= [ <variable> | <methode> | <constructeur> ]*
Le corps d’une classe est composé d’une suite de définition de champs et de méthodes.
Déclaration d’un champs
<modifier>* <type> <nom> = <expr>
Déclaration d’une méthode :
<modifier>* <type résultat> <nom>(<type1> <param1>,…,<typen> <paramn>)
Les modifieurs :
<modifier> : := < portée> | <allocation> | <modifiabilité>
<portée> : := public | protected | private protected | private
<allocation> : := static
<modifiabilité> : := final
• public : accessible de partout
• protected : accessible de partout à l’intérieur d’un package
• private : accessible uniquement de la classe où la variable a été définie.
static : indique que la variable est en fait globale à toutes les instances de la classe (ou de ses sous-classes). Elle est directement accessible par la classe. Ex :
CompteCrédit.taux
• final : indique que la valeur de la variable ne peut pas être changée (représente en fait une constante).
Les constantes sont généralement déclarées comme public static final.
Pour les méthodes, on a aussi les modifiers :
• abstract : ne contient aucun code, et implique que la méthode sera définie
dans les sous-classes. La classe ne peut plus être instanciée. (Si toutes les méthodes sont abstract, on pourra considérer la classe comme une
« interface »).
• synchronized (pour l’utilisation avec des threads)
Un exemple de description de classe :
class Compte {
int numero ;
int solde=0 ;
// constructeur Compte(String s, int c) {
client = s; solde = c;
}
}
Création d’objet
Constructeurs
Comme en C++ grosso modo. La différence essentielle vient de ce que toutes les instanciations se font à l’aide de la commande new. Attention, pour les programmeurs C..
Ex :
Compte c1 = new Compte(101,2000);
Envoi de message et méthodes
Envoi de message en Java
En java, l’envoi de message s’exprime sous la forme d’une notation ‘.’ comme dans Eiffel et les Pascal Objet (et d’une certaine manière en C++ si l’allocation n’est pas faite dans le tas).
Syntaxe :
<envoi-message> ::= <obj>.<sel>(<arg1>,..,<argk>)
où <obj> est un objet receveur du message et <sel> est un identificateur qui correspond au nom d’une méthode définie dans la classe de <obj> (ou dans l’une de ses sur-classes, voir la section suivante sur l’héritage).
Attention : l’envoi de message peut prendre la forme d’une expression ou d’une instruction. Dans le premier cas, l’envoi de message retourne une valeur, dans le second, la méthode ne retourne aucun résultat.
Exemple :
c1.deposer(100);
int a = c1.avoirSolde();
 Représentation graphique d’un envoi de message à une instance
<sel>(<arg1>,..,<argn>)
 Définition de méthodes
Exemple:
class Compte {
int numero;
int solde=0;
// constructeur Compte(int n, int c) {
numero = s; solde = c;
}
// définition des méthodes void deposer(int v) {
solde = solde + v;
O
}
void retirer(int v) {
solde = solde + v;
}
int avoirSolde() {
return(solde);
}
// note on verra par la suite une meilleure technique d’affichage void afficher() {
System.out.println(« Compte:  » + numero +
« , solde :  » + avoirSolde())
}
… // autres méthodes …
}
Utilisation des méthodes :
Compte co1 = new Compte(101,2000);
Compte co2 = new Compte(102,1000);
co1.deposer(1000);
co2.deposer(500);
co1.afficher();
co2.afficher();
Le fonctionnement du programme donnera:
Compte: 101, solde : 3000
Compte: 102, solde : 1500
 Héritage
Définition: mécanisme de recopie virtuelle par défaut des caractéristiques de la classe.
Les champs sont recopiés vers la sous-classe, mais pour les méthodes, tout se passe comme si on les recopiait d’une classe vers sa sous-classes. Mais si une sous-classe redéfinit ses méthodes, celles-ci ne sont pas recopiées.

1. 1. Introduction
1.1 Historique
1.2 Informations sur Java
1.3 Aspects généraux
1.4 Son mode de fonctionnement
1.5 Notion de machine virtuelle
2. Caractéristiques générales du langage Java
2.1 Syntaxe
2.2 Types de données
2.3 Variables
3. L’aspect objet du langage Java
3.1 Concepts de base des langages objets
3.2 Objet, classes et instance
3.3 Création d’une classe
3.4 Création d’objet
3.5 Envoi de message et méthodes
3.6 Héritage
3.7 Interfaces et implémentation
3.8 Relations et liens
3.9 Graphe de collaboration
4. Autres aspects du langage Java
4.1 Packages
4.2 Applications et applets
5. Les tableaux
6. Quelques particularités
7. Les packages et classes principales
7.1 Package Java.lang

……….