Chapitre 10 Polymorphisme

Présentation au sujet: "Chapitre 10 Polymorphisme"— Transcription de la présentation:

1 Chapitre 10 Polymorphisme

2 Sommaire Liaison dynamique et liaison statique
Polymorphisme et héritage Polymorphisme et interface Tri Recherche INF Introduction à la programmation objet (Automne 2017) - M. Badri

3 Liaison dynamique et liaison statique
Le polymorphisme est un concept très puissant qui complète le concept d’héritage En POO, une classe peut redéfinir certaines méthodes héritées de sa classe de base Cette possibilité correspond à la notion de polymorphisme Possibilité de traiter de la même manière des objets de types différents Choix de la méthode à exécuter: - Si la méthode n’est pas polymorphe, le choix de la méthode se fait à la compilation – liaison statique - Si la méthode est polymorphe, le choix de la méthode se fait à l’exécution – liaison dynamique ou liaison retardée INF Introduction à la programmation objet (Automne 2017) - M. Badri

4 Liaison dynamique et liaison statique
Polymorphe: signifie prendre plusieurs forme Une référence polymorphe est une référence qui peut désigner différents types d’objets à différents moments de l’exécution Un méthode appelée via une référence polymorphe peut changer d’un appel à l’autre Toutes les références en Java sont potentiellement polymorphes Le polymorphisme permet d’obtenir un comportement adapté à chaque type d’objet (sans avoir besoin de tester) Soit : Ligne L1; - cette référence peut concerner un objet de type Ligne ou tout autre objet compatible Cette compatibilité est établie grâce à la notion d’héritage ou à la notion d’interface INF Introduction à la programmation objet (Automne 2017) - M. Badri

5 Polymorphisme et héritage
Soit Les deux classes suivantes: Polygone et Rectangle (dérivée de la classe Polygone) Polygone pol; pol = new Polygone(…); pol = new Rectangle(…); Java permet d’affecter à une var objet non seulement la référence à un objet du type correspondant, mais également une référence à un objet de type dérivé Conversion implicite - compatibilité par affectation entre un type classe et un type ascendant – normal, car rectangle est un polygone L’inverse est possible mais en utilisant l’opérateur de cast – un polygone n’est pas un rectangle (à utiliser avec précaution) INF Introduction à la programmation objet (Automne 2017) - M. Badri

6 Polymorphisme et héritage
La classe Polygone possède une méthode affiche(); Cette méthode est redéfinie par la classe Rectangle Polygone pol; pol = new Polygone(…); pol.affiche() // affiche: c’est un polygone pol = new Rectangle(…); pol.affiche() // affiche: c’est un rectangle Le choix de la méthode ne dépend pas du type de la var objet (pol), mais du type de l’objet effectivement référencé – en l’occurrence rectangle dans le second exemple INF Introduction à la programmation objet (Automne 2017) - M. Badri

7 Polymorphism via Inheritance
Let's look at an example that pays a set of diverse employees using a polymorphic method See Firm.java See Staff.java See StaffMember.java See Volunteer.java See Employee.java See Executive.java See Hourly.java Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

8 //********************************************************************
// Firm.java Author: Lewis/Loftus // // Demonstrates polymorphism via inheritance. public class Firm { // // Creates a staff of employees for a firm and pays them. public static void main(String[] args) Staff personnel = new Staff(); personnel.payday(); } Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

9 //********************************************************************
// Firm.java Author: Lewis/Loftus // // Demonstrates polymorphism via inheritance. public class Firm { // // Creates a staff of employees for a firm and pays them. public static void main(String[] args) Staff personnel = new Staff(); personnel.payday(); } Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

10 Output Output (continued) Name: Sam Address: 123 Main Line
Phone: Social Security Number: Paid: Name: Carla Address: 456 Off Line Phone: Social Security Number: Paid: Name: Woody Address: 789 Off Rocker Phone: Social Security Number: Paid: Output (continued) Name: Diane Address: 678 Fifth Ave. Phone: Social Security Number: Current hours: 40 Paid: 422.0 Name: Norm Address: 987 Suds Blvd. Phone: Thanks! Name: Cliff Address: 321 Duds Lane Phone: Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

11 //********************************************************************
// Staff.java Author: Lewis/Loftus // // Represents the personnel staff of a particular business. public class Staff { private StaffMember[] staffList; // // Constructor: Sets up the list of staff members. public Staff() staffList = new StaffMember[6]; continue Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

12 staffList[0] = new Executive("Sam", "123 Main Line",
continue staffList[0] = new Executive("Sam", "123 Main Line", " ", " ", ); staffList[1] = new Employee("Carla", "456 Off Line", " ", " ", ); staffList[2] = new Employee("Woody", "789 Off Rocker", " ", " ", ); staffList[3] = new Hourly("Diane", "678 Fifth Ave.", " ", " ", 10.55); staffList[4] = new Volunteer("Norm", "987 Suds Blvd.", " "); staffList[5] = new Volunteer("Cliff", "321 Duds Lane", " "); ((Executive)staffList[0]).awardBonus(500.00); ((Hourly)staffList[3]).addHours(40); } Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

13 //-----------------------------------------------------------------
continue // // Pays all staff members. public void payday() { double amount; for (int count=0; count < staffList.length; count++) System.out.println(staffList[count]); amount = staffList[count].pay(); // polymorphic if (amount == 0.0) System.out.println("Thanks!"); else System.out.println("Paid: " + amount); System.out.println(" "); } Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

14 //********************************************************************
// StaffMember.java Author: Lewis/Loftus // // Represents a generic staff member. abstract public class StaffMember { protected String name; protected String address; protected String phone; // // Constructor: Sets up this staff member using the specified // information. public StaffMember(String eName, String eAddress, String ePhone) name = eName; address = eAddress; phone = ePhone; } continue Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

15 //-----------------------------------------------------------------
continue // // Returns a string including the basic employee information. public String toString() { String result = "Name: " + name + "\n"; result += "Address: " + address + "\n"; result += "Phone: " + phone; return result; } // Derived classes must define the pay method for each type of // employee. public abstract double pay(); Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

16 //********************************************************************
// Volunteer.java Author: Lewis/Loftus // // Represents a staff member that works as a volunteer. public class Volunteer extends StaffMember { // // Constructor: Sets up this volunteer using the specified // information. public Volunteer(String eName, String eAddress, String ePhone) super(eName, eAddress, ePhone); } // Returns a zero pay value for this volunteer. public double pay() return 0.0; Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

17 //********************************************************************
// Employee.java Author: Lewis/Loftus // // Represents a general paid employee. public class Employee extends StaffMember { protected String socialSecurityNumber; protected double payRate; // // Constructor: Sets up this employee with the specified // information. public Employee(String eName, String eAddress, String ePhone, String socSecNumber, double rate) super(eName, eAddress, ePhone); socialSecurityNumber = socSecNumber; payRate = rate; } continue Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

18 //-----------------------------------------------------------------
continue // // Returns information about an employee as a string. public String toString() { String result = super.toString(); result += "\nSocial Security Number: " + socialSecurityNumber; return result; } // Returns the pay rate for this employee. public double pay() return payRate; Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

19 //********************************************************************
// Executive.java Author: Lewis/Loftus // // Represents an executive staff member, who can earn a bonus. public class Executive extends Employee { private double bonus; // // Constructor: Sets up this executive with the specified // information. public Executive(String eName, String eAddress, String ePhone, String socSecNumber, double rate) super(eName, eAddress, ePhone, socSecNumber, rate); bonus = 0; // bonus has yet to be awarded } continue Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

20 //-----------------------------------------------------------------
continue // // Awards the specified bonus to this executive. public void awardBonus(double execBonus) { bonus = execBonus; } // Computes and returns the pay for an executive, which is the // regular employee payment plus a one-time bonus. public double pay() double payment = super.pay() + bonus; bonus = 0; return payment; Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

21 //********************************************************************
// Hourly.java Author: Lewis/Loftus // // Represents an employee that gets paid by the hour. public class Hourly extends Employee { private int hoursWorked; // // Constructor: Sets up this hourly employee using the specified // information. public Hourly(String eName, String eAddress, String ePhone, String socSecNumber, double rate) super(eName, eAddress, ePhone, socSecNumber, rate); hoursWorked = 0; } continue Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

22 //-----------------------------------------------------------------
continue // // Adds the specified number of hours to this employee's // accumulated hours. public void addHours(int moreHours) { hoursWorked += moreHours; } // Computes and returns the pay for this hourly employee. public double pay() double payment = payRate * hoursWorked; hoursWorked = 0; return payment; Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

23 //-----------------------------------------------------------------
continue // // Returns information about this hourly employee as a string. public String toString() { String result = super.toString(); result += "\nCurrent hours: " + hoursWorked; return result; } Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

24 Polymorphisme et Interface
Une variable de type interface peut être également polymorphe au même titre qu’une variable objet Soit l’exemple suivant: public interface forme { public void affiche(); public void remplir(); } public class polygone implements forme { public void affiche() {……} public void remplir() {…..} …. forme figure; // la référence figure peut référencer n’importe quel objet appartenant à n’importe quelle classe implémentant l’interface forme ….. figure.affiche() // résultat: c’est un polygone Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

25 Tri Trier les données est un processus permettant d’organiser les données d’un tableau selon un certain critère: Selon l’ordre ascendant (descendant) Ordre alphabétique … Il existe plusieurs algorithmes de tri qui varient en efficacité, parmi eux: Tri par sélection Tri par insertion INF Introduction à la programmation objet (Automne 2017) - M. Badri

26 Tri Tri par sélection: Le principe consiste à: (pour un tri ascendant)
- chercher la plus petite valeur dans le tableau - la permuter avec la valeur se trouvant à la première position du tableau - chercher la plus petite valeur du tableau à partir de la deuxième position - la permuter avec celle se trouvant à la deuxième position - continuer ainsi le processus pour le reste des valeurs des autres positions La méthode de tri utilise la permutation: ce processus utilise une variable temporaire La permutation des var un dans deux se fait ainsi: temp = un; // temp est une var temporaire un = deux; deux = temp; INF Introduction à la programmation objet (Automne 2017) - M. Badri

27 Selection Sort Copyright © 2017 Pearson Education, Inc.
INF Introduction à la programmation objet (Automne 2017) - M. Badri

28 Tri Rappel: L’interface Comparable possède une seule méthode compareTo qui renvoie un entier : <0 si l’objet comparé est plus petit que =0 si l’objet comparé est égal à >0 si l’objet comparé est plus grand que Grâce à cela, on peut définir une méthode de tri générique pouvant accepter n’importe quel ensemble d’objets de type comparable Dans l’exemple suivant, la méthode selectionSort possède comme argument un tableau d’objets de type comparable INF Introduction à la programmation objet (Automne 2017) - M. Badri

29 //********************************************************************
// PhoneList.java Author: Lewis/Loftus // // Driver for testing a sorting algorithm. public class PhoneList { // // Creates an array of Contact objects, sorts them, then prints // them. public static void main(String[] args) Contact[] friends = new Contact[8]; friends[0] = new Contact("John", "Smith", " "); friends[1] = new Contact("Sarah", "Barnes", " "); friends[2] = new Contact("Mark", "Riley", " "); friends[3] = new Contact("Laura", "Getz", " "); friends[4] = new Contact("Larry", "Smith", " "); friends[5] = new Contact("Frank", "Phelps", " "); friends[6] = new Contact("Mario", "Guzman", " "); friends[7] = new Contact("Marsha", "Grant", " "); continue Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

30 Sorting.selectionSort(friends); for (Contact friend : friends)
continue Sorting.selectionSort(friends); for (Contact friend : friends) System.out.println(friend); } Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

31 Output Barnes, Sarah 215-555-3827 Getz, Laura 663-555-3984
Grant, Marsha Guzman, Mario Phelps, Frank Riley, Mark Smith, John Smith, Larry continue Sorting.selectionSort(friends); for (Contact friend : friends) System.out.println(friend); } Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

32 The selectionSort method in the Sorting<T> class:
// // Sorts the specified array of objects using the selection // sort algorithm. public void selectionSort(Comparable<T>[] list) { int min; Comparable<T> temp; for (int index = 0; index < list.length - 1; index++) min = index; for (int scan = index + 1; scan < list.length; scan++) if (list[scan].compareTo((T)list[min]) < 0) min = scan; // Swap the values temp = list[min]; list[min] = list[index]; list[index] = temp; } Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

33 //-----------------------------------------------------------------
continue // // Returns a description of this contact as a string. public String toString() { return lastName + ", " + firstName + "\t" + phone; } public boolean equals(Object other) return (lastName.equals(((Contact)other).getLastName()) && firstName.equals(((Contact)other).getFirstName())); Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

34 //********************************************************************
// Contact.java Author: Lewis/Loftus // // Represents a phone contact. public class Contact implements Comparable<Contact> { private String firstName, lastName, phone; // // Constructor: Sets up this contact with the specified data. public Contact(String first, String last, String telephone) firstName = first; lastName = last; phone = telephone; } continue Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

35 //-----------------------------------------------------------------
continue // // Uses both last and first names to determine ordering. public int compareTo(Contact other) { int result; if (lastName.equals(other.getLastName())) result = firstName.compareTo(other.getFirstName()); else result = lastName.compareTo(other.getLastName()); return result; } Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

36 //-----------------------------------------------------------------
continue // // First name accessor. public String getFirstName() { return firstName; } // Last name accessor. public String getLastName() return lastName; Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

37 Tri Tri par insertion Le principe consiste à: (pour un tri ascendant)
on considère que le premier élément du tableau est trié (sous liste) on prend le deuxième élément et on l’insère à la bonne position dans la sous liste on fait la même chose pour le troisième élément on continue ainsi en faisant la même chose pour le reste des éléments – l’ensemble des éléments sont insérés à la bonne position INF Introduction à la programmation objet (Automne 2017) - M. Badri

38 Insertion Sort Copyright © 2017 Pearson Education, Inc.
INF Introduction à la programmation objet (Automne 2017) - M. Badri

39 The insertionSort method in the Sorting<T> class:
// // Sorts the specified array of objects using the insertion // sort algorithm. public void insertionSort(Comparable<T>[] list) { for (int index = 1; index < list.length; index++) Comparable<T> key = list[index]; int position = index; // Shift larger values to the right while (position > 0 && key.compareTo((T)list[position-1]) < 0) list[position] = list[position - 1]; position--; } list[position] = key; Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

40 Tri Comparaison des deux méthodes de tri:
Les deux méthodes de tri sont similaires en efficacité Ils fonctionnent en o(n2) – chacun possède deux boucles imbriquées parcourant chacune n éléments, donc n*n Il existe d’autres algorithmes plus efficaces: tri rapide INF Introduction à la programmation objet (Automne 2017) - M. Badri

41 Recherche La recherche est un processus consistant à chercher un élément donné dans une collection (tableau) L’élément peut se trouver, comme il peut ne pas se trouver au niveau de la collection Au niveau du tableau, il existe deux types de recherche: recherche linéaire et recherche binaire INF Introduction à la programmation objet (Automne 2017) - M. Badri

42 Recherche Recherche linéaire: le processus consiste à parcourir le tableau depuis le début en comparant un à un les éléments du tableau par rapport à l’élément clé (le tableau n’est pas trié) Si l’élément recherché est trouvé on arrête la recherche, dans le cas contraire on continue jusqu’à la fin du tableau Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

43 Recherche Recherche Binaire:
Le processus de recherche consiste à chercher un élément dans un tableau trié Le processus consiste à comparer l’élément clé à la valeur se trouvant au milieu du tableau 1. si valeur égale - l’élément recherché est trouvé 2. si l’élément recherché est inférieur, la recherche continue dans la première partie du tableau (0 à milieu-1) selon le même principe 2. si l’élément recherché est supérieur, la recherche continue dans la seconde partie du tableau (milieu+1 et n-1) selon le même principe La recherche s’arrête quand l’élément est retrouvé ou que la taille du tableau est égale à 1 et que l’élément du tableau est différent de l’élément recherché Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

44 //********************************************************************
// PhoneList2.java Author: Lewis/Loftus // // Driver for testing searching algorithms. public class PhoneList2 { // // Creates an array of Contact objects, sorts them, then prints // them. public static void main(String[] args) Contact test, found; Contact[] friends = new Contact[8]; friends[0] = new Contact("John", "Smith", " "); friends[1] = new Contact("Sarah", "Barnes", " "); friends[2] = new Contact("Mark", "Riley", " "); friends[3] = new Contact("Laura", "Getz", " "); friends[4] = new Contact("Larry", "Smith", " "); friends[5] = new Contact("Frank", "Phelps", " "); friends[6] = new Contact("Mario", "Guzman", " "); friends[7] = new Contact("Marsha", "Grant", " "); continue Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

45 test = new Contact("Frank", "Phelps", "");
continue test = new Contact("Frank", "Phelps", ""); found = Searching.linearSearch(friends, test); if (found != null) System.out.println("Found: " + found); else System.out.println("The contact was not found."); System.out.println(); Sorting<Contact> sorts = new Sorting<Contact>(); sorts.selectionSort(friends); test = new Contact("Mario", "Guzman", ""); found = (Contact) Searching.binarySearch(friends, test); } Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

46 Output Found: Phelps, Frank 322-555-2284
Found: Guzman, Mario continue test = new Contact("Frank", "Phelps", ""); found = Searching.linearSearch(friends, test); if (found != null) System.out.println("Found: " + found); else System.out.println("The contact was not found."); System.out.println(); Sorting<Contact> sorts = new Sorting<Contact>(); sorts.selectionSort(friends); test = new Contact("Mario", "Guzman", ""); found = (Contact) Searching.binarySearch(friends, test); } Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

47 The linearSearch method in the Searching<T> class:
// // Searches the specified array of objects for the target using // a linear search. Returns a reference to the target object from // the array if found, and null otherwise. public T linearSearch(T[] list, T target) { int index = 0; boolean found = false; while (!found && index < list.length) if (list[index].equals(target)) found = true; else index++; } if (found) return list[index]; return null; Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

48 The binarySearch method in the Searching<T> class:
// // Searches the specified array of objects for the target using // a binary search. Assumes the array is already sorted in // ascending order when it is passed in. Returns a reference to // the target object from the array if found, and null otherwise. public Comparable<T> binarySearch(Comparable<T>[] list, Comparable<T> target) { int min = 0, max = list.length - 1, mid = 0; boolean found = false; while (!found && min <= max) mid = (min + max) / 2; if (list[mid].equals(target)) found = true; else if (target.compareTo((T)list[mid]) < 0) max = mid - 1; min = mid + 1; } continue Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri

49 continue if (found) return list[mid]; else return null; }
Copyright © 2017 Pearson Education, Inc. INF Introduction à la programmation objet (Automne 2017) - M. Badri