I21 Algorithmique et programmation II

I21 Algorithmique et programmation
II
David Gross-Amblard, Joël Savelli
IEM-uB 2008-2009 - GFDL 1.2
CM2 version 2
Plan du cours
I. Rappels sur Java
- types, instructions, procédures, fonctions...
II.Programmation par objet
- classe, composition, héritage, initiation à la modélisation
III.Algorithmes (et types de données)
–
algorithmes de tri, algorithmes récursifs, listes, piles,
files, arbres
i21 - 2008-2009 IEM / uB GFDL 1.2
2
Procédure
public static void afficheNom(String nom){
System.out.println(« Le nom est »+nom);
}
●
void : c'est une procédure, l'appel est une
instruction (n'a pas de valeur)
i21 - 2008-2009 IEM / uB GFDL 1.2
3
Fonctions
public static int annéeNaissanceApprox(int age)
{
return 2009-age;
}
● int : type de retour
● Appel : possède une valeur (l'appel est une
expression)
● ex. System.out.println(anneeNaissanceApprox(35));
● return : instruction terminale, fixant la valeur
de retour
i21 - 2008-2009 IEM / uB GFDL 1.2
4
return
●
Peut apparaître plusieurs fois
public static int f(int x){
if (x>0) return 10;
if (x>10) return 0; // else implicite
return 20; // else implicite
}
i21 - 2008-2009 IEM / uB GFDL 1.2
5
Type de retour possible : tous
public static String friseDe5(String motif){
return motif+motif+motif+motif+motif;
}
String dessin=friseDe5(''*'');
(valeur de dessin : ''*****'')
●
Rappel : +, opérateur de concaténation de
chaînes
i21 - 2008-2009 IEM / uB GFDL 1.2
6
Résumé
●
Procédures : instructions, pas de valeur
●
Fonctions : expressions, ont une valeur
●
●
Distinction entre les deux : faux type de retour
void pour procédures
(comme en C, C++, à la différence du Pascal)
i21 - 2008-2009 IEM / uB GFDL 1.2
7
Syntaxe
class MonProgramme {
public static int maFonction(int x){...}
public static void maProcédure(){...}
public static void main(String[] arg){...}
}
●
●
●
main est une procédure
java MonProgramme exécute la procédure
main de MonProgramme.java (.class)
java MonProgramme salut bonjour, idem, avec
arg[0]=''salut'', etc.
i21 - 2008-2009 IEM / uB GFDL 1.2
8
Curiosité
●
En Java (comme en C, C++), on peut
–
oublier la valeur de retour d'une fonction
–
donc, la considérer comme une instruction
anneeNaissanceApprox(35);
●
(résultat perdu)
●
Par contre, une procédure n'a jamais de valeur
int x=afficheNom(''toto''); // erreur
●
Pas de déclaration de variable void (pas un
type)
i21 - 2008-2009 IEM / uB GFDL 1.2
9
Bonne pratique
●
●
Fonction utilisée comme instruction : peu
élégant
Séparation stricte :
–
Fonction : ont une valeur, utilisées dans les
expressions, ne font pas d'action (pas d'affichage,
modification mémoire,...)
–
Procédure : n'ont pas de valeur, utilisées comme
instructions, font des actions
i21 - 2008-2009 IEM / uB GFDL 1.2
10
(Autre curiosité en passant
●
Affectation (instruction) a aussi une valeur
●
Instruction x=3 a pour valeur 3
●
Danger :
boolean b=false,c=true;
If (b==c)...// valide, condition à faux
If (b=c) ...// valide, condition à vrai, b modifié)
i21 - 2008-2009 IEM / uB GFDL 1.2
11
(Autre curiosité en passant
●
Opérateur de postincrémentation
–
●
Opérateur de préincrémentation
–
●
x++ a pour valeur x, puis incrémentation x
++x a pour valeur x+1, puis incrémentation de x
Idem x--, --x
for(int x=0;x--<0;x=x++)
System.out.println(''génial''); ?)
i21 - 2008-2009 IEM / uB GFDL 1.2
12
Surcharge des procédures/fonctions
●
Autorise plusieurs procédures ou fonctions de
même nom
●
Différenciées par leur paramètres formels
●
ex. la procédure println est surchargée
●
println(''toto'');
●
println(12);
●
Bien sûr, ne surcharger que pour effectuer la
même famille d'action
i21 - 2008-2009 IEM / uB GFDL 1.2
13
Appels imbriqués
●
Si une procédure/fonction en appelle une
autre ?
i21 - 2008-2009 IEM / uB GFDL 1.2
14
Pile des appels
●
●
●
●
●
Ex. pour procédures
Contexte de l'appel : ensemble des variables
accessibles avant l'appel
Appel de la procédure : nouveau contexte,
contenant paramètres formels et variables
locales de la procédure
Si procédure appelle autre procédure,
empilement d'un nouveau contexte
Retour : dépilement de contexte
i21 - 2008-2009 IEM / uB GFDL 1.2
15
Pile des appels
p.s. void a(int x, int y){
b(x,x);
●
Appel a(5,6)
–
c(y);
Appel B(5,5)
●
●
}
p.s. void b(int x,int z){
–
affiche
Appel C(5);
Appel C(5);
Appel C(6)
5
5
6
c(x);c(z);
}
(p.s. : public static)
p.s. void c(int y)
{sopln(y);}
i21 - 2008-2009 IEM / uB GFDL 1.2
16
(Récursivité
●
●
Une définition de procédure/fonction M est
récursive si cette définition contient in fine des
appels à M.
(appel direct, ou à une procédure/fonction qui
fait appel, ou ...)
●
Programmation parfois très élégante
●
Pour plus tard)
i21 - 2008-2009 IEM / uB GFDL 1.2
17
Plan du cours
I. Rappels sur Java
- types, instructions, procédures, fonctions...
II.Programmation par objet
- classe, composition, héritage, initiation à la modélisation
III.Algorithmes (et types de données)
- algorithmes de tri, algorithmes récursifs, listes, piles, files,
arbres
i21 - 2008-2009 IEM / uB GFDL 1.2
18
II. Programmation par objet
1. Motivation
2. Encapsulation
3. Héritage
4. Initiation à la modélisation
i21 - 2008-2009 IEM / uB GFDL 1.2
19
1. Vers l'abstraction et au delà
●
Représentation machine : 1001011 (concret)
●
Représentation Java : int
●
Représentation d'un étudiant avec types de
base
–
●
72 (abstraction)
String nom, String prenom, int anneeNaissance
Bien, mais peut-on aller plus loin ?
i21 - 2008-2009 IEM / uB GFDL 1.2
20
Avec types de base
●
Savoir si deux étudiants sont potentiellement la
même personne
p.s. boolean mêmePersonne(String nom1, String
prenom1, int annee1, String nom2, String prenom2, int
annee2){
if (nom1.equals(nom2) &&
(prenom1.equals(prenom2) && annee1==annee2)
return true;
return false;
}
i21 - 2008-2009 IEM / uB GFDL 1.2
21
Limitation
●
Pénible (nombre de paramètres formels)
●
Difficile à mettre à jour
●
–
Si il faut ajouter numéro de sécurité social ?
–
Changer partout la représentation concrète de
l'étudiant
–
Ajouter des paramètres à la fonction précédente
–
Modifier son code pour comparer numéro de sécu.
Objectif : faire de Etudiant un type à part entière
i21 - 2008-2009 IEM / uB GFDL 1.2
22
Programmation par objets
●
Evolution des langages de programmation :
nouvelle notion de type
●
Langage impératif objet : Java, Pascal, C++
●
(Langage fonctionnel objet : ocaml
●
Langage logique objet : oopl)
●
Pas d'objets : C
i21 - 2008-2009 IEM / uB GFDL 1.2
23
Principes
●
Encapsulation : rassembler en un nouveau type
la représentation et les traitements d'une notion
abstraite
–
●
ex. : notion d'étudiant : type Etudiant
Héritage : matérialiser la relation d'héritage (des
représentations, des traitements) entre les
notions abstraites
–
ex. : un etudiant est une personne
–
le type Etudiant hérite (quoi) du type Personne
i21 - 2008-2009 IEM / uB GFDL 1.2
24
2. Encapsulation
•
Déclaration
•
Instanciation
•
Constructions
•
Accès aux membres et droits d'accès
•
Destruction d'instances
•
Membres de classe
Encapsulation
●
Regroupement des propriétés et des
traitements dans une même « capsule »
●
Nouveau type : classe
●
La classe définit ses membres :
●
Attributs : propriétés (variables et constantes)
●
Méthodes : traitements (procédures ou
fonctions)
Modèle d’un étudiant (scolarité)
class Etudiant
Membres :
{
String nom, prenom;
Attributs
int dateNaissance;
String numeroEtudiant;
int[] notes;
String academie,ufr,formation;
double valeurMoyenne(){…}
String valeurMention(){…}
void fixeMoyenne(float note){…}
void editeDiplome(){…}
void editeCarte(){…}
}
Methodes
Règle et conventions Java
●
●
Règle :
–
Un fichier par définition de classe, ayant le même
nom que la classe
–
ex. Etudiant.java pour classe Etudiant
Convention :
–
Identificateur de classe débute par une majuscule
–
Identificateur d'attribut, méthode : par une
minuscule
Instanciation
●
●
ex :
–
3 : instance du type (de base) int
–
l'étudiant John Doe est une instance de la classe
Etudiant
Instanciation : matérialisation en mémoire d'un
objet respectant la définition de sa classe
(l'objet a les attributs et méthodes spécifiés)
●
Objet : instance d'une classe
●
Type d'un objet : sa classe
●
Une classe peut avoir plusieurs instances
Instanciation d'une classe
Etudiant e;
e=new Etudiant();
●
●
Objets toujours manipulés par référence (e est
une référence vers l'objet de type Etudiant)
Deux étapes :
–
Allocation mémoire de chaque attribut
–
Initialisation : appel de la méthode constructeur
Constructeur(s)
●
Méthode(s) ayant pour identificateur le nom de
la classe et pas de type de retour
Class Etudiant {
String nom;
public Etudiant(){nom=''inconnu''};
public Etudiant(String n){nom=n;}
public Etudiant(Etudiant e){ ... }
}
●
Surcharge des constructeurs
Utilisation des constructeurs
Etudiant e=new Etudiant();
Etudiant e2=new Etudiant(« Bob »);
Etudiant e3=new Etudiant(e2);
●
Si aucun constructeur défini : constructeur par
défaut Etudiant() (donne leur valeur par défaut
aux attributs)
Accès aux membres
●
Méthodes d'un objet : accès direct à ses
propres attributs
Class Etudiant {
String nom;
public void fixeNom(String n){
nom=n;
}
}
Accès aux membres
●
De l'extérieur : notation pointée
Etudiant e=new Etudiant(« bob »);
System.out.println(e.nom);
e.fixeNom(''john'');
Danger
●
Le code externe à l'objet peut manipuler
directement son état interne
e.Moyenne=-15; // Moyenne négative ?
e.nom=null; // N'y a-t-il pas toujours un nom ?
●
Peu souhaitable
Droits d'accès sur les membres
●
Mots-clés public, private
●
Membre public : toujours accessible
●
●
Membre private : accessible uniquement depuis
les méthodes de la classe
(existe d'autres subtilités)
Exemple
Class Etudiant {
public String nom;
e.nom=''bob''; //ok
private String codeSecret;
e.codeSecret=''truc''; //
interdit
public void afficheNom()
{...}
private int calculAge(){...}
}
Etudiant e=new Etudiant();
e.afficheNom(); // ok
int n=e.calculAge(); // interdit
Destruction d'instances
Etudiant e=new Etudiant();
e=new Etudiant();
●
●
●
●
Premier objet perdu
Si un objet n'est plus référencé par aucune
variable, alors (a un moment donné), il est
effacé de la mémoire et la mémoire réutilisée
Mécanisme de ramasse-miette (glanage de
cellule, garbage collecting)
(Idem pour les tableaux et les chaînes)