Vous êtes sur la page 1sur 33

Déroulement du cours

8h15 9h45 10h 11h30


9 janvier COURS TD

10 janvier TP TP

17 janvier TP TP
23 janvier TD TP

24 janvier TD TP

30 janvier TD TP

6 février TP TP

7 février EXAMEN TP

– 2 TP à envoyer à la fin des séances (24/1 et 7/2)


– Évaluation sur un de ces 2 TPs et l'examen écrit
note = 0,5*examen + 0,5*TP
Modèle en cascade pour le
développement logiciel
Analyse
SADT, SA-RT, MERISE,
OMT, UML, …
Conception

Implémentation Fortran, Cobol, C, SmallTalk,


Ada, C++, Java, …
Tests

Maintenance
Langages procéduraux et
fonctionnels
Un programme est composé de plusieurs
procédures (ou fonctions) :
 qui effectuent un traitement sur des Données
données (procédure)
 qui retournent une valeur après leur
invocation (fonction) Traitement 1

Certains langages ne distinguent pas Traitement 2


procédures et fonctions.
Traitement 3
Exemples de langages procéduraux ou
fonctionnels : Fortran, Lisp, C, …
Langages Orientés-Objet

Un programme est composé de plusieurs


objets qui contiennent : D
 des données "internes" T
 des traitements manipulant ces
données internes ou d'autres données D D

T
Les données d'un objet sont appelés ses T

attributs et ses traitements sont ses


D
méthodes (ou opérations). D

T T
Exemples de langages orientés-objet :
SmallTalk, C++, Java, …
UML & Java
Unified Modeling Language (UML) :
Analyse notation standard pour l'analyse et la
conception
construite par l'Object Management
Conception Group
Première version standard en 1997
Implémentation Java :
pas un standard mais un langage très
largement utilisé
Tests développé par SUN microsystems en
1995
Maintenance dernière version stable : JDK 1.5.0
Objet
 Approche procédurale :
"Que doit faire mon programme ?"
 Approche orientée-objet :
"De quoi doit être composé mon programme ?"
 Cette composition est conséquence d'un choix de modélisation
fait pendant la conception

Exemple: Gestion d'une bibliothèque

Germinal
E. Zola
Le Monde Alice Dupont Anne Durand
Directrice
Lectrice

Arsène Deschamps
Le seigneur des anneaux Michel Martin Lecteur
J.R.R.Tolkien
Bibliothécaire
Classe
Des objets similaires peuvent être informatiquement décrits par
une même abstraction : une classe
 même structure de données et méthodes de traitement
 valeurs différentes pour chaque objet Classe Lecteur
Classe Livre Classe Employé -nom, prénom
-titre, auteur Classe Journal -nom, prénom, statut
-titre

Germinal
E. Zola
Le Monde Alice Dupont Anne Durand
Directrice
Lectrice

Arsène Deschamps
Le seigneur des anneaux Michel Martin Lecteur
J.R.R.Tolkien
Bibliothécaire
Contenu d'une classe
Une classe est composée de plusieurs membres dont chacun est soit :
 un attribut : variable typée
 une méthode (ou opération) : ensemble d'instructions de
traitement
class CompteBancaire {
String proprietaire;
Attributs double solde;

double getSolde() {
return solde;
}
Méthodes
void credite(double val) {
solde = solde + val;
}
}
Encapsulation
L'encapsulation est la pratique consistant à regrouper des
attributs au sein d'une même classe.

Exemple : la classe Livre encapsule les attributs titre et


emprunteur

 Pour améliorer la lisibilité des programmes, les attributs


encapsulés sont souvent privés (inaccessibles aux autres
classes).
 Les données et méthodes accessibles sont dites publiques.
Syntaxe Java
Le code source d'un programme Java est contenu dans
plusieurs fichiers d'extension .java

 Une seule classe publique par fichier;


 Le nom du fichier doit être le même que celui de la
classe;
 Par convention, le nom d'une classe commence toujours
par une majuscule.

Le code source d'une classe commence par le mot-clé class suivi de


son contenu :

class <nom de la classe> {


<contenu de la classe>
}
Types primitifs de données
Même types qu'en C: Plus deux nouveaux types :
 int  boolean
 byte
 float
 double Plus la classe :
 short  String
 long
 char Déclaration :
int monEntier;
 void
String chaine;
boolean test;
Écriture des méthodes
Une méthode est composée de sa signature et d'un traitement
associé.
La signature d'une méthode contient notamment :
 un nom de méthode;
 un type de données de retour;
 des types de données pour ses arguments;
…
Par convention le nom des méthodes et attributs commencent
toujours par une minuscule.

<type de retour> <nom de méthode> ( <arguments> * ) {


<traitement associé>
}
Exemple
class Livre {: classe Livre
String titre;
Lecteur emprunteur;
Attributs

void setTitre(String t) {
titre = t;
}

String getTitre() {
return titre; Méthodes
}

Date emprunte(Lecteur lec) {


if (emprunteur = = null) {
emprunteur = lec;
return new Date();
} else return null;
}
}
Portée d'une variable
public class Portee {
int a;

public void test(int b) {


if (a > b) {
int c = b; l'entier a est visible dans
b = a; toute la classe
a = b;
}
afficher(b);
}
}
Portée d'une variable
public class Portee {
int a;

public void test(int b) {


if (a > b) {
int c = b; l'entier b est visible à
b = a; l'intérieur de la méthode
a = b;
}
test
afficher(b);
}
}
Portée d'une variable
public class Portee {
int a;

public void test(int b) {


if (a > b) {
int c = b; l'entier c est visible dans
b = a; le bloc du if
a = b;
}
afficher(b);
}
}
Instanciation
L'instanciation est l'opération qui consiste à créer un objet à
partir d'une classe.

En Java, le mot-clé new provoque une instanciation en faisant


appel à un constructeur de la classe instanciée.

 Un constructeur est une méthode qui a le même nom que la


classe
 Un constructeur n'a pas de valeur de retour
 Plusieurs constructeurs peuvent exister dans une même
classe (avec des arguments différents)
 Il faut au moins un constructeur dans une classe pour en
instancier des objets
Constructeur de la classe Livre
class Livre {
String titre;
Lecteur emprunteur;

Livre(String t) {
titre = t;
emprunteur = null; Constructeur
}

void setTitre(String t) {
titre = t;}

String getTitre() {
return titre;}

Date emprunte(Lecteur lec) {



}
}
Instanciation de la classe Livre
class InterfaceBibliothecaire {

void enregistreLivre(String nom) {


Livre nouveauLivre;
nouveauLivre = new Livre(nom);
ajouteEnBibliotheque(nouveauLivre);
}

void ajouteEnBibliotheque(Livre li) {



}
}
Invocation de méthodes
En Java, une méthode ne peut pas être invoquée
seule, elle est toujours appelée sur un objet.
Un point . sépare le nom de la méthode de l'objet sur lequel elle est
invoquée.

Livre monLivre = new Livre("Germinal");
String titreDuLivre = monLivre.getTitre();

Le mot-clé this désigne, en cours d'exécution d'une méthode, l'objet
sur lequel elle est appelée.

La syntaxe pour accéder aux attributs d'un objet est la même.


Exemple
class Livre { class Lecteur {
String titre; Livre[ ] emprunts;
Lecteur emprunteur; int nbEmprunts;
… …
boolean estEmprunte() { boolean empruntePossible() {
if (emprunteur == null) return false; if (nbEmprunts < 5) return
else return true; true;
} else return false;
}
Date emprunte(Lecteur lec) {
if ( this.estEmprunte() == true)
return null; void ajouteEmprunt(Livre liv) {
if ( lec.empruntPossible() ) { emprunts[nbEmprunts] = liv;
emprunteur = lec; nbEmprunts ++;
lec.ajouteEmprunt( this ); }
return new Date(); }
} else return null;
}
}
Visibilité des membres
La visibilité d'une classe et de ses membres définit quelles
autres classes y ont accès. Ces contraintes portent sur :
 la référence fait à une classe
 l'invocation d'une méthode sur un objet
 l'accès en lecture et écriture à un attribut d'un objet

4 niveaux de visibilité en Java :


 public : visible tous les objets
 private : uniquement visible par les instances de la classe
 protected : expliqué ultérieurement
 par défaut : expliqué ultérieurement
Exemple de visibilité
public class Lecteur {
public class Livre {
private Livre[ ] emprunts;
private String titre;
private Lecteur emprunteur; private int nbEmprunts;
… …
private boolean estEmprunte() { public boolean empruntePossible() {
if (emprunteur == null) return if (nbEmprunts < 5) return true;
false; else return false;
else return true; }
}
public void ajouteEmprunt(Livre liv)
public Date emprunte(Lecteur lec) {
{
if ( this.estEmprunte() == true)
emprunts[nbEmprunts] = liv;
return null;
if ( lec.empruntPossible() ) { nbEmprunts ++;
emprunteur = lec; }
lec.ajouteEmprunt( this ); }
return new Date();
} else return null;
}
Exceptions
En Java, les erreurs se produisent lors d'une
exécution sous la forme d'exceptions.
Une exception :
 est un objet, instance d'une classe
d'exceptions.
 peut provoquer la sortie d'une méthode
 correspond à un type d'erreur
 contient des informations sur cette erreur
Déclaration des exceptions
possibles
Une méthode déclare, par le mot-clé throws, dans sa signature
les classes d'exception qu'elle peut envoyer.

Exemple de la méthode substring de la classe String:


public class String {

public String substring( int beginIndex, int endIndex )
throws IndexOutOfBoundsException {

}

}
Traitement des exceptions
Il y a deux manières de traiter une exception reçue :

Propagation Interception
public String initialesAuteur(Livre l) public String initialesAuteur(Livre l) {
throws IndexOutOfBoundsException { String titre, initiales;
String titre, initiales; try {
titre = l.getTitre(); titre = l.getTitre();
initiales = titre.substring(0,2); initiales = titre.substring(0,2);
return initiales; return initiales;
} } catch (IndexOutOfBoundsException ex) {
return new String("???");
}
}

L'exception est renvoyée à la méthode L'exception est traitée dans la


ayant invoquée initialesAuteur méthode initialesAuteur et "disparaît"
Émission & création
d'exceptions
Vous devez prévoir tous les cas d'erreurs des méthodes que vous
écrivez en émettant les exceptions appropriées:
1. Créer un objet d'une classe d'exception
2. Émettre l'exception
public Date emprunte(Lecteur lec) throws Exception {
if ( this.estEmprunte() = = true) {
Exception excep = new Exception("Livre deja emprunte");
throw excep;
}
if ( lec.empruntPossible() ) {
emprunteur = lec;
lec.ajouteEmprunt( this );
return new Date();
} else {
throw new Exception("Le lecteur a trop d'emprunts");
}
}
Compléments de syntaxe
Instruction conditionnelle

if <condition> {bloc_si_vrai} else {bloc_si_faux}

Exemple :

if ( emprunteur.getStatut() = = "employe") {
unLivre.setDateRetour(30);
} else {
unLivre.setDateRetour(15);
}
Compléments de syntaxe
Instruction itérative

while <condition> {bloc}

Exemple :

while ( i < biblio.nbLivres() ) {


Livre l = biblio.getLivre(i);
l.setDisponible(true);
i++;
}
Compléments de syntaxe
Instruction itérative

for (<init>; <condition>; <increment>) {bloc}

Exemple :

for (int i = 0; i < biblio.nbLivres(); i++ ) {


Livre l = biblio.getLivre(i);
l.setDisponible(true);
}
Compléments de syntaxe
Instruction de choix multiple
switch (<variable>) { Exemple :
case <val1>: <bloc1>
case <val2>: <bloc2> switch (l.getCategorie()) {
… case 1: l.setDuree(15);
default: <bloc> break;
} case 2: l.setDuree(20);
break;
default: l.setDuree(30);
}
Autres particularités de
syntaxe
 On peut utiliser l'opérateur + sur les objets de
classe String
String s1 = "hello ", s2 = "world";
String s3 = s1 + s2;
 s3 vaut "hello world"

 La variable length donne la taille d'un tableau;


char[] tab = new char[25];
int a = tab.length;
 a vaut 25