UV LO43 - Bases fondamentales de la Programmation

UV LO43 - Bases fondamentales de la
Programmation Orientée Objet
Introduction au langage Java
Un exemple simple..............................................................................................................................................................2
La grammaire......................................................................................................................................................................3
Types...................................................................................................................................................................................3
Variables.............................................................................................................................................................................3
Tableaux.............................................................................................................................................................................4
Les chaînes de caractères.................................................................................................................................................4
Les structures de contrôle................................................................................................................................................4
Différences entre Java et C++.........................................................................................................................................4
Les objets en Java...............................................................................................................................................................5
Classes, constructeurs, attributs, méthodes..................................................................................................................5
L’encapsulation.................................................................................................................................................................6
L’héritage...........................................................................................................................................................................8
Redéfinition des méthodes, surcharge.........................................................................................................................10
Polymorphisme................................................................................................................................................................10
Méthodes abstraites........................................................................................................................................................10
Interface............................................................................................................................................................................10
Héritage multiple ............................................................................................................................................................10
Paquetages et classes publiques...................................................................................................................................11
Les librairies standard....................................................................................................................................................11
Les threads .........................................................................................................................................................................11
Les exceptions....................................................................................................................................................................11
Définir et lever une exception.......................................................................................................................................11
Attraper une exception...................................................................................................................................................12
Déclarer une exception ..................................................................................................................................................12
Les applets..........................................................................................................................................................................13
Travail Dirigé....................................................................................................................................................................14
Travail Dirigé....................................................................................................................................................................15
TP Java sur les mécanismes d’exception...................................................................................................................16

Le langage Java
2
Un exemple simple
Considérons ce premier programme Java :
// Exemple simple de programme Java
import java.io.* ;
public class ExempleSimple {
public static void main(String args[]) {
System.out.println(« BONJOUR ! ») ;
}
}
On l’enregistre sous le nom ExempleSimple.java.
Comment le compiler :
>javac ExempleSimple.java
produit un fichier précompilé ExempleSimple.class
>java ExempleSimple
execute le programme.
Le noms de fichiers correspondent au nom de la classe publique principale dans le fichier. L’exécution
consiste à demander au noyau Java d’interpréter le programme, ce qui consiste au chargement de la
classe ExempleSimple et à l’exécution de la méthode main de cette classe.
Cette méthode doit être déclarée Public statique pour pouvoir être exécutée.
ExempleSimple.class est une librairie dynamique.
Quelques commentaires :
// je suis une ligne de commentaire
import java.io.* ;
indique au compilateur que l’on veut importer et utiliser tout (.*) le paquetage de la librairie standard
d’entrée/sortie de Java.
CLASSPATH précise ou aller chercher les classes java , ainsi avec
CLASSPATH = C:\JAVA ; C:\MONPROJET le noyau ira chercher les classes dans
c:\JAVA\JAVA\IO, puis s’il ne les a pas trouvées, dans C:\MONPOJET\JAVA\IO.
La méthode main ne renvoie rien (void).

Le langage Java
3
(Strings args [ ]) est le paramètre obligatoire de la méthode main. C’est un tableau de chaîne de
caractères.
La grammaire
Types
Cela ressemble à C++ sauf que :
- Java utilise le jeu de caractères Unicode codé sur 16 bits et qui permet d’include à peu près tous
les alphabets connus.
- Le type boolean introduit deux valeurs en standard : true et false
Les types élémentaires manipulés sont :
- byte (1 octet)
- boolean (1 bit)
- short (2 octets)
- int (4 octets)
- long (8 octets)
- float (4 octets)
- double (8 octets)
- char (2 octets).
L’implémentation de ces types est indépendante de la machine.
Variables
Il n’y a plus de variable globale,
short VariableGlobale ;
déclarée en dehors d’une classe.
En réduisant les possibilités de la syntaxe, Java facilite la relecture du code :
Void MethodeQuelconque(Objet iciOuLa) {
Objet ceci = new Objet() ;
IciOuLa.Recoit(ceci, cela) ;
}
ici, on peut déduire que la variable cela est nécessairement un attribut de l’objet.
En ce qui concerne le stockage des objets :
- les types élémentaires sont manipulés directement par valeur
- les objets sont manipulés à travers leur adresse par référence.
void Methode () {
int var1 = 2 ;

Le langage Java
4
Objet var2 = new Objet(2) ;
var1 = var1 + 3 ;
var2.ajoute(3) ;
}
Figure 1 : Stockage par valeur et par variable
Tableaux
Quelques exemples :
int [ ] TableauDEntier ;
int TableauDEntier [] ;
int MatriceDEntier [][] ;
int Jours [] = { 28, 29, 30 } ;
String LesNomsDesMois [] = new String[12] ;
LesNomsDesMois[0] = "Janvier" ;
Les chaînes de caractères
Deux classes spécialement prévues à cet effet :
String : chaînes constantes
StringBuffer : chaînes modifiables, il faut gérer leur longueur et représentation mémoire
Opérations sur les chaînes :
- créer la chaîne
- extraire un caractère particulier
- rechercher une sous-chaîne
- remplacer des caractères …
Les structures de contrôle
C’est quasiment la même chose qu’en C++ pour les embranchements, les boucles, les sauts.
Différences entre Java et C++
Voici quelques différences essentielles :
- il n’y a plus de macros
Var1 5
Var1 Objet 5

Le langage Java
5
- il n’y a plus de struct et union
- on ne manipule plus explicitement de pointeur, leur usage est transparent (passage par référence)
- la mémoire est gérée par le ramasse miette, les objets sont détruits automatiquement, il n’y a
jamais à se soucier des désallocations de la mémoire
- tous les objets sont dynamiques
- tous les passages de paramètres se font par variable
- le système détecte les utilisations abusives de pointeurs nuls.
Les objets en Java
Classes, constructeurs, attributs, méthodes
Considérons :
class Fenetre {
// attributs
String titre ;
int X ;
int Y ;
int hauteur ;
int largeur ;
// constructeur
public Fenetre(String le_nom, int x, int y, int h, int l) {
titre = le_nom ;
X = x ;
Y = y ;
Hauteur = h ;
Largeur = l ;
}
// méthodes
void DoublerTaille() {
hauteur = hauteur * 2 ;
largeur = largeur * 2 ;
}
}
Le constructeur est appelé au moment de la création de l’objet à l’aide du mot clé new qui réserve
l’emplacement mémoire pour l’objet :
public class democonstructeur {
public static main(String arg[]) {
Fenetre f ;
f = new Fenetre("Titre", 0, 0, 100, 200) ;
}
}
Variables et méthodes statiques
Ce sont des attributs en commun, ils sont lisibles et modifiables par tous les objets d’une même
classe :
class partage {
...
static int partage = 2 ;