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
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).
2
Le langage Java
(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 ;
3
Le langage Java
Objet var2 = new Objet(2) ;
var1 = var1 + 3 ;
var2.ajoute(3) ;
}
Var1
5
Objet
Var1
5
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
4
Le langage Java
-
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 ;
5
Le langage Java
static void methode() ;
...
}
Ils sont appelés simplement en donnant le nom de la classe, sans préciser d’objet :
partage.methode() ;
L’encapsulation
Elle est assurée par cinq types de protections à l’aide des mots clés public, private, protected. Ces
protections sont : private, private protected, protected, friendly, public, elles sont résumées dans
l’exemple et le tableau suivants. La notion de paquetage (ensemble de classes) intervient ici dans la
définition des droits.
Exemple
package PaquetageA ;
// signifie que les classes appartiennent au PaquetageA
class Mere {
private int attPrivate = 0 ;
private protected int attPrivateProtected = 0 ;
protected int attProtected = 0 ;
int attFriendly = 0 ;
private void metPrivate() { ;} ;
private protected metPrivateProtected() { ;} ;
protected metProtected() { ;} ;
void metFriendly() { ;} ;
} ;
Voici la classe FilleCherie. Les attributs et méthodes private protected de Mere ne peuvent
être utilisés que s’ils se rapportent à un objet de la classe FilleCherie ; il est par contre interdit d’y
accéder s’ils se rapportent à un objet de la classe Mere.
class FilleCherie extends Mere {
void AccesMere(Mere m) {
// m.attPrivate = 0 ; // interdit
// m.attPrivateProtected = 0 ; // interdit
m.attProtected = 0 ;
m.attFriendly = 0 ;
// m.metPrivate() ; // interdit
// m.metPrivateProtected() ; // interdit
m.metProtected() ;
m.metFriendly() ;
} ;
void AccesAFilleCherie() {
// attPrivate = 0 ; // interdit
attPrivateProtected = 0 ;
attProtected = 0 ;
attFriendly = 0 ;
// metPrivate() ; // interdit
metPrivateProtected() ;
metProtected() ;
metFriendly() ;
} ;
} ;
6
Le langage Java
La classe FilleIndigne a moins de droits :
import PaquetageA.Mere ;
class FilleIndigne extends Mere {
void AccesAMere(Mere m) {
// m.attPrivate = 0 ; // interdit
// m.attPrivateProtected = 0 ; // interdit
// m.attProtected = 0 ; // interdit
// m.attFriendly = 0 ; // interdit
// m.metPrivate() ; // interdit
// m.metPrivateProtected() ; // interdit
// m.metProtected() ; // interdit
// m.metFriendly() ; // interdit
} ;
void AccesAFilleIndigne() {
// attPrivate = 0 ; // interdit
attPrivateProtected = 0 ;
attProtected = 0 ;
// attFriendly = 0 ; // interdit
// metPrivate() ; // interdit
metPrivateProtected() ;
metProtected() ;
// metFriendly() ; // interdit
} ;
} ;
Enfin la classe Collegue est située dans le même paquetage que la classe Mere :
package PaquetageA ;
class Collegue {
void AccesAMere(Mere m) {
// m.attPrivate = 0 ; // interdit
// m.attPrivateProtected = 0 ; // interdit
m.attProtected = 0 ;
m.attFriendly = 0 ;
// m.metPrivate() ; // interdit
// m.metPrivateProtected() ; // interdit
m.metProtected() ;
m.metFriendly() ;
} ;
} ;
Tableau des protections
Accès à partir
de :
private
private
protected
protected
friendly
public
Mere
O
O
O
O
O
FilleCherie
N
R
O
O
O
Collegue
N
N
O
O
O
FilleIndigne
N
R
R
N
O
Etrangere
N
N
N
N
O
Avec :
7
Le langage Java
O : accès possible,
N : accès impossible,
R : cas réservé aux sous-classes. Accès possible, à condition que l’attribut ou la méthode se rapporte à
un objet de la sous-classe, et non pas un objet de la classe Mere,
Mere : définit des attributs et méthodes plus ou moins protégées,
FilleCherie : hérite de la Mere et est dans le même paquetage,
FilleIndigne : hérite de la Mere et est dans un autre paquetage,
Collegue : n’hérite pas de Mere mais est dans le même paquetage,
Etrangere : à la classe,
friendly est la protection des attributs et méthode par défaut, lorsqu’on ne précise rien.
L’héritage
C’est un des facteurs qui permet la réutilisabilité du code.
C’est une relation entre classes définie par le mot-clé extends ; dire qu’une classe fille hérite d’une
classe Mere signifie :
-
qu’elle en reprend les attributs et les méthodes,
-
qu’un objet de la classe Fille est aussi un objet de la classe Mere.
La classe qui hérite peut :
-
ajouter de nouvelles méthodes,
-
redéfinir les méthodes.
Dans l’exemple qui suit Voiture et Camion « sont des » Vehicules. Camion redéfinit la méthode
Accélerer et la propriété de polymorphisme de Java (voir plus loin) permet son appel suivant le type
dynamique de l’objet appelant.
8
Le langage Java
class Vehicule {
int nbRoues ;
int vitesse ;
void Accelerer() {
vitesse += 100 ;
}
} ;
class Camion extends Vehicule {
int poidsChargement ; // spécifique à camion
void Accelerer() {
vitesse += 1 ;
} ;
class Voiture extends vehicule {
boolean peintureMetallisee ; // spécifique à voiture
} ;
// appels valables
vehicule unVehicule = new Voiture() ;
unVehicule.Accelerer() ;
unVehicule = new Camion() ;
unVehicule.Accelerer() ; // +1
Toute classe hérite par défaut de la classe Object.
class Heritier {
est équivalent à :
class Heritier extends Object {
Une classe peut définir un constructeur, dans lequel elle peut être amenée à appeler le constructeur de
la classe mère (obligatoire si celui-ci attend des paramètres):
class Mere
private int monParam ;
public Mere(int unParam) {
monParam = unParam ;
}
}
class Fille extends Mere {
public Fille(int unParam) {
super(unParam) ; // appel du constructeur de Mere
}
}
Final
Dans certains cas il peut être utile d’interdire la redéfinition d’une méthode dans une classe dérivée.
Pour cela Java a prévu le mot clé final :
class mere {
final void MethodeFinale() {...};
}
et le compilateur rejettera toute tentative de redéfinition dans une classe héritée.
On définit aussi des constantes si un attribut est final :
final int constante = 128;
9
Le langage Java
il ne peut alors être modifié.
Redéfinition des méthodes, surcharge
La redéfinition consiste à définir une méthode de la classe mère (même nom, mêmes arguments) dans
une classe fille.
La surcharge d’une méthode c’est définir une nouvelle méthode ayant le même nom mais avec des
arguments différents.
Polymorphisme
C’est la liaison dynamique, la méthode d’une classe fille est automatiquement appelée à l’exécution
indépendamment du type statique.
Mere m ;
m = new Mere() ;
m.parle() ; // renvoie « je suis mere »
m = new Fille() ;
m.parle() ; // renvoie « je suis fille »
Fini les switch et les attributs inutiles !
Méthodes abstraites
Cette une méthode dont on donne la signature, sans en décrire l’implémentation. Celle -ci doit être
impérativement définie dans les sous-classes que l’on veut instancier.
abstract void MethodeAbstraite() ; // pas de corps
Une classe dont une méthode est abstraite est aussi abstraite :
abstract class Abstraite {
abstract void MethodeAbstraite() ;
}
sinon le compilateur le signale.
Une classe abstraite ne peut être instanciée puisqu’elle n’est pas complétement définies.
Interface
C’est une classe dont :
-
toutes les méthodes sont abstraites,
-
tous les attributs sont final.
interface Vehicule {
/* final */ int nbRoues = 2 ;
/* abstract */ void Methode() ;
}
Lorsqu’on hérite d’une interface, on l’implémente :
class Fille implements MereInterface {
Héritage multiple
On peut hériter d’une interface (classe totalement abstraite) que l’on implémente en même qu’on
hérite d’une autre classe :
10
Le langage Java
class Fille extends Mere implements MereSpirituelle { ... }
Paquetages et classes publiques
Exemple : les classes appartenant au paquetage java.awt sont situés :
-
dans des sources dont la première ligne de code est : package java.awt
-
dans un sous répertoire java/awt d’un des répertoires définis par la variable d’environnement
CLASSPATH
Chaque fichier Java comprend une et une seule classe public qui doit porter le même nom que le
fichier, au suffixe près.
Les librairies standard
Elles sont organisées en paquetages dont les principaux sont :
-
java.lang et java.util : extensions immédiates du langage
-
java.io : entrées/sorties
-
java.net : librairies réseaux
-
java.awt : librairies graphiques.
Les threads
Ils permettent d’exécuter des tâches en parallèle. Un thread peut être :
-
créé,
-
actif,
-
endormis,
-
mort.
Leur contrôle est réalisé à l’aide des méthodes :
-
new(),
-
start(),
-
wait()/notify(), sleep(), suspend(),
-
resume(),
-
stop().
Les exceptions
Ceux sont des objets descendants de la classe throwable qui peuvent être levés puis attrapés.
Définir et lever une exception
Définition :
class NbKilometresNegatif extends ExceptionNbKilometres {
}
11
Le langage Java
Par exemple :
if (nbKilomètres < 0) {
throw new NbKilometresNegatif() ; // levée
}
// les lignes suivantes ne sont pas exécutées si l’exception
// à été levée
if (prix < 0) {
throw new PrixNegatif() ;
}
Le flot d’exécution du programme est interrompu et remonte la pile des appels jusqu’au premier bloc
catch qui peut traiter l’exception.
Attraper une exception
Les blocs catch se situent à la suite d’un bloc try :
try {
//
//
//
//
ensemble d’instructions pouvant lever
NbKilometres et prixNegatif
directement ou indirectement par l’appel à des méthodes
elles-mêmes susceptibles de lever une exception
}
catch (NbKilometresNegatif e)
{
// Traitement de cette exception
}
catch (PrixNegatif e)
{
// Traitement de la deuxième exception
}
L’exception est attrapée dans le premier bloc catch pouvant traiter le type de l’exception.
Déclarer une exception
Les exceptions dont le soulèvement est à la portée d’une méthode et qui ne sont pas traitées dans ces
blocs catch doivent obligatoirement être déclarées dans le profile de cette méthode. Par exemple :
void MethodeQuelconque() throws Loup {
try {
// effectuer des traitements
// qui lèvent une exception Mere ou Loup
}
catch(Mere m) {
// traitement exception
...
}
}
Ainsi l’utilisateur de la méthode connaît les exceptions susceptibles d’être levées par la méthode et
aussi par les méthodes appelées.
Certains types d’exceptions cependant n’ont pas à être déclarés, c’est le cas par exemple des
RuntimeException qui sont généralement levées par le noyau Java.
12
Le langage Java
Les applets
Différences avec une application classique :
-
elles sont lancées grâce à un navigateur (netscape, HotJava…),
-
elles sont chargées à travers le réseau par l’intermédiaire de pages HTML,
-
leur cycle de vie est différent (initialisée et démarrée au chargement de la page HTML,
-
par sécurité elles ont des droits limités sur le poste qui les exécute (pas d’écriture de fichier, pas de
chargement de DLL…).
13
Le langage Java
Travail Dirigé
Exercice 1 (TAD vecteur)
Donner une réalisation en Java du TAD vecteur en vous inspirant de la classe vecteur réalisée en C++.
14
Le langage Java
Travail Dirigé
Exercice (exceptions)
Considérons le programme :
class GrandMere extends Exception { … } ;
class Mere extends GrandMere { … } ;
class PetiteFille extends Mere { … } ;
class Loup extends Exception { … } ;
avec le bloc suivant :
try {
}
catch (Mere m) {
System.out.println(m.toString()) ;
}
catch (GrandMere gm) {
}
catch (PetiteFille pf) {
}
Analyser l’ordre d’exécution des traitements d’exception, est-il correcte ? expliquer.
Exercice (exceptions)
Considérons une méthode de transfert d’information Transfert() en Java qui est susceptible de
propager la hiérarchie d’erreurs suivante :
Exception
ErreurProtocole
ErreurTransmetteur
ErreurConnexion
ErreurReceveur
ErreurEmission
Donner un exemple de construction « try { } catch() { } catch() { } … » prenant en compte cette
hiérarchie d’erreurs et affichant à chaque fois le type d’erreur produite (System.out.println
("Je suis l’erreur xxxx");).
15
Le langage Java
TP Java sur les mécanismes d’exception
Un exemple simple
Afin de tester les mécanismes d’exception en Java, on demande d’entrer le
programme donné au verso, de le compiler et de l’exécuter.
Dans un premier temps on testera le programme tel quel, on effectuera la
compilation du fichier "essai.java" sur la console d’entrée :
>javac essai.java
qui produit un fichier précompilé essai.class exécuté par :
>java essai
Ensuite, on testera et analysera les mécanismes d’exception en modifiant le
programme : ajout de clauses try, catch, en mettant l’attribut utilisateur
excep à true, false, en inversant les clauses catch, en ajoutant des
exceptions héritées ...
16
Le langage Java
import java.io.*;
import java.util.*;
import java.lang.*;
class MonException extends Exception {
//public String toString () {
//}
//System.out.println(" CECI EST MON EXCEPTION ");
//return super() ;
//}
}
//
// premiere application java
//
public class essai {
public boolean excep = false;
public static void main (String args[]) {
System.out.println(" Essai exception ");
essai pp = new essai ();
pp.methode1();
System.out.println(" Fin de l'essai ");
}
void methode1() {
try {
methode2();
}
catch (MonException me) {
System.out.println ("Ceci est mon exception ");
me.toString();
me.printStackTrace();
}
catch (Exception e) {
System.out.println ("Appel e.toString : " + e.toString());
System.out.println ("Appel e.printStackTrace : ");
e.printStackTrace();
}
}
void methode2() throws MonException {
if (excep)
throw new MonException();
methode3();
}
void methode3() { methode4(); }
void methode4() { int i = 0; i = 2 / i; }
}
17