modÈleset angages de programmation - … · le nom du fichier («firstprogram.java») doit...

MODÈLES ET LANGAGES

DE PROGRAMMATION

Cécile Hardebolle, Christophe Jacquet,Éric Totel, Marc-Antoine Weisser

Table des matières

I. Introduction : Qu'est-ce que la programmation ? (#8)

II. Programmation impérative (#16)1. Premier programme (#18)

2. Déclaration et affectation (#25)

3. Entrées / Sorties (#32)

4. Nombres (#36)

5. Blocs et structure conditionnelle (#42)

6. Booléens (#53)

7. Boucles (#59)

8. Types de données et expressions (#83)

9. Tableaux (#92)

10. Fonctions (#109)

11. Bibliothèques de fonctions (#147)

12. Constantes (#151)

13. Packages et visibilité (#157)

III. Approche objet (#161)1. Introduction (#162)

2. Objets et classes (#167)

3. Constructeur (#184)

4. Méthodes (#194)

5. Classes prédéfinies (#211)

6. Comparaison et représentation textuelle des objets (#219)

7. Héritage (#225)

8. Polymorphisme (#238)

9. Classes abstraites (#248)

10. Visibilité (#253)

IV. Conclusion : Quelles sont les autres façons de programmer ? (#265)

MLP — septembre 2014 2

Informatique ?

Pascaline1650

abaque, boulier-2000

Machine à différencesde Babbage

1830

ENIACpremier

ordinateur1945

Omniprésencedu numérique

2000…


� Connaître :► Notion de programme

► Concepts de base de la programmation

► Vocabulaire

� Être capable de :

� Comprendre un programme compte tenudu formalisme du langage utilisé

� Concevoir et écrire un programme

Objectifs du cours


① Introduction� Qu’est-ce que la programmation ?

② Programmation impérative� Comment programmer avec un langage impératif ?

③ Approche objet� Qu’est-ce que l’approche objet et comment programmer avec un langage orienté objet ?

④ Conclusion� Quelles sont les autres façons de programmer ?

Plan du cours


Cours5 & 6

Cours 7

EL 1

Une pédagogie axée sur la pratique


Introduction. Bases de la programmation impérative

Affectation, structures de contrôle

Un peu de graphisme !

EL 2

BE 3

Cours3 & 4

BE 2

Cours1 & 2

BE 1

Types de données, tableaux, fonctions

Tableaux, fonctions et récursivité

Bases de la programmation objet

Programmation objet

Héritage et polymorphisme. Conclusion

Un peu de graphisme ! (suite)

Vous écrirezvos premiers programmes

ici !

36% de cours32% de BE (pratique)32% d'EL (pratique)

Ressources du cours


Aide-mémoire

Polycopié

Site webhttp://wwwdi.supelec.fr/MLP

TutoC

SiteB

LivreA

• API Java 8http://docs.oracle.com/javase/8/docs/

• Livre Programmer en Java,

C. Delannoy, Eyrolles, 2014

• Introduction à la programmation objet,

R. Guerraoui et J. Sam

http://cowww.epfl.ch/proginfo/wwwhiver/

Accessiblesur mobile !

Plan

I. Introduction : Qu'est-ce que la programmation ?

II. Programmation impérative1. Premier programme

2. Déclaration et affectation

3. Entrées / Sorties

4. Nombres

5. Blocs et structure conditionnelle

6. Booléens

7. Boucles

8. Types de données et expressions

9. Tableaux

10. Fonctions

11. Bibliothèques de fonctions

12. Constantes

13. Packages et visibilité

III. Approche objet1. Introduction

2. Objets et classes

3. Constructeur

4. Méthodes

5. Classes prédéfinies

6. Comparaison et représentation textuelle des objets

7. Héritage

8. Polymorphisme

9. Classes abstraites

10. Visibilité

IV. Conclusion : Quelles sont les autres façons de programmer ?


� Ensemble de techniques permettant derésoudre des problèmes à l’aide d’un ordinateur

� Programmer savoir exprimer ses idéeset les structurer de façon efficace

Programmation ?

Données RésultatsTraitement

➡


1) Cahier des charges

2) Spécification du problème

3) Conception : architecture, algorithme(s)

4) Codage

5) Mise au point

6) Déploiement, maintenance, évolution

Étapes de la programmation

Programmation ≠ codage !


Cours d’informatique en tronc commun à Supélec :

► Première année : Modèles et Langages de Programmation (MLP), Structures de données et Algorithmes (FISDA), Génie Logiciel (GL)

► Deuxième année : Architecture des Systèmes Informatiques (Archi), Systèmes d’Information (SI), Projet de développement logiciel




4) Codage

5) Mise au point


Étapes de la programmation

GL

GL

GL

MLP

GL

GL

FISDA

GL FISDA Archi

SI


Structure d’un ordinateur

entréessorties

mémoire

instructions

01

n

unité detraitement

données

données(accès direct)

ordres

états

données

ContientInstructions + Données

Exécute les instructions une à une⇒ Agit sur les données ou les entrées/sorties

cases


� Langage permettant d’écrire les instructions qui seront exécutées par l’unité de traitement► Différents langages possibles (Assembleur par exemple)

► « Bas niveau »

► Exemple : calcul de maximum

� Souhaiteriez-vous programmer de cette façon ?

Langage machine

0: iload_0 // a

1: iload_1 // b

2: if_icmple 7 // si a > b

5: iload_0 // a est le maximum

6: ireturn

7: iload_1 // sinon b est le maximum

8: ireturn

En binaire :00011010 0001101110100100 0000000000000101 0001101010101100 0001101110101100


Codage

Programme Exécutable

Données

Résultats

Interprétation

Programme Interpréteur

Données

Résultats

Compilateur

Spécification,Algorithme

Traduction

Langage naturel

Ambigu

Langage deprogrammation

Sans ambiguïté,« de haut niveau »

Langage machine

Sans ambiguïté,« de bas niveau »


� Créé en 1995 par Sun Microsystems,entreprise rachetée par Oracle en 2009

� Très utilisé :► Applications métier sur serveurs (web...)

► Applications sur téléphones et tablettes (Android)

► Applications sur PC

� Modalités de diffusion du langage et des outils :► Logiciels libres (mise à disposition gratuite)

► Disponibles sur presque toutes les plate-formes

� Java est un langage de programmation impératif et objet

Java


Plan


II. Programmation impérative

1. Premier programme



4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Langage impératif :► Notion de variable

► Programme = séquence d’actions, définie par le développeur, pour faire évoluer les variables dans le but de résoudre un problème (faire un calcul par exemple)

� Langage objet :☛Vu en deuxième partie de cours (cours 5, 6 et 7)

Java, un langage impératif et objet

lire x

lire y

calculer x * y

stocker le résultat dans z

afficher z


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Un programme qui ne fait rien : fichier « Nothing.java »

� Comment utiliser ce programme ?1) Compiler (automatique avec Eclipse)

2) Exécuter

Le plus petit programme Java

public class Nothing {

public static void main( String args[] ) {

}

}

Séquence d'instructions

à exécuter(vide ici)


Un exemple plus complet

public class Factorial {

public static void main( String args[] ) {

int n; // déclaration de trois variables

int fact; // pouvant contenir des entiers

int i;

n = Input.readInt("n ?"); // lecture de n

i = 1; // initialisations : 1!=1

fact = 1;

while (i <= n) { // boucle de calcul

fact = fact * i; // fact = 1*1*2*3*…*i

i = i + 1; // incrémentation de i

}

System.out.println(fact); // affichage

}

}

Séquence d'instructions

à exécuter


� Commenter un programme = expliquer en français(ou en anglais) ce que le code fait► Doit expliquer le raisonnement qui a abouti au programme

► Ne doit pas alourdir le code

� Essentiel pour :► Documenter un programme

► Travailler en équipe

► Rendre un programme réutilisable

Commentaires

// commentaire sur une seule ligne

/* commentaire

sur plusieurs lignes

*/


� Instructions = briques de base que l’on assemblepour obtenir un programme

� Catégories d’instructions :► Déclaration : créer une variable

► Affectation : ranger une valeur dans une variable

► Entrées-sorties : lire ou afficher des données

► Structures de contrôle : organiser la séquence d'instructions

Instructions

int x;

x = 1;

System.out.println("Travail terminé ; au revoir !");

if (x < 0) {…

} else {…

}


� Pour créer un programme Java :► Créer un fichier « FirstProgram.java »

► Ecrire le code suivant :

� Remarques :► Le nom du fichier (« FirstProgram.java ») doit correspondre

au code class FirstProgram

► Le programme exécutera les instructions mises dansle main

Synthèse : structure d’un programme Java

public class FirstProgram {

public static void main(String[] args) {

… instructions …

}

}


Développement d'un programme Java

Rédaction du programme dans

une fenêtre d'édition d'Eclipse

Compilation(réalisée à la volée)

Exécution(Run)

pas d'erreur

erreur(s) signalée(s)

fonctionnementattendu

dysfonctionnement(s), erreur(s) à l'exécution


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



Rappel : structure d’un ordinateur

entréessorties

mémoire

instructions

01

n

unité detraitement

données

données(accès direct)

ordres

états

données

ContientInstructions + Données

Exécute les instructions une à une⇒ Agit sur les données ou les entrées/sorties

cases


� Mémoire ≈ ensemble de « tiroirs »

� Chaque « tiroir » stocke une donnée

� Une donnée est représentée en programmation par une variable

Mémoire : analogie


� Création et nommage d’une nouvelle variable

� Fonctionnement► Réserve une case dans la mémoire pour stocker la valeur

► Donne un nom (identificateur) à cette case mémoire afin de pouvoir y accéder facilement plus tard pour :� Stocker une valeur

� Lire la valeur stockée

Première instruction : la déclaration

int maVariable;

Nomde la variable

Typede la variable


maVariable

� Contraintes► Contient uniquement des lettres, chiffres ou ‘_’

► Commence par une lettre ou par ‘_’

► Aucun accent

► Ne doit pas être un mot-clé du langage (class, int, if, …)

� Conventions► Majuscule à chaque mot sauf au premier

► Le nom d’une variable désigne explicitement son contenu

Conventions de nommage

int nombreDeParticipants;

int valeur2;

int nombre_de_participants;

int 2valeur;

int moitié;


� Initialisation ou changement de la valeur d’une variable

� Affectation ≠ égalité !► « = » n’a pas le même sens qu’en mathématiques

► « = » se lit « reçoit »

Deuxième instruction : l’affectation

maVariable = expression;

maVariable � expression;

1Évaluation de l’expression(calcul de la valeur)

Stockage du résultat2


valeur expr.maVariable

Exemple : déclaration & affectation



int x; // déclaration d’une variable appelée « x »

int y; // déclaration d’une variable appelée « y »

x = 10; // affectation de la valeur littérale 10 à x

y = x; // affectation de la valeur contenue dans x

// (c’est-à-dire 10) à y

x = 20 * 3 + 12; // affectation du résultat de

// l’évaluation de l’expression

// 20 * 3 + 12 à x

// y ne change pas de valeur !

}

}

1

2


x

y

10

10

72

Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Instructions de communication avec l’extérieur

� Java n’en possède pas à proprement parler► Bibliothèque de fonctions→ même effet

� Exemples :

Instructions d’entrées / sorties

entrée

sortie

// lecture d’un entier

x = Input.readInt();

// affichage avec retour à la ligne

System.out.println(variable);

// affichage sans retour à la ligne

System.out.print(variable);


� Dans un fichier « Square.java » :

Exemple d’interactions

import interaction.Input;

public class Square {


int x; // déclaration d’une variable entière « x »

int y; // déclaration d’une variable entière « y »

x = Input.readInt("x ?"); // lecture puis affectation de x

y = x * x; // affectation de y

System.out.println(y); // affichage de y

}

}


� Notation abrégée : déclaration + initialisation

� On ne peut pas lire une variable non initialisée :

Initialisation : première affectation

int age; // déclaration

System.out.println(age);

age = 50; // initialisation

int age = 40;

Variable age non initialisée à ce stade→ interdit de chercher

à utiliser sa valeur

int age;age = 40;


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Nous venons de voir le type entier

� Impact du type en Java :► Une variable ne peut contenir que des valeurs du type donné !

► Les opérations possibles sur la valeur dépendent du type

Qu’est-ce qu’un type de données ?

int monEntier; // déclaration d’un entier

monEntier = -5; // affectation d’une valeur entière

NomType

Valeur


-5monEntier

� Représentation des entiers► Type Java : int

► Exemple :

� Comment représenter les nombres réels ?► Représentation approchée sur un ordinateur

► Nombres à virgule flottante (floating-point numbers)

Nombres

int monEntier; // déclaration d’un entier

monEntier = -5; // affectation

System.out.println(monEntier * 4);

System.out.println(monEntier / 4);Que va afficherce programme ?


� Type Java : double► « Double précision »

► Existe aussi float, simple précision (peu utilisé)

� Écriture des littéraux (valeurs) :► Un point pour séparer les décimales : 7.3 -10.2 5.0

► Notation scientifique possible : 6,02x1023 sera noté 6.02e23

� Exemple :

Nombres à virgule flottante

double zero; // déclaration d’un réel

zero = 0.0; // affectation d’une valeur réelle

System.out.println(-5.0 / 4.0);

System.out.println(6.02e23);


� Portent sur entiers et réels

� Priorités usuelles

� Associatifs à gauche

Opérateurs arithmétiques

Opérateur Opération Exemple Ex. Numérique

+ addition z=x+y 3+2 → 5

- soustraction z=x-y 3-2 → 1

* multiplication z=x*y 3*2 → 6

/ division z=x/y3.0/2.0 → 1.53/2 → 1

%reste de la division (modulo)

z=x%y13%5 → 32.2%1.5 → 0.7


� Déclaration d’une variable► De manière générique :

► Exemple pour les entiers :

� Affectation d’une variable► Affectation d’une valeur littérale :

► Affectation d’une expression :

� Entrées/sorties► Entrée (lire une valeur) :

► Sortie (afficher une valeur) :

Synthèse : variables et entrées/sorties

type nomDeVariable;

int monAge;

monAge = 21;

ageDeMonFrere = monAge - 2;

monAge = Input.readInt();

System.out.println("Hello !");

System.out.print(monAge);

Rappel :Affectation ≠ égalité !


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Par défaut :exécution des instructionsles unes après les autresdans l’ordre d’écriture

� Besoins :► Sauter un groupe

(sous certaines conditions)

► Répéter un groupe

� Instructions de contrôle

Instructions de « contrôle »

i1;i2;i3;i4;i5;

i1;i2;i3;i4;i5;i6;

5 fois


Exemple

public class AbsoluteMajority {


int voteCount;

int majority;

voteCount = Input.readInt("Nombre de votants ?");

if((voteCount % 2) == 0) { // nombre de votants pair

System.out.print("Nombre de votants pair. ");

majority = voteCount / 2 + 1;

} else { // nombre de votants impair

System.out.print("Nombre de votants impair. ");

majority = (voteCount - 1) / 2 + 1;

}

System.out.println("Majorité absolue = " + majority);

}

}


Exemple : bloc d’instructions

public class AbsoluteMajority {


int voteCount;

int majority;

voteCount = Input.readInt("Nombre de votants ?");

if((voteCount % 2) == 0) { // nombre de votants pair

System.out.print("Nombre de votants pair. ");

majority = voteCount / 2 + 1;

} else { // nombre de votants impair

System.out.print("Nombre de votants impair. ");

majority = (voteCount - 1) / 2 + 1;

}

System.out.println("Majorité absolue = " + majority);

}

}


� Grouper plusieurs instructions en une seule→ entre accolades { }

� Peut également contenir des déclarations de variables

� Exemple :

Grouper plusieurs instructions : bloc

1 déclaration

3 instructions

…

{

int temp;

temp = d1;

d1 = d2;

d2 = temp;

}

… Bloc


Exemple : instruction conditionnelle

public class Sign {


int x;

x = Input.readInt("Donnez un nombre");

if (x < 0){ // teste si x est négatif

System.out.println("Le nombre saisi est négatif.");

} else {

System.out.println("Le nombre saisi est positif.");

}

}

}


� if : un bloc d’instructions est exécuté si unecondition est vraie

� if-else : un bloc d’instructions est exécuté si une condition est vraie, sinon un autre est exécuté

Instruction conditionnelle : if

if ( x < 0) {

x = -x;

}

if ( x < y ) {

z = x;

} else {

z = y;

}


Cond.

Bloc

fauxvrai

Cond.

Bloc

fauxvrai

Bloc

► L’indentation des instructions est très importante !

If : imbrication

if(note > 16) {

System.out.println("Examen très bon !");

} else {

if(note < 10) {

System.out.println("Examen à rattraper.");

rattrapages = rattrapages + 1;

} else {

System.out.println("Examen OK.");

}

}


Synthèse : if

if (condition) {

i1;

i2;

…

in;

} else {

j1;

j2;

…

jn;

}

Bloc d’instructions exécuté si condition

vraie

Bloc d’instructions exécuté si condition

fausse

optionnel


� La portée d'une variable commence à l'endroit où elle est déclarée et finit à la fin du bloc qui contient sa déclaration

� Exemple :

Portée d'une variable

int age;

age = Input.readInt("Donnez votre âge :");

if(age <= 25) {

int tarif;

tarif = 4;

} else {

tarif = 11;

}

Déclarationde la variable

tarif

Portéede la variable

tarif

Ici la variable tarif n'existe pas !


Else if

if (condition1) {

…

} else if (condition2) {

…

} else if (condition3) {

…

} else {

…

}


if (condition1) {

…

} else {

if (condition2) {

…

} else {

if (condition3) {

…

} else {

…

}

}

}

Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Quelle est la nature d'une condition ?

� < est aussi un opérateur !► Compare des entiers ou réels

► Type de son résultat ?

Opérateurs de comparaison

if (x < 0){ // teste si x est négatif

System.out.println("Le nombre saisi est négatif.");

} else {

System.out.println("Le nombre saisi est positif.");

}

Expression ?

Type booléen :valeur logique

vrai/faux


� Type Java : boolean

� Écriture des littéraux (valeurs) : true et false

� Exemple :

Booléens (valeurs logiques)

…

boolean majeur = (age >= 18);

if(majeur) {

System.out.println("Vous pouvez voter !");

}


� Opérateurs au même titre que +, *, ...

� Rendent un résultat booléen

Opérateurs de comparaison

Opérateur Utilisation Rend true si

== a == b a et b égaux

!= a != b a et b différents

> a > b a > b

>= a >= b a ≥ b

< a < b a < b

<= a <= b a ≤ b

a et b sontdes entiersou des réels


� && et || évalués en court-circuit

Opérateurs entre booléens

Nom Opérateur Utilisation Rend true si

ET && a && b a et b sont vrais

OU || a || b a ou b est vrai

NON ! ! a a est faux

a et b sontdes booléens


� Types

� Expressions construites à partir des opérateurs► Arithmétique : +,-,*,/,%

(avec versions unaires et raccourcies)

► Comparaison et logique : <,>,<=,>=,==,!=,&&,||,!

Synthèse : nombres et booléens

Entiers Réels Booléens Réels courts Entiers longs

Type int double boolean float long

Domaine -231 231-1 +/- 10308 true/false +/- 1038 -263 263-1

Exemples de constantes

178, -130.031, 10e-3, 37.266D, -3.01e3

true, false 87.363F 8864L


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Répéter un bloc d’instructions un certain nombre de fois

� Trois formes de boucles (en Java) :► boucle tant-que (while)

► boucle faire-tant-que (do-while)

► boucle pour (for)

� Équivalentes,mais adaptées à des cas différents

Instructions de boucle


Exemple : boucle tant-que

public class IntSquareRoot {


int x; // déclaration d'une variable entière

x = Input.readInt("Votre nombre ? "); // lecture de la

// valeur initiale

int i;

i = 1;

while ((i + 1) * (i + 1) <= x) { // tant qu'on n'a pas atteint

// la racine carrée de x

i = i + 1; // on incrémente i

}

System.out.print("La racine carrée entière est : ");

System.out.println(i);

}

}


� Permet d’exécuter un bloc d’instructionstant qu’une condition est vraie

� Exemple :

Boucle tant-que (while)

System.out.println("Compte à rebours : ");

int cpt;

cpt = 3;

while(cpt >= 0) {

System.out.println(cpt);

cpt = cpt-1;

}


► On commence par évaluer la condition, puis :� Si la condition est vraie, on exécute le bloc d'instructions

et on recommence au niveau de la condition (en 1)

� Si la condition est fausse, on « saute » le bloc d’instructionset on continue l’exécution après la boucle

While : fonctionnement

while (condition) {

i1;

…

in;

}

…

1

1

2

2

2’

2’

3

3


Bloc

Cond.

vrai

faux

Synthèse : while

while (condition) {

i1;

…

in;

}

…

Bloc d’instructions exécuté si et

tant que condition vraie

Condition


Exemple : jeu de Nim

Se joue à deux joueurs.

À tour de rôle, chaque joueurenlève 1, 2 ou 3 bâtons.

Le gagnant est celui quienlève le(s) dernier(s) bâton(s).


Exemple : boucle faire-tant-que…

while(nbBatons > 0) {

System.out.println("Nombre de bâtons restants : " + nbBatons);

System.out.println("C'est au tour du joueur " + joueur);

int choix; // Nombre de bâtons choisis par le joueur

do {

choix = Input.readInt("Combien de bâtons prenez-vous ?");

} while(choix < 1 || choix > 3 || choix > nbBatons);

nbBatons = nbBatons - choix; // Décompte des bâtons choisis

if(joueur == 1) { // Changement de joueur

joueur = 2;

} else {

joueur = 1;

}

}


� Permet d’exécuter systématiquement une première fois un bloc d’instructions, puis de le répéter tant qu’une condition est vraie

� Exemple :

Boucle faire-tant-que (do-while)


int cpt;

cpt = 3;

do {


cpt = cpt-1;

} while (cpt >= 0);


► On commence par exécuter le bloc d’instructions

► Puis on évalue la condition� Si la condition est vraie, on recommence au début

� Si la condition est fausse, on continue l’exécution après la boucle

Do-while : fonctionnement

do {

i1;

…

in;

} while (condition);

… 2

2

1

1

3

3’

3’

3


Bloc

Cond.

vrai

faux

Synthèse : do-while

do {

i1;

…

in;

} while (condition) ;

…

Bloc d’instructions exécuté

au moins une fois

puis tant que condition vraie

Condition


Retour sur la factorielle

int n; // déclaration de trois variablesint i; // pouvant contenir des entiers

int fact;

n = Input.readInt("n ?"); // lecture de n

i = 1; // initialisations : 1!=1

fact = 1;

while (i <= n) { // boucle de calcul incrémental

fact = fact * i; // fact = 1*1*2*3*…*i

i = i + 1; // incrémentation de i

}

System.out.println(fact); // affichage


Exemple : boucle pour

public class FactorialFor {


int n; // on veut calculer n!

n = Input.readInt("Votre nombre ?");

int fact; // variable pour le résultat

fact = 1;

for(int i = 1 ; i <= n ; i = i+1 ) {

fact = fact * i;

}

System.out.println(fact);

}

}


� Permet d’exécuter un bloc d’instructions tant qu’une condition est vraie, et une variable de contrôle estmise à jour à chaque itération► La variable de contrôle évolue à chaque tour de boucle

► Elle permet de contrôler le nombre de tours réalisés(≈ compteur)

� Exemple :

Boucle pour (for)


for (int cpt = 3 ; cpt >= 0 ; cpt = cpt-1) {


}


► On commence par initialiser la variablede contrôle

► Puis on évalue la condition� Si la condition est vraie, on exécute le bloc

d’instructions puis on met à jour la variablede contrôle, et on recommence en 1

� Si la condition est fausse, on continue l’exécution après la boucle

For : fonctionnement

for (init ; condition ; maj ) {i1;…in;

}…

1

1

0

0

3

2’

2’2

3

2

4

4


Bloc

Cond.

Init.

M.à.j.

vrai

faux

� L'instruction de mise à jour n'est pas obligatoirement une incrémentation ou une décrémentation

� Exemple :

For : forme moins courante

System.out.println("Quelques puissances de deux :");

for (int puiss = 1 ; puiss <= 100000 ; puiss = puiss * 2) {

System.out.println(puiss);

}


Synthèse : for

for (init ; condition ; maj ) {i1;…in;

}…

Bloc d’instructions exécuté tant quecondition vraie

Initialisation de la variable de contrôle

(affectation)

ConditionMise à jour de la

variable de contrôle

(affectation)


� On rencontre fréquemment :

� Idem pour les autres opérateurs arithmétiques :


Raccourcis pour l’affectation (1/2)

variable = variable + quantité;

variable += quantité;

somme += nb;

fact *= n;

solde –= debit + frais;

Formecourte

somme = somme + nb;

fact = fact * n;

solde = solde – (debit + frais);

� Encore plus fréquemment : l’incrémentation

� Idem pour la décrémentation (opérateur -)

� Exemples :

Raccourcis pour l’affectation (2/2)

variable = variable + 1;

variable ++;

x++;

y--;

Formecourte

x += 1;

y -= 1;

x = x+1;

y = y-1;


� Boucle tant-que (while) :► La condition est évaluée au début

► Le bloc n’est exécuté que si la condition est vraie

� Boucle faire-tant-que (do-while) :► Le bloc est exécuté systématiquement au moins une fois

► La condition est évaluée à la fin

� Boucle pour (for)► Le bloc est exécuté un nombre donné de fois

► La variable de contrôle est mise à jour à la fin de chaque tour

Synthèse : boucles


� A quel type de boucle correspondchaque schéma ?

Synthèse : boucles (bis)

Bloc

Cond.

vrai

fauxBloc

Cond.

vrai

faux

Bloc

Cond.

Init.

M.à.j.

vrai

faux


Synthèse : structures de contrôle

Besoin Nom de l’instruction

En Java ?

Sauter un groupe d’instructions

Conditionnelle if(condition) {…

} else {…

}

Répéter un groupe d’instructions

Boucle tant-que while(condition) {…

}

Boucle faire-tant-que do {…

} while(condition);

Boucle pour for(init; condition; maj) {…

}


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



Rappel : déclaration et affectation

type nomVariable;

nomVariable = expression;

Rappel :Affectation ≠ égalité !

Forme ?

1Évaluation de l’expression(calcul de la valeur)

Stockage du résultat2


valeur expr.nomVariable

� ≈ Expression mathématique → calculs

� Exemples :

� Peut être composée de :► Constantes (-5, 12.57839, 7, true…)

► Variables (x, monSolde…)

► Parenthèses

► Opérateurs

► Application de fonctions (f(x)…)

Expression

nouveauSolde = solde – base * 0.055 – (debit + frais);

z = (2.0 ∗ x − y ) / 5.2;

cpt = f(x) + y;

auComplet = auComplet && elevePresent(i);


Affectation et type d’une expression

type nomVariable;

nomVariable = expression;

L’expression doit êtrede même type que la variable

ou doit pouvoir êtreconvertie dans ce type

Type ?


� Toute expression a un type :le type du résultat du dernier opérateur à être appliqué

� Exemples :int i;

double d;

3 ⇨ int

i * 3 ⇨ int

4.5 ⇨ double

(4.5 + d) * 3.1 ⇨ double

d - 1 ⇨ ???

i / d ⇨ ???

Type d'une expression

double

Lorsque le contexte l'impose, le type int

est implicitement convertien double


� Avec les déclarations suivantes :

� On écrit :

Affectation et type

Conversion sans risque → implicite

Interdit :risque de perte d’information

double solde;

double debit;

double credit;

int i;

i = 1;

solde = credit – debit;

i = i * 3;

i = i + 1;

solde = i;

i = solde;


� Conversion explicite de typepour aller dans le sens d'une perte d'information

� Écriture : (nomDeType) expression

� Exemples :int i = 5;

double d = 7.0;

d = i + 1; // conversion implicite

i = (int)(d + 1); // transtypage nécessaire

Transtypage


� Deux types de base pour les nombres : int et double

� Opérateurs arithmétiques► Opérandes de type int et/ou double

► Conversion implicite du type des opérandes si besoin et uniquement lorsque pas de perte d'information

► Type d'une expression =type du résultat du dernier opérateur appliqué

� Conversions de type ► Conversion implicite si pas de perte d'information

► Transtypage pour forcer explicitement une conversion

Synthèse : nombres et types

int ⇨ double double ⇨ int

int variable = (int)4.5487;


� Types prédéfinis (rappel)

� Type des expressions► Dépend du dernier opérateur appliqué

► Peut être converti explicitement (transtypage) : (type)expression

Synthèse : types de données et expressions


Entiers Réels Booléens Réels courts Entiers longs

Type int double boolean float long

Domaine -231 231-1 +/- 10308 true/false +/- 1038 -263 263-1

Exemples de constantes

178, -130.031, 10e-3, 37.266D, -3.01e3

true, false 87.363F 8864L

Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Exemple :

� Représentation par un tableau

Suites de valeurs

double note1;double note2;double note3;…

note1 = 12.5;note2 = 15.0;note3 = 8.0;note4 = 18.5;…

12.5 15.0 8.0 18.5 …notes =

n°1 n°2 n°3 n°4


� Ensemble fini de variables de même type repérées par des indices

� Ces variables s’appellent éléments de tableau

� Tableau utilisé en général comme conteneur d’informations ayant plusieurs composantes(vecteurs, matrices, …)

Tableau : définition

0 1 i n-1

élément du tableau

3.7

indice


� Un tableau occupe une certaine zone mémoire

� Il peut-être désigné par une ou plusieurs variables

� Ces variables sont des références au tableau ;elles ne contiennent pas le tableau lui-même

Tableau et référence

Tableau de5 éléments :

occupe 5 « tiroirs »en mémoire

Variable de type tableau : 1 tiroir qui contient

le numéro du premier tiroir du tableau⇒ Référence


réf.

� Déclaration d'une variable de type (référence à un) tableau► On indique le type des éléments

► La variable peut alors désigner un tableau, mais aucun tableau n'a encore été créé !

� Création d'un tableau : opérateur new► On indique le type des éléments et la taille

► On affecte en général le tableau à une variable

� Notation abrégée :

Déclaration et création d'un tableau

Tableau de taille 4

double[] notes = new double[4];

double[] notes;

notes = new double[4];


réf.

notes @

Déclaration et création de tableau : en détails

2Création d’un tableau (allocation de mémoire) de 50 cases de type double à 1 dim.

Affectation de la référence à la variable notes

3

double[] notes;

notes = new double[50];

Déclarationnotes : variable de type référence à un tableau de double à 1 dim.


1

� Lors de la création du tableau, une valeur par défautest donnée à chacun des éléments du tableau► Pour les entiers : 0

► Pour les réels : 0.0

► Pour les booléens : false

� Il est possible de créer un tableau avec des valeurs définies

Valeurs initiales dans un tableau

double[] notes = new double[] {12.0, 18.5, 6.5, 10.0};


double[] notes = new double[4];

0.0 0.0 0.0 0.0@réf.

notes

12.0 18.5 6.5 10.0@réf.

notes

� Accès à un élément du tableau avec tab[indice]► Exemple :

� Parcours avec des boucles en utilisant la taille tab.length► Exemple :

Utilisation des tableaux

System.out.println(notes[1]); // affiche 18.5

notes[3] = 11.0; // modifie l'élément d'indice 3


12.0 18.5 6.5 10.0@réf.

élément du tableaunotes[1]

indice

0 1

14.0 3.0 0.0 20.0

i n-1

taille nnotes.length

for (int i = 0; i < notes.length; i++) {notes[i] = notes[i]/2;

}

notes

Affectation et tableaux

@ 0 0 0 0 0 0 0 0réf.

int[] tabA = new int[nbCol];

int[] tabB = new int[nbCol];

tabA[1] = 3;

tabB = tabA;

tabB[1] = 7;


tabA


0 0 0 0 0 0 0 0réf.

0 0 0 0 0 0 0 0réf.



tabA[1] = 3;

tabB = tabA;

tabB[1] = 7;


@tabA

@tabB


0 3 0 0 0 0 0 0réf.

0 0 0 0 0 0 0 0réf.



tabA[1] = 3;

tabB = tabA;

tabB[1] = 7;


@tabA

@tabB


⇒ Synonymie !



tabA[1] = 3;

tabB = tabA;

tabB[1] = 7;

0 3 0 0 0 0 0 0réf.

0 0 0 0 0 0 0 0


@tabA

@tabB


Orphelin : sera détruitpar le ramasse-miettes

0 7 0 0 0 0 0 0réf.

0 0 0 0 0 0 0 0



tabA[1] = 3;

tabB = tabA;

tabB[1] = 7;


@tabA

@tabB

� Tableau désigné par une référence stockée dans une variable► Accès aux éléments du tableau par leurs indices :

► Accès à la taille du tableau :

� Déclaration de variable et création de tableau

� Affectation

Synthèse : tableaux (1 dimension)

double[] tabDouble;

tabDouble = new double[12];

for (int i = 0; i < tabInt.length; i++) {

tabInt[i] = 7849387;

}

tabDouble[6] = 3.85;

System.out.println(tabDouble[6]);

monTab[i]

monTab.length

int[] tabInt = new int[45];


� Problèmes d'indices :► La numérotation des éléments commence à 0

et termine à « tab.length - 1 » !

� Problèmes d'affichage :► Afficher la variable qui référence le tableau c'est afficher

l'adresse en mémoire du tableau…


Erreurs fréquentes avec les tableaux

int[] t = new int[2];

t[2] = 10;

t : [I@5f893efet[1] : 10

int[] t = new int[2];t[1] = 10;System.out.println("t : "+t);System.out.println("t[1] : "+t[1]);

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException : 2

� Extension de ce qui précèdeSyntaxe : à chaque dimensioncorrespond une paire de crochets []

� Lors de la déclaration, indiquer► Le type des éléments

► Le nombre de dimensions

� Lors de la création, indiquer► Le type des éléments

► Les tailles de chaque dimension

Tableaux à plusieurs dimensions

Vecteur (1 dimension)

Taille de la 1ère

dimension : 5

Taille de la 2è

dimension : 3

Taille de la dimension : 4

Matrice (2 dimensions)

0 0 0

0

0 0

0

0

0

0

0

0

0

0

0


int[][] monTableau2D;

monTableau2D = new int[5][3];

Exemple : tableau à 2 dimensions

int[][] monTableau2D; // déclaration

monTableau2D = new int[5][3]; // création

// affectation d'un élément

monTableau2D[2][1] = 7;

// parcours selon la 1ère dimension

for(int dim1 = 0; dim1 < monTableau2D.length ; dim1++) {

System.out.print("(");

// parcours selon la 2è dimension

for(int dim2 = 0; dim2 < monTableau2D[dim1].length ; dim2++) {

System.out.print(monTableau2D[dim1][dim2]);

}

System.out.println(")");

}

Taill

e 1

ère

dim

ension

: 5

0 0 0

0

0 0

7

0

0

0

0

0

0

0

0

Taille 2e dimension : 3


Un tableau à 2 dimensions est en fait un tableau de tableaux...

Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Cas n°1 : soit un tableau contenant les notes d'un groupe d'élèves dans une matière donnée. On souhaite calculerla moyenne, le minimum et le maximum.

� Cas n°2 : soit un ensemble de tableaux contenant les notes de tous les groupes d'élèves de la promo dans une matière donnée. On souhaite :► Calculer la moyenne, le minimum et le maximum

de l'ensemble de la promo

► Calculer la moyenne, le minimum et le maximumde chaque groupe

Pourquoi des fonctions ?


� Même concept qu'en mathématiques :► Donne un résultat en fonction de paramètres

► Eventuellement pas de paramètre, pas de résultat

� 2 facettes des fonctions : (1) la déclaration, (2) l'utilisation

� Exemples déjà vus :► Math.sqrt(x) ⇨ rend racine carrée de x

► Input.readInt() ⇨ rend nombre saisi au clavier

► System.out.println(x) ⇨ affiche valeur x à l'écran, ne rend rien

Fonctions : définition


1. Déclaration

2. Utilisation (appel)

3. Cas particuliers

4. Organisation d'un programme avec fonctions

5. Transmission des paramètres

6. Fonctions récursives

7. Signature


Fonctions

Déclaration de fonction

carre : ℤ → ℤx ↦ x × x

static int carre (int x) {

return x*x;

}

Mat

hsJa

va




Nom de la fonction


return x*x;

}

Mat

hsJa

va



carre : ℤ → ℤx ↦ x × xM

aths

Java


return x*x;

}

Paramètres formels





return x*x;

}

Ensemble de départ

Type du paramètre

Mat

hsJa

va





return x*x;

}

Ensemble de destination

Type du résultat

Mat

hsJa

va





return x*x;

}

Résultat de la fonction appliquée

au paramètre formel

Mat

hsJa

va


� Exemple :

Déclaration : forme générale

static typeResultat nomFonction (type1 param1, …, typen paramn) {


…

return valeurResultat;

} L'instruction return :

1. Indique quel est le résultat de la fonction

2. Met fin immédiatement à l'exécution de la fonction

static double computeInterests (double amount, double rate) {

double interests;

interests = amount * rate;

return interests;

}


� Importance de l'instruction return :► Une fonction calculant un résultat doit toujours se finir par

l'exécution de l’instruction return avec une valeurdans tous les chemins d'exécution possibles

► C'est la toute dernière instruction exécutée d’une fonction

� Exemple :

Return

static double computeInterests (double amount) {

if(amount > 150000.0) {

return amount * 0.025;

} else {

return amount * 0.035;

}

}


1. Déclaration


3. Cas particuliers




7. Signature


Fonctions

Fonction

Utilisation d'une fonction (« appel »)

int x = …;……int y = abs(x) * 2;……

static int abs(int n) {if(n >= 0) {

return n;} else {

return -n;}

}Valeur :paramètre effectifex : -3

Le paramètre formel prend la valeur du paramètre effectifex : n vaut -3

3

Programme principal


� Discriminant d'un trinôme :

� Appel possible :

Exemple de fonction : discriminant


double discr;

discr = discriminant(1.5, 4.0, 5.0/3);

// discr vaut 6.0

}

static double discriminant(double a, double b, double c){

return b*b - 4*a*c;

}


� Le plus petit de deux entiers :

� Appel possible :

Exemple de fonction : minimum

static int min(int a, int b) {if (a < b) {

return a;}return b;

}


int i;

i = 4;

i = min(3, i+1); // i vaut alors 3

i = -3;

i = min(3, i+1); // i vaut alors -2

}


1. Déclaration


3. Cas particuliers




7. Signature


Fonctions

� Fonction sans paramètre

► Actions qui ne réalisent pas de calcul sur les paramètres► Exemple :

� Fonction sans résultat

► Actions qui ne calculent pas de résultat en retour► Exemple :

Fonctions : cas particuliers

Maths Java

« f : ∅ → ℝ » static double maFonction () { … }

Maths Java

« f : ℝ → ∅ » static void maFonction (double c) { … }

Input.readDouble(), Math.random()

System.out.println("Bonjour");


� Pas de résultat⇒ return n'est pas suivi d'une valeur⇒ return sert juste à mettre fin à la fonction

� Exemple :

� Dans ce cas seulement return peut être omis :fin implicite lorsqu'on rencontre l'accolade de fin

Return dans une fonction sans résultat

static void f() {

…

if(condition) {

return;

}

}


� Déclaration de fonctions avec et sans résultat

� Appel de fonctions avec et sans résultat

Synthèse : déclaration et appel de fonctions

static void g(…){… instructions …

}

static int f(…){… instructions … return resultat;

}

Return explicite obligatoire

Return explicite optionnel

double variable;variable = 2.71;g(variable);

int variable;variable = f(4) – 12;

Utilisation dans une expression

(attention au type)Instruction en soi


1. Déclaration


3. Cas particuliers




7. Signature


Fonctions

� C'est une fonction sans résultat !

� Exécuter un programme, c'est exécuter la fonction dont le nom est main

Programme principal... ?




}

}


� Fonctions déclarées les unes sous les autres dans class

� Impossible de les imbriquer !

Où placer la définition d'une fonction ?

public class TraitementDeDonnees {

public static void main(String[] args) {while(donneePrete()) {

traiterDonnee();

}}

public static boolean donneePrete() {...

}

public static void traiterDonnee() {...

}}


Exemple : nombres premiers


public class PrimeOrNot {

static boolean isPrime(int n){for(int i=2; i<n; i++) {

if(n % i == 0) { // si n connait au moins un diviseurreturn false; // alors n n'est pas premier

}}return true; // si n ne connait aucun diviseur,

// il est premier !}

public static void main(String[] args) {int u = Input.readInt("Enter a number:");System.out.println("Is this number a prime ? "+isPrime(u));

}

}

1. Déclaration


3. Cas particuliers




7. Signature


Fonctions

� En Java, les paramètres sont transmis par valeur :paramètre formel = copie du paramètre effectif

� Exemple :

� Modification uniquement du paramètre formel→ aucune influence sur le paramètre effectif

Transmission de ses paramètres à une fonction

static void compute() {int a, b;…a = 5;b = twice(a);…

}

5

static int twice(int x) {

x *= 2;

return x;}

5

10

Copie1

Copie3

Calcul sur x2

10


a

b

x

x

� La référence est bien recopiée (transmission par valeur), mais pas le tableau qu'elle désigne :

☛ c'est le tableau d'origine qui est modifié

� Ce sera la même chose pour tous les types objets

36

static void twice(int[] t) {

…

t[i] *= 2;

…

}

Transmission d'une référence à un tableau

@

0 0 0

réf.

static void compute() {…int[] tab = new int[4];tab[2] = 3;twice(tab);…

}

@

réf.


tab t

Copie

1

Modification dutableau d'origine !

2

1. Déclaration


3. Cas particuliers




7. Signature


Fonctions

� Une définition de la factorielle :

� Reprise du premier exemple du cours

� Solution « itérative » : la boucle for itère sur les entiers

Exemple de fonction : factorielle

static int fact(int n) {int resultat = 1;

for (int k = 1; k <= n; k++) {resultat *= k;

}

return resultat;}


� Définition de la fonction à partir d'elle-même : récursive

� Traduction directe en Java :

Autre définition de la factorielle : récursive

static int fact(int n) {if (n <= 0) {

return 1;}return n * fact(n – 1);

}


� Identifier :► Schéma récursif – autoréférence

(utilisation de la fonction pour son propre calcul)

► Mécanisme de décroissance

► Cas terminal, critère d'arrêt

� Parfois une formulation mathématique récursive existe déjà

Définition d'une fonction récursive

static int fact(int n) {

if (n <= 0) {

return 1;

}

return n * fact(n – 1);

}


� Déterminer le nombre de chiffres d'un entier n écrit en base 10 (longueur)

� Algorithme (on suppose n ≥ 0) ?► Si n < 10 : la longueur est 1

► Sinon : la longueur est 1 + longueur(n/10)

� En Java :

Exemple : longueur d'un entier

Cas terminal

Schéma récursifavec décroissance

static int longueur(int n) {

if(n < 10) {

return 1;

} else {

return 1 + longueur(n/10);

}

}


Exemple : appel de longueur(1789)


Appel d'une fonction récursive

longueur(1789)

longueur(178)

longueur(17)

longueur(1) 1

2

3

4

static int longueur(int n) {

if(n < 10) {

return 1;

} else {

return 1 + longueur(n/10);

}

}

Exécution de longueur(1789)

1789n


178n


17n


1n

1. Déclaration


3. Cas particuliers




7. Signature


Fonctions

� Que se passe-t-il lorsqu'on écrit f(5.5) ?► Java infère de cette expression une signature de fonction

► Signature = nom de fonction + type des arguments

► Java cherche une méthode avec une signature compatible

Ce n'est pas le nom seul qui compte !

� Exemple► f(5.5) a pour signature f(double)

► S'il existe la fonction : static void f(double x) { … } ?

► S'il existe la fonction : static void f(int x) { … } ?

Signature des fonctions

��


� Une fonction n'est donc pas recherchée par son nom uniquement mais par sa signature complète

� Il est donc possible d'avoir des fonctions homonymes :► Ces fonctions doivent avoir un nombre ou des types

d’arguments différents → signatures différentes

► Lors d'un appel de fonction, la fonction à exécuter est choisie d’après les arguments (nombre, types)

� On parle de surcharge (« function overloading »)

Fonctions homonymes


public class Interests {

static double computeInterests (double amount, double rate) {return amount * rate;

}

static double computeInterests (double amount) {if(amount > 150000.0) {

return amount * 0.025;} else {

return amount * 0.035;}

}

}

Exemple : fonctions homonymes


Signature :computeInterests (double, double)

Signature :computeInterests (double)

Noms identiques,mais signatures différentes !

1. Déclaration


3. Cas particuliers




7. Signature


Fonctions

Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



Fonction 1

Fonction 2

Fonction n

public class NomProgramme {


…

}

static int fact(int n) {

…

}

static double racine(double x) {

…

}

…

}

Rappel : structure d’un programme Java

Il faut une fonction main


Les fonctions se placentles unes

en dessousdes autres

Fichier NomProgramme.java

Fonctions dans des fichiers différents ?


public class Primes {

static boolean isPrime(int n) {for (int i = 2; i < n; i++) {

if (n % i == 0) { return false;

}}return true;

}

}

Fichier Primes.java

public class Test {

public static void main(String[] args) {int u = Input.readInt("Enter a number:");

System.out.println( Primes.isPrime(u) );

}

}

Fichier Test.java

Pour appeler la fonction,on fait précéder l'appel

du nom du fichier (= nomde la classe) suivi d'un .

� Java dispose d'une bibliothèque de fonctions prédéfinies► Une telle bibliothèque est appelée API

(Application Programming Interface)

► Documentation :http://docs.oracle.com/javase/7/docs/api/

� Exemples :► Mathématiques : Math.fonction(…)

► Tableaux : Arrays.fonction(…)

Fonction prédéfinies

double randomNumber = Math.random(); // attention : [0,1]

double squareRootX= Math.sqrt(…); // + cbrt

… = Math.abs(…);

double cosX = Math.cos(…); // + sin, tan, acos…

double lnX = Math.log(…); // + log10, exp…

String text = Arrays.toString(…);


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



public class CompositeInterests {

// intérêts obtenus sur une période d'épargnestatic double onePeriodInterests(double amount) {return amount * 0.025;

}

// nombre de périodes d'épargne nécessaires static double periodNumber(double initAmount, double finalAmount) {return Math.log(finalAmount / initAmount) / Math.log(1 + 0.025);

}}

► Quelles modifications faut-il apporter lorsque le taux des intérêts change ?↳ Il faut rechercher la valeur et la modifier

dans toutes les fonctions…


Pourquoi utiliser des constantes ?


static final double RATE = 0.025;

// intérêts obtenus sur une période d'épargnestatic double onePeriodInterests(double amount) {return amount * RATE ;

}

// nombre de périodes d'épargne nécessaires static double periodNumber(double initAmount, double finalAmount) {return Math.log(finalAmount / initAmount) / Math.log(1 + RATE);

}

}

Exemple d'utilisation d'une constante


Pour modifier le taux dans toutesles fonctions, il suffit de modifier

la valeur de la constante !

� Donner du sens à une constante ➞ lui attribuer un nom► Mot clé Java : final

► Exemple : final int ZERO = 0;

� Attacher une constante à une classe pour pouvoiry accéder depuis d'autres classes► Mot clé Java : static

� Exemple de constante de classe :


Constantes

public class Trigo {

static final double PI = 3.1416;…

} Utilisation : Trigo.PI

Convention :nom de la constante

en majuscules

Le mot clé static « attache »les fonctions et les constantesà la classe ☛ pour les utiliser :

nom de la classe suivi de .


static final double RATE = 0.025;

// intérêts obtenus sur une période d'épargnestatic double onePeriodInterests(double amount) {return amount * RATE;

}

// nombre de périodes d'épargne nécessaires static double periodNumber(double initAmount, double finalAmount) {return Math.log(finalAmount / initAmount) / Math.log(1 + RATE);

}

}

Sur notre exemple


public class Test {public static void main(String[] args) {

System.out.println( CompositeInterests.periodNumber(1000, 1500) );

System.out.println( CompositeInterests.RATE );

}}

Fichier Test.java

� Il existe de nombreuses constantes prédéfiniesdans l'API Java

� Exemples :► Mathématiques :

► Entiers :

► Réels :

► Couleurs :


Constantes nommées prédéfinies

Math.PI

Math.E

Integer.MAX_VALUE // 2^31-1Integer.MIN_VALUE // -2^31

Double.POSITIVE_INFINITY // +∞Double.NEGATIVE_INFINITY // -∞Double.NaN // "Not a Number"

Color.BLACKColor.RED…

Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Pour organiser le code, il est possible de regrouper plusieurs classes (≈ fichiers) dans un package (≈ dossier)


Packages

utils

Primes.javaPrimes.javaPrimes.java

package utils;

public class Primes {static boolean isPrime(int n) {…

}}

Le fichier .javadoit être placédans le dossier

Le nom du package doit être indiqué tout en haut de la classe,

précédé du mot clé packageet

� Pour pouvoir utiliser une fonction d'une classe qui se trouve dans un package à partir d'une classe qui se trouve dans un autre package1. La fonction doit être explicitement indiquée comme publique

2. Il est nécessaire d'importer la classe


Visibilité

public static boolean isPrime(int n) {…

}

utils

Primes.javaPrimes.javaPrimes.java

test

Test.java

import utils.Primes;

Nom du package suivi de .puis du nom de la classe

� D'où une fonction est-elle visible ?

► Exemple : visibilité des fonctions se trouvant dans MaClassesi privées, si sans qualificateur, si publiques


Qualificateurs de visibilité

Qualificateur La classe Le package Les autres packages

public ✓ ✓ ✓rien ✓ ✓private ✓

package

Primes.javaPrimes.javaMaClasse.java

autrePackage

Primes.java

AutreClasse.java

Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes


III. Approche objet

1. Introduction


3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Problème :► Soit un ensemble de nombres complexes

► Donner un nombre dont la norme est minimale(le premier si plusieurs atteignent le minimum)

► Si ensemble vide, renvoyer 0 + 0i (convention)

� Ensemble de valeurs → tableau

� Mais comment représenter un tableau de complexes ?

Exemple : manipulation de nombres complexes


static double[] minimum(double[] reelles, double[] imaginaires) {

double reMin = 0;

double imMin = 0;

double normeMin = Double.POSITIVE_INFINITY;

for(int i=0; i<reelles.length; i++) {

double re = reelles[i];

double im = imaginaires[i];

double norme = Math.sqrt(re*re + im*im);

if(norme < normeMin) {

reMin = re;

imMin = im;

normeMin = norme;

}

}

return new double[] { reMin, imMin };

}

Idée 1 : deux tableaux

��

�

Multiplication des arguments

Rien ne garantit que les deux tableaux auront la même taille

Pour la valeur résultat on doit utiliser un tableau


Idée 2 : un tableau à deux dimensions

static double[] minimum(double[][] nombres) {

double min[] = new double[] { 0, 0 };


for(int i=0; i<nombres.length; i++) {

double[] z = nombres[i];

double norme = Math.sqrt(z[0] * z[0] + z[1] * z[1]);


min[0] = z[0];

min[1] = z[1];

normeMin = norme;

}

}

return min;

}

� Convention non explicite :→ risque d'erreurs→ peu lisible

Pour la valeur résultat on doit toujours utiliser un tableau

�

�


� Un type « nombre complexe »

� Que doit contenir une variable de type Complexe ?► Partie réelle

► Partie imaginaire

� Un Complexe sera un objet avec deux attributs

Ce qu'il nous faut...

static Complexe minimum(Complexe[] nombres) {...

}

Ces deux valeurs définissent entièrementun nombre complexe


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Objectif : définir un nouveau type de données

� Une classe = un moule servant à créer des objets d'une certaine sorte

� Une classe ↔ un fichier .java qui porte le nom de la classe

Création d'un type d'objet = une classe

class Complexe {double reel;double imag;

}

Nom de la classe= nom du type

Déclaration d'un attributMême forme que la

déclaration d'une variable

Tous les attributs ne sont pas forcément du

même type...


Écriture de la fonction minimum

static Complexe minimum(Complexe[] nombres) {

Complexe min = new Complexe();

min.reel = 0;

min.imag = 0;



Complexe z = nombres[i];

double norme = Math.sqrt(z.reel * z.reel + z.imag * z.imag);


min = z;

normeMin = norme;

}

}

return min;

}

Création d'un objetAccès aux

attributs


� Déclarer une classe = créer un type d'objets► La classe est le moule à construire les objets : elle définit

les attributs que possèdent les objets de ce type

► Chaque objet a ses propres valeurs d’attributs

� Construire un objet = créer une instance d'une classe

� Utiliser un objet = utiliser ses attributs

Bilan à ce stade

public class NomClasse {…

Type nomAttribut;…

}

NomClasse unObjet = new NomClasse();

Accès aux attributs d'une instance

unObjet.nomAttribut = … ;


Exemple récapitulatif


public class Complexe {

double reel;double imag;

}

Fichier Complexe.java

public class Test {


Complexe c = new Complexe();c.reel = 3.0;c.imag = 5.0;

System.out.println(c.reel); // affiche 3.0}

}

Fichier Test.java Programme principal

Classe définissantle nouveau

type Complexe

Instanciation d'un objet de type Complexe

� Comme pour les tableaux, les variables de type objet sont des références vers un objet

Référence vers un objet

Objet en mémoire : « 1 tiroir par attribut »

a

Variable de type objet : 1 tiroir qui contient le

numéro du premier tiroirde l'objet

⇒ Référence

Complexe a;a = new Complexe();

Complexe b =new Complexe();

.reel .imag

.reel .imag

b


Affectation d'objet : fonctionnement

Construction d'une instance de la classe (allocation mémoire)

Affectation de la référence à la variable z

Déclarationz : variable de type Complexe

(référence à une objet instance de la classe Complexe)

Complexe z;z = new Complexe();


1

2

3

Affectation d'objet

Complexe a = new Complexe();a.reel = 3;Complexe b = a;b.imag = b.reel * 2;@ .reelréf.

.imag

0.0

0.0


a

Affectation d'objet

Complexe a = new Complexe();a.reel = 3;Complexe b = a;b.imag = b.reel * 2;

.reelréf.

.imag

3.0

0.0


@a

Affectation d'objet

réf.

Deux références sur le même objet


.reelréf.

.imag

3.0

0.0


@a

@b

Affectation d'objet

.reelréf.

.imag

3.0

6.0

réf.



@a

@b

� Valeur spéciale pour les références : null► Ne désigne aucun objet

► Utilisable aussi pour les variables de tableaux

� Poursuite de l'exemple :

Référence null

Complexe a = new Complexe();a.reel = 3;Complexe b = a;b.imag = b.reel * 2;a = null;

.reelréf.

.imag

3.0

6.0

réf.


@a

@b

� Valeur spéciale pour les références : null► Ne désigne aucun objet

► Utilisable aussi pour les variables de tableaux

� Poursuite de l'exemple :

Référence null

réf.

Complexe a = new Complexe();a.reel = 3;Complexe b = a;b.imag = b.reel * 2;a = null;

.reel

.imag

3.0

6.0

réf.


nulla

@b

� Lorsque la dernière référence sur un objet disparaît, cet objet ne peut plus être utilisé

� Le ramasse-miettes recycle la mémoire pour réutilisation

� (Triste) fin de l'exemple :

Ramasse-miettes (garbage collector)

.reelréf.

.imag

3.0

6.0

Objet orphelin : sera détruitpar le ramasse-miettes.reel

.imag

0.0

0.0

réf.

Complexe a = new Complexe();a.reel = 3;Complexe b = a;b.imag = b.reel * 2;a = null;b = new Complexe();


nulla

@b

Meilleure fonction minimum grâce à null

static Complexe minimum(Complexe[] nombres) {Complexe min = null;


for(int i=0; i<nombres.length; i++) {Complexe z = nombres[i];double norme = Math.sqrt(z.reel * z.reel + z.imag * z.imag);if(norme < normeMin) {

min = z;normeMin = norme;

}}

return min;}


Renvoie null si tableau vide(0 élément)

� Que se passe-t-il si on exécute ce code ?

� « Exception » = erreur d'exécution :

« Bug » fréquent

Complexe z = null; System.out.println(z.reel);

nullréf.

Exception in thread "main" java.lang.NullPointerExceptionat Test.main(Test.java:48)

Prendre l'attribut reel de l'objet pointé par la référence z


z

� Une variable peut contenir une référence vers un tableau ou un objet, mais elle ne contient pas le tableau ou l'objet lui-même

� Un tableau ou un objet est créé grâce à l'opérateur new

� Un tableau ou un objet dispose de sa propre zone mémoire

� Un tableau ou un objet qui n'est plus référencé par aucune variable est détruit automatiquement (ramasse-miettes)

� Une variable référence peut valoir null► Elle ne désigne alors aucun tableau ou objet

► Toute tentative d'accès au contenu du tableau ou objet supposé (qui en fait n'existe pas !) génère une erreurNullPointerException

Synthèse : références et tableaux/objets


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Un constructeur est une sorte de fonction associée à la classe, qui initialise l'état d'un objet à sa création

� On n'a pas créé explicitement de constructeur dans la classe complexe, pourtant on peut créer des objets ?► Java crée un constructeur par défaut sans argument

► Risque : oublier d'initialiser certains attributs

⇒ On devrait toujours créer explicitement un constructeur

Construction des objets

Complexe a = new Complexe();a.reel = 3;b.imag = 5;

Utilisation du constructeur par défaut


� Un constructeur ressemble à une fonction mais :► Même nom que la classe

► Pas static

► Pas de type résultat

Forme du constructeur

public class Complexe {double reel;double imag;

Complexe(…) {……

}}

Nom → celui de la classe

Pas staticPas de type résultat

Paramètres ?Corps ?


� Pour créer un nombre complexe, il serait raisonnable et pratique d'indiquer sa partie réelle et sa partie imaginaire lors de la construction

Un constructeur pour la classe Complexe


Complexe(double r, double i) {……

}}

Paramètres : parties réelles et imaginaires du

complexe à créer

Corps : « l'attribut réel de l'objet en cours de création doit prendre

la valeur r (affectation) ... »


� « L'attribut reel de l'objet en cours de création doit prendre la valeur r (affectation) »► instanceEnCoursDeCreation.reel = r;

� Mot-clé this :► Référence sur l'objet en cours de création ou de manipulation

(dit « objet courant »)

► S'utilise comme une variable

� Sur l'exemple :

Manipuler l'objet « courant »

???

Complexe(double r, double i) {this.reel = r;…

}


0.03.0

this

…

Complexe a = new Complexe(3,5);

…

.reelréf.

.imag 0.0

…

Complexe(double r, double i) {

this.reel = r;

this.imag = i;

}

appelavec r = 3

et i = 5

Classe Complexe

Programme principal

réf.

5.0


@a @ this

� Classe avec constructeur complet :

� Utilisation :

Récapitulatif


Complexe(double r, double i) {this.reel = r;this.imag = i;

}}

Complexe z = new Complexe(3, 5);

Déclaration des attributs

Constructeur :affectation des

attributs


� Pas d'ambiguïté entre le nom des arguments et le nom des attributs (toujours préfixés de this)

� On peut donc écrire :

Attributs et arguments


Complexe(double reel, double imag) {this.reel = reel;this.imag = imag;

}} Argument du constructeurAttribut

même nom


� Constructeur : fonction spéciale qui initialise un objet► Porte le nom de la classe

► Pas de type résultat, pas static

� Si aucun constructeur défini explicitement, Java créeun constructeur par défaut sans argument

� new NomClasse(paramètres)

► Réserve un espace mémoire pour un objet instancede la classe NomClasse� Par défaut les attributs de l'objet sont alors initialisés à 0/0.0/false/null

► Appelle le constructeur (qui initialise alors les attributsavec les valeurs passées en paramètre)

Synthèse : construction d'objets





double reel;double imag;


}

}

Fich

ier

Com

ple

xe.ja

va

public class Test {

public static void main(String[] args) {Complexe c = new Complexe(3.0, 5.0);System.out.println(c.reel); // affiche 3.0

}

}Fich

ier T

est.j

ava

Classe définissant le type Complexe, avec constructeur permettant d'initialiser les

attributs des objets

Instanciation d'un objet de type Complexeet affichage de sa partie réelle

Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Extrait :

� Quelle idée devrait-on avoir ?► Créer une fonction normeComplexe

Retour sur le programme de départ

double norme = Math.sqrt(z.reel * z.reel + z.imag * z.imag);if(norme < normeMin) {

...}


► Mais on aimerait pouvoir demander sa norme à un nombre complexe de la même manière qu'on peut lui demander sa partie réelle ( ) ou sa partie imaginaire ( )…

� Programmation objet :► Regrouper données et opérations au sein de la classe

► Les fonctions deviennent des méthodes,c'est-à-dire des services proposés par un objet

Quelque-part dans un programme...

static double normeComplexe(Complexe z) {return Math.sqrt(z.reel * z.reel + z.imag * z.imag);

}…

Complexe c = new Complexe(3,5);System.out.println(normeComplexe(c));


c.reel c.imag

� Presque identique à une définition de fonction mais :► Pas de static

► On travaille sur une instance de la classe, accessible via this

Définition de la méthode norme



}

double norme() {return Math.sqrt(this.reel * this.reel +

this.imag * this.imag);}

}


Utilisation de la méthode norme

static Complexe minimum(Complexe[] nombres) {

Complexe min = null;



Complexe z = nombres[i];

double norme = z.norme();


min = z;

normeMin = norme;

}

}

return min;

}


� Et comme pour les fonctions :► Si la méthode rend un résultat, le return est obligatoire

► Sinon (si typeRendu est void), le return peut être omis

Déclaration d’une méthode

Seule l'absence de static la distingue d'une déclaration

de fonction

public class NomClasse {

…

typeResultat nomMethode (type1 param1, …, typen paramn) {


return valeurResultat;

}

…

}


Utilisation d'une méthode


double reel;

double imag;

double norme() {

return Math.sqrt(

this.reel * this.reel

+ this.imag * this.imag);

}

}

Dans ce contexte, le même objet s'appelle this (objet courant)

…


… z.norme();

…

3.0@ .reelréf.

.imag 4.0

@réf.

L'objet Complexe s'appelle z ici, on lui demande un service


z this





}

double norme() {return Math.sqrt(this.reel * this.reel + this.imag * this.imag);

}}

Fich

ier

Com

ple

xe.ja

va

public class Test {

public static void main(String[] args) {Complexe c = new Complexe(3.0, 5.0);System.out.println(c.norme()); // affiche 5.830951894845301

}

}Fich

ier T

est.j

ava

Classe définissant le type Complexe, avec constructeur

et méthode permettant d'obtenir la norme d'un complexe

Instanciation d'un objet de type Complexeet affichage de sa norme

� Ajouter à Complexe une méthode qui indique si le nombre est sur le cercle unité : norme = 1 ?► Comment une méthode peut-elle appeler une autre méthode

sur la même instance ?

Méthode appartientAuCercleUnite


double reel;

double imag;

double norme() {

return Math.sqrt(this.reel * this.reel + this.imag * this.imag);

}

boolean appartientAuCercleUnite() {

return this.norme() == 1;

}

}


Utilisation d'une méthode (suite)


double reel;

double imag;

double norme() {

return Math.sqrt(...);

}

boolean appartientAuCercleUnite() {

return this.norme() == 1;

}

}

Dans ce contexte, le même objet s'appelle this (objet courant)

…


… z.appartientAuCercleUnite();

…

L'objet Complexe s'appelle z ici, on lui demande un service


3.0@ .reelréf.

.imag 4.0

@réf.

z this

� On appelle (invoque) une méthode, sur une instance de la classe qui contient la définition de la méthode :il faut disposer d'une référence sur cette instance

� Exemples :► Avec l'objet « courant » :

► Avec un objet quelconque :

Synthèse : appel d'une méthode

… this.methode(…) …

UneClasse refObjet = new UneClasse();

… refObjet.methode(…) …

… reference.methode(…) …


� Ajouter à la classe Complexe une méthode qui ajoute un complexe donné au complexe courant

Exercice


� Ajouter à la classe Complexe une méthode qui ajoute un complexe donné au complexe courant

� Utilisation (dans main) :

Exercice

public class Complexe {double reel;double imag;... void ajoute(Complexe autre) {

this.reel += autre.reel;this.imag += autre.imag;

}...

}


Complexe zero = new Complexe(0,0);Complexe deux = new Complexe(2,2);zero.ajoute(deux);System.out.println(zero.reel); // 2.0

Modifie l'objet courant

� Même chose que ce qui a été vu pour les fonctions

� Donc, pour les fonctions comme pour les méthodes :► Transmission par valeur

� le paramètre formel reçoit une copie de l'argument

► Attention� une valeur de type simple est donc recopiée

� une référence sur un tableau ou un objet est également recopiée,mais pas le tableau ou l'objet lui-même !

Transmission des paramètres de méthodes


Appel de méthode sur un objet

…

Complexe z = new Complexe(3,3);

Complexe zero = new Complexe(0,0);

zero.aligner(z);

…


…

void aligner(Complexe a) {

a.reel = this.reel;

…

}

}

3.0.reelréf.

.imag 3.0

réf.

0.0.reelréf.

.imag 0.0

réf.

0.0

Copie


@z

@zero

@ a

@ this

� Comme pour les fonctions, on peut créer des méthodes homonymes


Méthodes homonymes

public class Article {

double prixHT;

…

double prixTTC(double tauxTVA) {

return this.prixHT * (1 + tauxTVA);

}

double prixTTC() {

return this.prixTTC(0.196);

}

}

� Le constructeur appelé est celui de signature compatible avec les paramètres fournis

Constructeurs homonymes



}

Complexe(double reel) {this.reel = reel;this.imag = 0;

}…

}


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Java dispose d'une bibliothèque très fournie de classes préexistantes► Une telle bibliothèque est appelée API

(Application Programming Interface)

� Exemples► Classes Math, System, File…

► Documentation : http://docs.oracle.com/javase/8/docs/api/

� Voyons la classe String : chaînes de caractères

L'API Java

System.out.println("Quel est votre nom ?");

String poste = "Enseignant-chercheur";


� Type Java : char (type simple, non objet)► Un caractère isolé (un seul !)

� Écriture des littéraux : caractère noté entre '(apostrophe appelée aussi simple quote)► Exemples : 'a' 'b' '0' '$'

� Caractères spéciaux : notation avec \► '\n' newline passage à la ligne

► '\t' tabulation espace horizontal avec alignement

► '\'' apostrophe

Préalable : type caractère


Caractères : exemple

char reponse;

do {

…

…

reponse = Input.readChar("Voulez-vous continuer (O/N) ?");

} while(reponse == 'o' || reponse == 'O');


� Terme informatique pour « texte »► Utilisation pour les messages d’invites, etc.

► Vous en avez déjà vues :

� Type Java : String

� Écriture des littéraux : texte noté entre "(guillemet anglais, appelé aussi double quote)► Exemples :

� Exemples d’utilisation :

Chaînes de caractères

System.out.print("Bonjour Bob.");

"Saisir un nombre :", "Cet entier est négatif.",…

System.out.println("Quel est votre nom ?");

String poste = "Enseignant-chercheur";


� Opérateur de concaténation : +

� Particularité : concaténation de chaînes avec d'autres types(conversion implicite)

Opération de base : concaténation

String msg = "Ça";

msg = msg + " va"; ⇨ "Ça va"

msg = msg + 10; ⇨ "Ça va10"

msg = msg + '!'; ⇨ "Ça va10!"

msg = true + msg; ⇨ "trueÇa va10!"

msg += 007; ⇨ "trueÇa va10!7"


� Longueur : méthode length

� Extraction du caractère n°i : méthode charAt

► le 1er caractère porte le numéro 0

► donc i doit être inférieur strictement à la longueur

Longueur d'une chaîne, extraction de caractère

String chaine = "Hello";

int n = chaine.length();

// n vaut 5 (longueur de "Hello")

char c = chaine.charAt(1);

// c vaut 'e'


� Quelques méthodes utiles► split : découper une chaîne

► substring : extraire des sous-chaînes

► indexOf : rechercher une sous-chaîne

► endsWith : déterminer si la fin correspond à telle sous-chaîne

► toUpperCase : convertir en majuscules

� Tous les détails dans la documentation,comme pour toutes les classes standard :docs.oracle.com/javase/8/docs/api/ → String

Autres méthodes de la classe String


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Exemple:

Comparaison de chaînes (equals)

String str1 = new String("Hello");

String str2 = new String("Hello");

boolean b = (str1 == str2);

// vaut faux (comparaison des références)

boolean b2 = (str1.equals(str2));

// vaut vrai

boolean b3 = (str1.equals("HELLO"));

// vaut faux (chaînes différentes)

boolean b4 = (str1.equalsIgnoreCase("HELLO"));

// vaut vrai (ignore majuscules et minuscules)


� == ne teste pas l'égalité des objets,mais indique si deux références désignent le même objet

� Pour tester l'égalité de deux objets, les classes de l'API disposent d'une méthode equals► La signification de l'égalité de deux objets dépend de leur

classe...

� De même lorsqu'on crée une classe, il est conseillé de la munir d'une méthode equals

Comparaison de chaînes et autres objets


� Programme principal :

Exemple : comparaison de complexes



}

boolean equals(Complexe autre){return (this.reel == autre.reel)

&& (this.imag == autre.imag);}

}

Complexe c1 = new Complexe(3,5);

Complexe c2 = new Complexe(3,5);

c1.equals(c2) // true


� Affichage d'un complexe ?

► Affichage obtenu :

� Méthode permettant d'obtenir une représentation textuelle d'un objet : toString

► Existe sur les classes de l'API Java

► Doit être ajoutée aux classes qu'on écrit soi-même

Représentation textuelle des objets

Complexe c = new Complexe(3,5);System.out.println(c);

Complexe@268b819f

Représentation textuelle par défaut

d'un objet : valeur de la référence = adressemémoire de l'objet

public String toString() {…return texteRepresentantLObjetCourant;

}


� Programme principal :

Exemple avec la classe Complexe



}…public String toString() {

return "Complexe : " + this.reel + "+" + this.imag + "i";}

}

Complexe c = new Complexe(3,5);

System.out.println(c.toString()); // "Complexe : 3.0+5.0i"


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� On souhaite représenter des points du plan► Coordonnées cartésiennes (x, y)

► Méthode distanceA donnant la distance à un point donné

Révision : une classe Point


� On souhaite représenter des points du plan► Coordonnées cartésiennes (x, y)

► Méthode distanceA donnant la distance à un point donné

Révision : une classe Point

public class Point {

double x;

double y;

Point(double x, double y) {

this.x = x;

this.y = y;

}

double distanceA(Point autre) {

return Math.sqrt((this.x-autre.x)*(this.x-autre.x)

+ (this.y-autre.y)*(this.y-autre.y));

}

}


Une classe Triangle

public class Triangle {

Point a;

Point b;

Point c;

Triangle(Point a, Point b, Point c) {

this.a = a;

this.b = b;

this.c = c;

}

double perimetre() {

return this.a.distanceA(this.b) + this.b.distanceA(this.c)+ this.c.distanceA(this.a);

}

boolean estTriangleRectangle() {

// à faire en exercice

}

}


Une classe Quadrilatère

public class Quadrilatere {

Point a;

Point b;

Point c;

Point d;

Quadrilatere(Point a, Point b, Point c, Point d) {

this.a = a;

this.b = b;

this.c = c;

this.d = d;

}


return this.a.distanceA(this.b) + this.b.distanceA(this.c) + this.c.distanceA(this.d) + this.d.distanceA(this.a);

}

boolean estParallelogramme() {


}

}


� Deux classes Triangle et Quadrilatère► Des méthodes spécifiques à chacun

(estTriangleRectangle, estParallélogramme...)

► Une méthode possédée par chacun et réalisée de façon semblable (perimetre)

� Duplication de code : à éviter !► Fastidieux à faire

► Risque de recopier des erreurs

► Fastidieux de reporter des modifications

Bilan


� Constat► Un triangle est un polygone

► Un quadrilatère est un polygone

► On sait calculer le périmètre d'un polygone

� Solution :► Créer une classe Polygone, avec une méthode perimetre

► Triangle et Quadrilatère hériteront de Polygone car ce sont des sous-catégories de polygones⇒ Triangle et Quadrilatère sous-classes de Polygone

Solution : héritage


� Exprime une relation est un entre deux classes► Un Triangle est un Polygone

► Un Quadrilatère est un Polygone

► Un Employé est une Personne


Héritage

PersonnePolygone

perimetre()

Triangle

estTriangleRectangle()

Quadrilatere

estParallelogramme()

Employe

Sur l'exemple : d'abord la classe Polygone

public class Polygone {

Point[] sommets;

Polygone(Point[] sommets) {

this.sommets = sommets;

}


double longueur = 0;

for(int i=0; i<=this.sommets.length-2; i++) {

longueur += this.sommets[i].distanceA(this.sommets[i+1]);

}

longueur += this.sommets[this.sommets.length-1].distanceA(this.sommets[0]);

return longueur;

}

}

Rien de nouveau jusqu'ici...


Sous-classes de Polygone

public class Triangle extends Polygone {

…

boolean estRectangle() {


}

}

public class Quadrilatere extends Polygone {

…

boolean estParallelogramme() {


}

} public static void main(String[] args) {

Point a = new Point(0, 0);

Point b = new Point(0, 3);

Point c = new Point(4, 0);

Triangle monTriangle = new Triangle(a, b, c);

System.out.println(monTriangle.perimetre());

}

Triangle et Quadrilatère héritent de Polygone, donc possèdent la méthode perimetre


Constructeurs des sous-classes


Triangle(Point a, Point b, Point c) {

super(new Point[] {a, b, c});

}

...

}

public class Quadrilatere extends Polygone {

Quadrilatere(Point a, Point b, Point c, Point d) {

super(new Point[] {a, b, c, d});

}

...

}Délégation de la constructionau constructeur de Polygone :

super + paramètres du constructeur de Polygone


� But 1 : augmenter la réutilisation de code► Triangle et Quadrilatere profitent automatiquement des

méthodes et attributs de Polygone

► Employe profite des méthodes ou attributs de Personne

� But 2 : ajouter ou enrichir des servicesrendus par une classe► Raffiner le comportement d’une classe

Bilan : pourquoi l’héritage ?


� Réutilisation de code de la classe mère, avec raffinement► Héritage des attributs

► Héritage des méthodes

� En Java, toute classe a une et une seule classe mère► Classe mère par défaut : Object (racine de l'arbre d'héritage)

Synthèse : héritage

ClasseMere

ClasseFilleabst

ract

ion

spéc

ialis

atio

n

public class ClasseFille extends ClasseMere {…

}

Classe mère= classe de base= superclasse

Classe fille= classe dérivée

= sous-classe


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Une variable de type Polygone peut contenir des instances de Triangle et Rectangle⇒ Polymorphisme

Exemple : tableau de polygones

Triangle t1 = …

Triangle t2 = …

Quadrilatere q1 = …

Polygone[] p = new Polygone[] { t1, t2, q1 };

int longueurTotale = 0;

for(int i=0; i<p.length; i++) {

longueurTotale += p[i].perimetre();

}


� Comment ajouter la forme cercle ?► La méthode perimetre ne peut être commune aux cercles et

aux polygones...

� Solution : méthode polymorphe► Méthode qui est redéfinie dans les sous-classes

(method overriding)

► On l'appelle sur un objet « générique » (haut dans la hiérarchie), mais selon l'objet c'est un code différent (adapté à cet objet) qui est exécuté

Exemple : une nouvelle forme


Méthode polymorphe sur l'exemple

Polygone

perimetre()

Triangle Quadrilatere

Cercle

perimetre()

Forme

perimetre()

Méthode redéfinie chez les

descendants

= -1 (par convention)

= 2πr

= somme des longueurs des

côtés


Écriture des classes

public class Forme {


return -1;

}

}

public class Cercle extends Forme {

Point centre;

double rayon;

Cercle(Point centre, double rayon) {

this.centre = centre;

this.rayon = rayon;

}


return 2 * Math.PI * this.rayon;

}

}

public class Polygone extends Forme {

Point[] sommets;

Polygone(Point[] sommets) {


}


// somme des longueurs

// des segments (déjà vue)

...

}

}

Méthode perimetreredéfinie dans les

sous-classes


Utilisation

Triangle t1 = ...

Triangle t2 = ...

Quadrilatere q1 = ...

Cercle c1 = ...

Forme[] formes = new Forme[] { t1, t2, q1, c1, ... };

int longueurTotale = 0;

for(int i = 0; i < formes.length; i++) {

longueurTotale += formes[i].perimetre();

}

Polymorphisme :chaque forme calcule son

périmètre selon sa vraie nature.


Utilisation (autre exemple)

public class Forme {double perimetre() {

return -1;}

double aireLateralePrismeDroit(double hauteur) {return hauteur * this.perimetre();

}}


...



}

}


...




}

}



System.out.println(formes[i].aireLateralePrismeDroit(10.5));

}

Appel de méthode polymorphe dans la

classe de base


Polymorphisme sur la classe Object

public class Employe {

String nom;

String prenom;

int matricule;

public String toString() {

return "Prénom : " + this.prenom

+ ", Nom : " + this.nom;

}

}

extends Objectimplicite

Redéfinition de la méthode toString d'Object

⇒ Polymorphisme


Variante : utilisation de super.toString

Redéfinition de la méthode toString d'Object

⇒ Polymorphisme

Utilisation de la version de toString

présente dans la classe mère, Object


public class Employe {

String nom;

String prenom;

int matricule;

public String toString() {

return super.toString()

+ "Prénom : " + this.prenom

+ ", Nom : " + this.nom;

}

}

extends Objectimplicite

this

Référence à l'objet courant

this.methode(...)appel d'une méthode sur l'objet courant

this(...);(en première ligne d'un constructeur)

délégation de la construction à un autre constructeur de la classe courante

super

Désignation de la classe mère

super.methode(...)appel (sur l'objet courant) de la version d'une méthode définie dans la classe parente

super(...);(en première ligne d'un constructeur)

délégation de la construction à un constructeur de la classe mère

Synthèse : this et super


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



Un aspect non satisfaisant de l'exemple

public class Forme {


return -1;

}

...

}


...




}

}

Pourquoi devoir définir ce résultat « conventionnel »

mais inutile ?


...



}

}


� Méthode abstraite :► Pas d'implémentation, juste une déclaration

► Rend la classe abstraite, non instanciable

► Doit être implémentée par toute sous-classe concrète

Solution : méthode abstraite

Abstraite

Concrètes


Polygone

perimetre()

Triangle Quadrilatere

Cercle

perimetre()

Forme

perimetre()

public abstract class Forme {

abstract double perimetre();

double aireLateralePrismeDroit(double hauteur) {return hauteur * this.perimetre();

}}

Exemple avec classe et méthode abstraite


...



}

}


...




}

}



System.out.println(formes[i].aireLateralePrismeDroit(10.5));

}

Utilisation inchangée


� Objectif : spécifier un modèle ou une définition

� Méthode abstraite :► Pas d'implémentation

► On indique qu'elle doit exister dans toutes les classes réelles, concrètes, descendantes

� Une classe doit être déclarée abstraite si elle contient une méthode abstraite

� Une classe abstraite est non instanciable(on ne peut pas construire un objet de ce type)

Synthèse : classe abstraite

abstract double perimetre();

public abstract class Forme {…}


Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Un package regroupe des classes formant un tout(équivalent d'un dossier)► Permet une organisation hiérarchique du code

� Si une classe est située dans un package :► Indiquer tout en haut : package unpackage;

� Pour utiliser des classes d'un autre package :► Importer le package : import unpackage.UneClasse;

► Les classes, méthodes et attributs utilisés doivent être précédés du mot-clé public, sans quoi ils sont locaux à leur package...

Packages (rappel)


� Définition de la classe (A. Dubreuil, Paris) :

� Utilisation (B. Jones, San Francisco) :

Retour sur la classe Point


public double x;

public double y;

public Point(double x, double y) {

this.x = x;

this.y = y;

}

}

Point p1 = new Point(…);

Point p2 = new Point(…);

p1.x += p2.x/2;

p1.y += p2.y/2;

A. Dubreuil peut-elle maintenant modifier la

classe Point pour passer en coordonnées

polaires ?


� Séparer l'interface (publique) de l'implémentation (privée)

� Interface = contrat (vis-à-vis de l'extérieur)► Déf. : liste des attributs et des (signatures de) méthodes publics

► Figée une fois que le contrat est passé entre le programmeur-créateur et les programmeurs-utilisateurs

� Implémentation = réalisation (purement interne)► Déf. : liste des attributs et des (signatures de) méthodes privés,

+ corps de toutes les méthodes

► Ne concerne que le programmeur-créateur

► Privée → il peut la changer unilatéralement

Encapsulation


� Mots-clés qui indiquentd'où sont visibles les attributs et les méthodes :

► private : visible uniquement dans la classe courante

► sans qualificateur : visible dans le package courant

► protected : visible dans la classe courante, dans le packagecourant et dans les classes dérivées (même si elles ne se trouvent pas dans le même package)

► public : visible partout

Solution : visibilité


visibilité croissante

� L’attribut ou la méthode est accessible dans tous les contextes

� Exemple :

Visibilité public


public double x;

public double y;

…

public distanceA(Point autre) {

double d = Math.sqrt(Math.pow(this.x-autre.x, 2)+ Math.pow(this.y-autre.y, 2));

return d;

}

}

Point p1 = new Point(0,4);

p1.x = 2; // accès à l'attribut public autorisé

double d = p1.distanceA(p2); // appel de la méthode public autorisé


� L’attribut ou la méthode n'est accessible que dans le contexte de la classe

� Exemple :

Visibilité private


private double x;

private double y;

…

public distanceA(Point autre) {

double d = Math.sqrt(Math.pow(this.x-autre.x, 2)+ Math.pow(this.y-autre.y, 2));

return d;

}

}

Point p1 = new Point(0,4);

p1.x = 2; // accès à l'attribut private interdit

double d = p1.distanceA(p2); // appel de la méthode public autorisé

Autorisé cardans le contexte

de la classe


� Attributs► Contiennent l'état interne de l'objet

► Donc sont liés à l'implémentation de la classe

⇒ Devraient toujours être privés

� Méthodes► Certaines constituent le moyen d'accéder de l'extérieur aux

fonctionnalités de la classe⇒ publiques

► Certaines ne sont utilisés qu'en interne, vis-à-vis d'une implémentation donnée⇒ privées

Bonnes pratiques d'encapsulation



private double x;

private double y;


this.x = x;

this.y = y;

}

public double getX() {

return this.x;

}

public double getY() {

return this.y;

}

}

Point avec encapsulation, v1

Accesseur : méthode destinée à lire (ici) ou écrire un attribut privé



private double r;

private double theta;


this.r = Math.sqrt(x*x + y*y);

this.theta = Math.atan2(y, x);

}

public double getX() {

return this.r * Math.cos(this.theta);

}

public double getY() {

return this.r * Math.sin(this.theta);

}

…

}

Point avec encapsulation, v2

L'implémentation change, mais la signature de

l'accesseur ne change pas


Exemple d’utilisation private/protected/public

public abstract class Forme {

public abstract double perimetre();

double aireLateralePrismeDroit(double hauteur) { ... }

}


private Point centre;

private double rayon;

public Cercle(Point centre, double rayon) {

this.centre = centre;

this.rayon = rayon;

}

public double perimetre() {


}

}


protected Point[] sommets;

public Polygone(Point[] sommets) {


}

public double perimetre() {

…

}

}



public Triangle(Point a, Point b, Point c) {

super(new Point[] {a, b, c});

}

public boolean estRectangle() {

// utilise l'attribut protégé "sommets"

}

}

� D'où l'élément (attribut ou méthode) est-il visible ?

� Bonnes pratiques d'encapsulation :► Attributs : privés (ou protégés si héritage)

► Accesseurs : à créer selon les besoins, généralement publics� Attention : un getter retournant une référence à un objet ou à un

tableau donne, par définition, accès en écriture à cet objet/tableau !


Synthèse : visibilité

visibilitécroissante

Qualificateur La classe Le package Les sous-classes Tout le monde

private ✓rien ✓ ✓protected ✓ ✓ ✓public ✓ ✓ ✓ ✓

Plan





4. Nombres


6. Booléens

7. Boucles


9. Tableaux

10. Fonctions


12. Constantes




3. Constructeur

4. Méthodes



7. Héritage

8. Polymorphisme


10. Visibilité



� Java est un langage► Impératif

► Orienté objet

► Fortement typé

� Il existe un grand nombre de langages (>2000)► Exemples : Fortran, C, C++, C#, Java, Perl, Ruby, Python, Lisp,

Caml, OCaml, Haskel, Eiffel, Prolog…

� Partagent-ils tous la même approche que Java ?

Mise en perspective


① Quelles sont les autres façons de programmer ?

② En résumé, qu'avons nous vu dans ce cours ?

Conclusion


� Concepts communs, mais styles différents

� Modèles de programmation► Impératif

► Fonctionnel

► Déclaratif

Modèles de programmation

► Objet


� Notion de variable

� Programme = séquence d’actions, définie par le développeur, pour faire évoluer les variables

� Exemple :

Modèle impératif (ex : Java, C)

lire x

lire y

calculer x * y

stocker le résultat dans z

afficher z


� Notion de fonction : résultat = fonction(données)

� Programme = composition de fonctions(dans un ordre fixé par le programmeur)

� Exemple 1 :

� Exemple 2 :

Modèle fonctionnel (ex : Lisp, Caml, Haskell)

let twice = function f -> (function x -> f(f(x)));;

let g = twice (function x -> x+3);;

let z = g(4);;

let tableau_d_honneur = trier(map noter_copie liste_copies)


� Logique mathématique

� Programme = ensemble de faits et règles,déductions de réponse(s) à partir de questions

� Exemple :

Modèle déclaratif (ex : Prolog)

fils_de (x, y) � « x fils de y »

fils_de (Jean, Pierre)

fils_de (Pierre, Paul)

fils_de (Jules, Pierre)

fils_de(x,z) ET fils_de(y,z) � freres(x,y)

freres(Jean, Pierre)? freres (Jean, Jules)?

fils_de (Pierre,x)? freres(x,y)?


� Approche transverse : s’applique à tout modèlede programmation

� Ensemble d'objets interagissants► Modélisation « naturelle »

► Objet = état (données) + comportements (traitements)

� Programme = ► Description de classes d’objets

► Création, manipulation, destruction d’objets

Approche objet (ex : OCaml, Java, C++)

belgique : Pays frontieresBelges : PolygonecalculerPerimetre()


� Un langage est principalement associé à un modèle de programmation, mais ceci n'est pas exclusif► Exemple : Java est impératif + objet,

mais on peut programmer dans un « style fonctionnel »

� Un langage peut être multi-paradigmes :► Exemple : C# est principalement impératif + objet

+ modèle fonctionnel plus intégré qu'en Java+ intégration de requêtes déclaratives (LINQ)

� Il existe des multitudes de langages de programmation pour des usages très différents (web, logique…)

Conclusion sur les modèles de programmation


① Quelles sont les autres façons de programmer ?

② En résumé, qu'avons nous vu dans ce cours ?

Conclusion


� Connaître :► Notion de programme

► Concepts de base de la programmation

► Vocabulaire

� Être capable de :

� Comprendre un programme compte tenudu formalisme du langage utilisé

� Concevoir et écrire un programme

Rappel des objectifs du cours


� On a vu comment un ordinateur est capabled'exécuter un programme

� On a vu qu'il existe différents modèles de programmation

� On a vu et appliqué les principes de la programmation impérative, ce qui a été illustré avec le langage Java

� On a vu et appliqué les principes de la programmation objet, ce qui a été illustré avec le langage Java

En résumé


Cours d’informatique en tronc commun à Supélec :

► Première année : Modèles et Langages de Programmation (MLP), Structures de données et Algorithmes (FISDA), Génie Logiciel (GL)

► Deuxième année : Architecture des Systèmes Informatiques (Archi), Systèmes d’Information (SI), Projet de développement logiciel




4) Codage

5) Mise au point


Rappel des étapes de la programmation

GL

GL

GL

MLP

GL

GL

FISDA

GL FISDA Archi

SI


modÈleset angages de programmation - … · le nom du fichier («firstprogram.java») doit...

Documents