Introduction la programmation

1
30-755-03 Programmation objet en gestion Séance
6
2
Déroulement du cours

• Retour sur les alias et références
• Les classes  wrapper 
• Égalité entre les objets
• Le tableau
• Le tri dans les tableaux (Selection/Insertion
  Sort)
• Structure de données Array-List

3
Références et alias dobjets

• Une variable de référence et un objet sont deux
  choses séparés.
• En fait, la variable de référence détient
  ladresse mémoire de lobjet. (Pointeur).
• Téléviseur commande null
• commande new Téléviseur()

4
Les Wrapper Class

• Pour pouvoir insérer des éléments de type
  primitif dans un environnement nécessitant des
  objets, il existe des classes dites wrapper
  permettant cette conversion.
• Ex.

int nb 5 Integer wrapNb null wrapNb
new Integer (nb)
Integer, Float, Double, Character
5
Égalité avec les objets

• Il y a une distinction à faire quand vient le
  temps de faire la comparaison dobjets.
• Contrairement avec les types primitifs,
  lopérateur , lorsque employé pour faire la
  comparaison dobjets, va en fait faire la
  comparaison sur la base de légalité de la
  référence. (pas utile!)
• La méthode boolean equals(Object o). On doit par
  contre redéfinir cette méthode.

6
Égalité avec les objets
public class Registraire public static void
main ( String args ) Etudiant etudiant1
new Etudiant ( Jean, 012 ) Etudiant
etudiant1 new Etudiant ( Alice, 456 )
if (etudiant1 etudiant2 ) if (
etudiant1.equals(etudiant2) )
Sils ont la même référence, linstruction va
retourner vrai. Elle va en fait comparer
ladresse mémoire et non leur contenu. Va
retourner faux même si tous les champs à
lintérieur des objets sont identiques
Pour que ceci devienne valide, on doit redéfinir
ce que equals() doit comparer
7
Égalité avec les objets
public class Etudiant private String nom
Seb private String matricule 12365487
public boolean equals ( Etudiant etudiant )
if (nom.equalsIgnoreCase(etudiant.getNom())
matricule.equals(etudiant.getMatricule()))
return true else return
false
if ( etudiant1.equals(etudiant2) )
System.out.println(Ces étudiants sont
identiques) else System.out.println(Ces
étudiants sont différents)
8
Tableau

• Les tableaux sont des objets qui nous aident à
  organiser de grandes quantités d'information

Chaque valeur dans le tableau possède un index
qui débute normalement à 0 jusquà N-1 (ex. 0 à
9).
Le tableau a un nom
0 1 2 3 4 5 6 7 8
9
Résultats
9
Tableau

• Une valeur particulière dans un tableau est mise
  en référence en utilisant le nom du tableau suivi
  de l'index entre parenthèses.
• Ex. résultat 2

0 1 2 3 4 5 6 7 8
9
10
Tableau

• Les valeurs dun tableau sappellent des
  éléments.
• Les valeurs dun tableau doivent toutes être du
  même type.
• Les éléments peuvent être de type primitif ou
  être des objets.
• Du fait quun tableau est un objet, nous devons
  en faire linstanciation avant de pouvoir
  lutiliser.

11
Déclarer un tableau

• Syntaxe

int nombre new int 5
0 1 2 3 4
12
Remplir un tableau
int nombre new int 10
for ( int i 0 i lt 10 i ) nombre i
i i
for ( int i 0 i lt nombre.length i )
nombre i i i
Exception possible Ex. si au lieu de i lt 10 on
met i lt10 ArrayIndexOutOfBoundException
13
Exercice

• Tableau1.java

14
Initialiser un tableau et les objets
int nombre 1,2,3,4,5
Initialiser un tableau
On peut aussi avoir un tableau contenant des
objets
Déclarer un tableau dobjets
Etudiant etudiants new Etudiant 10
Insérer un objet
etudiants 0 new Etudiant ( alice, 123 )
OU
Etudiant e1 new Etudiant ( John, 321 )
etudiants 1 e1
Utiliser lobjet
etudiants 1 .setNom( Alex )
Enlever lobjet
etudiants 1 null
Démonstration Tableau2.java
15
Tableau à deux dimensions
int nombres new int 3 4
Déclaration
0 1 2
Initialiser un tableau
3
int nombres 1,2,3,5,3,3,3
0
1
2
4
3
16
Ordre

• La notion dordre est le processus par lequel on
  définit une liste dans un ordre particulier.
• Ce processus se base sur les valeurs des éléments
• Mettre en ordre des résultats en ordre croissant
• Mettre en ordre des noms de famille de manière
  décroissantes
• Il y a beaucoup d'algorithmes pour ordonner une
  liste
• Ces algorithmes varient en efficacités
• Selection Sort
• Insertion Sort

17
Ordre Selection Sort

• Approche préconisée (Stratégie)
• Scan une première fois la liste à la recherche de
  la plus petite valeur
• Échange cette valeur avec celle de la première
  position
• Avance lindex de un (puisque la première est à
  la bonne position)
• Recommence jusquà N-1 (puisque le dernier index
  contient forcément la plus grande valeur)
• liste originale 3 9 6 1 2
• valeur la plus petite 1 1 9 6 3
  2
• valeur la plus petite 2 1 2 6 3
  9
• valeur la plus petite 3 1 2 3 6
  9
• valeur la plus petite 6 1 2 3 6
  9

18
Échanger deux valeurs

• On parle ici de permutation ou swapping
• La permutation est le processus d'échanger deux
  valeurs
• Nécessite la présence de trois instructions
• temp première
• première seconde
• seconde temp

Mem
Original Première 30, Seconde 10 Final
Première 10, Seconde 30
19
Ordre Insertion Sort

• Approche préconisée (Stratégie)
• Commencer avec une liste triée qui a (au départ)
  quune seule valeur.
• Par la suite, ajoutez-y la valeur qui est à sa
  droite et faites-en la comparaison.
• Si les valeurs sont ordonnées, passer à la valeur
  de droite suivante, sinon permuter les données.

20
Paramètres revisités

• et aussi passer des tableaux en paramètre

Tout le tableau
Une partie
int nombres 1,2,3,4,5
int nombres 1,2,3,4,5
augmente(nombres)
nombres 1 augmente(nombres 1)
for (int i 0 i lt nombres.length i)
System.out,println(nombrei)
System.out,println(nombre1)
public static void augmente ( int n ) n
return n
public static void augmente ( int n )
for (int i 0 i lt n.length i) ni

Içi le paramètre est passé par valeur, on doit
donc faire un return pour modifier nombre 1
21
ArrayList

• Les ArrayList sont similaires au tableau, mais
  diffèrent sur
• La dimension dun ArrayList nest pas fixée à
  lavance.
• Vs. Tableau int a new int 5
• Laccès à un élément dans un ArrayList implique
  lutilisation dune méthode.
• On ne peut pas insérer des données ayant un type
  primitif à lintérieur du ArrayList, que des
  objets. Pour les types primitifs, il faut
  utiliser les Wrapper class.

22
ArrayList
Import java,util.ArrayList
Etudiant etudiant1 new Etudiant ( Jean, 012
) EtudiantMaitrise etudMaitre new
EtudiantMaitrise ( Alice, 456 )
ArrayList al new ArrayList()
al.add(seb) al.add(0, etudiant1)
al.add(etudMaitre)
0
1
2
System.out.println(al)
String Seb
Etudiant Jean
Avec toString( ) redéfini
Output Jean 012, seb, Alice 456
Output Etudiant123_at_342345, seb,
EtudiantMaitrise6543_at_2345456
Sans toString( ) redéfini
23
ArrayList

• Voir page 356 pour autres méthodes
• Du fait que le ArrayList comporte comme élément
  des éléments Object, il faut, si on veut se
  servir des méthodes de nos objets, les Casters.
• Ex.

ArrayList al new ArrayList() al.add(seb)
al.add(0, etudiant1) al.add(etudMaitre) al.get
(2).setOption( memoire ) ((EtudiantMaitrise)
al.get(2)).setOption( memoire )
get(index i) me retourne un objet de type Object
Index de mon objet
24
Les Wrapper Class

• Pour pouvoir insérer des éléments de type
  primitif dans le ArrayList, nous devons les
  transformer en un objet.
• Ex.

int x 5 al.add(x) int x 5 Integer wrapX
new Integer (x) al.add(wrapX) Integer wrapX
new Integer(5) al.add(wrapX) int i
((Integer) al.get(3)).intValue( )
X
Retourne la valeur en int
Integer, Float, Double, Character