csi1502 principes fondamentaux en conception des logiciels chapitre 7: lhéritage
TRANSCRIPT
CSI1502Principes fondamentaux en conception des logiciels
Chapitre 7: L‘héritage
2
Objectifs du cours:L‘héritage
Une autre technique OO fondamentale dénommé l`héritage, pour organiser et créer des classes et promouvoir leur réutilisation.
Comprendre ce qui suit: Dériver de nouvelles classes de classes existantes Créer des hiérarchies de classe: une classe parent
et de classes enfants Le modificateur d`accès protected Le Polymorphisme via l`héritage Hiérarchies héréditaires pour les interface
3
Qu`est-ce qu`est l`héritage?
L`héritage permet au programmeur de dériver de nouvelles classes à partir de classe existante.
La classe existante est dénommé la classe parent, ou super classe (superclass) ou classe de base (base class).
La classe dérivé est dénommé classe enfant ou sous-classe (subclass)
Comme le nom indique, l`enfant hérite des caractéristiques de la classe parent. C`est à dire que la classe enfant hérite:
Des méthodes et données définis dans la classe parent
4
L`héritage : Idée principale
Afin d`ajuster la classe dérivée un programmeur peut: Ajouter de nouvelles variables ou méthodes, ou Modifier les éléments hérités
La réutilisant de logiciel est au coeur de l`héritage En utilisant des objets logiciels existants afin de
créer d`autres objets logiciels, nous bénéficions de tout le travail qui à été mis dans la création, implémentation et vérification des logiciels existants.
5
Visualisation de l`héritage Les relations héritage sont souvent montrées de
façon graphiques dans les diagramme de classe, avec une flèche allant vers la classe parent
L`héritage crée une relation «est un(e)» (L`héritage crée une relation «est un(e)» (is-a)is-a), soit que , soit que l`enfant est une version plus spécifique que le parentl`enfant est une version plus spécifique que le parent
Vehicle
Car
6
Dérivation de sous classes En Java, le mot réservé extends est utilisé pour
établir une relation d`héritage
class Car extends Vehicle
{
// class contents
}
Voir Words.java, Book.java et Dictionary.java (pp.384++)
7
Diagramme UML montrant l`héritage
Words
+ main (args : String[]) : void
+ definitionMessage( ): void
Dictionary
- definition: int
+ pageMessage( ):void
# pages: int
Book
8
Programme pilote:Words.java
public class Words{
//Instansiates a derived classpublic static void main (String[] args){
Dictionary webster= new Dictionary();
webster.pageMessage();webster.definitionMessage();
}}
9
Book.java:La Classe Parent
public class Words{
//Instansiates a derived classpublic static void main (String[] args){
Dictionary webster= new Dictionary();
webster.pageMessage();webster.definitionMessage();
}}
10
Dictionary.java:La classe enfant
public class Dictionary extends Book{
private int definitions = 52500;
public void definitionMessage(){
System.out.println("Number of definitions: " + definitions);
System.out.println("Definitions per page: " + definitions/pages);
}} Number of pages: 1000
Number of definitions: 52500Definitions per page: 52
11
Modificateur d`accès:Le modificateur protected
Les modificateurs d`accès déterminent quels membres de la classe sont héritable et lesquels ne le sont pas
Les variables et méthodes déclarées avec un modificateur public sont héritées; ceux avec un modificateur private ne le sont pas
Mais le variables public violent le principe d`encapsulation
Il existe un troisième modificateur d`accès qui aide les situation d`héritage: protected
12
Le modificateur protected
Le modificateur d`accès protected permet à un membre de la classe parent a être hérité par l`enfant
Le modificateur protected donne une meilleure encapsulation que le modificateur public.
Malgré ça, le modificateur protected n`a pas une encapsulation plus forte que le modificateur private
Plus de détails sure chaque modificateur est donné dans l`appendice F.
13
Référence à un parent:La référence super
Les constructeurs ne sont pas héritables, malgré leur modificateur public
Et pourtant souvent nous voudrions utiliser le constructeur de la classe parent afin d`initialiser la «partie du parent» dans l`objet
La référence super peut-être utilisée pour invoquer la classe parent, et souvent est utilisé pour invoquer le constructeur de celui-ci
Voir l`exemple Word2, pp.388-393
14
Le programme pilote:Words2.java
public class Words2{
//Instansiates a derived classpublic static void main (String[] args){ Dictionary2 webster= new Dictionary2(1500,
52500);
webster.pageMessage(); webster.definitionMessage();}
}Number of pages: 1500Number of definitions: 52500Definitions per page: 35
15
La classe parent:Book2.java
public class Book2{
protected int pages;
public Book2(int numPages){
pages = numPages;}
// print a messagepublic void pageMessage(){
System.out.println("Number of pages: " + pages);}
}
16
La classe enfant:Dictionary2.java
public class Dictionary2 extends Book2 { private int definitions;
public Dictionary2(int numPages, int numDefinitions) {
super(numPages);
definitions = numDefinitions; }
public void definitionMessage() {
System.out.println("Number of definitions: " + definitions);System.out.println("Definitions per page:“ + definitions/pages);
}}
17
Plus au sujet de la référence super
Un constructeur d`une classe enfant et responsable d`appeler le constructeur du parent
La première ligne du constructeur doit utiliser la référence super afin d`appeler le constructeur du parent
La référence super peut aussi être utilisé afin d`accéder à d`autres variables et méthodes définies dans la classe parent
18
L`héritage simple vs. l`héritage multiple
Java ne supporte que l`héritage simple, soit qu`une classe dérivé ne peut n`avoir qu`un seul parent!
Certains autre langages supportent l`héritage multiple, ce qui permet à certaines classes d`être dérivées de plusieurs classe bénéficiant de toutes les variables et méthodes de ses parent
Ceci implique que les collisions, tel que d`avoir deux variables du même nom doivent alors être résolues
Dans la plus part des cas, l`utilisation d`interface nous donne les avantages de l`héritage multiple sans la complexité
19
L`outrepassement de méthodes
Une classe enfant peut outrepasser la définition d`une méthode hérité en faveur de sa propre méthode
C`est à dire, que un enfant peut redéfinir une méthode héritée de son parent
La nouvelle méthode doit avoir la même signature que la méthode du parent, mais peut avoir un fonctionnalité différente.
Le type de l`objet en train d`exécuter détermine quel version de la méthode qui doit être invoquée
20
L`outrepassement de méthodes :Messages.java (p.392)
public class Messages{
public static void main (String[] args){
Thought parked = new Thought();Advice dates = new Advice();
parked.message();dates.message();
}}
I feel fine
Warning: Time is shrinking
21
Thought.java
public class Thought{
public void message(){
System.out.println("I feel fine");System.out.println();
}}
22
Advice.javapublic class Advice{
public void message(){
System.out.println("Warning: Time is shrinking");System.out.println();
}}
public class Advice extends Thought{ public void message()
{System.out.println("Warning: Time is shrinking");System.out.println();
super.message();}}
23
L`outrepassement de méthodes et de variables
Notez que la méthode parent peut être invoqué spécifiquement en utilisant la référence super
Si une méthode est déclaré avec le modificateur final, on ne peut l`outrepasser
Le concept d`outrepassement peut aussi être appliqué au variables (dénommé shadowing variables en anglais). Mais ceci, de règle générale, est non recommandé
24
La surcharge de méthodes vs. l`outrepassement de méthodes
La surcharge de méthodes concerne plusieurs méthodes dans une même classe ayant le même nom mais pas la même signature.
L`outrepassement de méthodes concerne deux méthodes l`une dans une classe parent l`autre dans la classe enfant ayant le même nom et la même signature.
La surcharge de méthodes vous permet de définir des opérations similaires de façon différentes pour différentiels type de données
L`outrepassement de méthodes vous permet de définir une opération similaire de façon différente pour des objets différents.
25
Hiérarchies de classe Une classe enfant d`un parent peut-être le
parent d`une autre classe enfant, créant ainsi une Hiérarchies de classe
Business
RetailBusiness ServiceBusiness
KMart Macys Kinkos
26
Hiérarchies de classe: Quelques définitions
Deux enfants du même parents sont dénommé «siblings» Un bon concept est de mettre les aspects commun aussi
haut que raisonnable dans une hiérarchie Un membre héritable se fait passer dans tous les enfants
Le mécanisme d`héritage est transitif C`est à dire que une classe enfant hérite de tous ces
ancêtres Il n`existe pas «La» hiérarchie de classe qui est appropriée
dans toutes les situations Les hiérarchies de classes doivent souvent être modifiées
et améliorées afin de rester utile
27
La classe Object:Incluse dans java.lang
Toutes les classes sont dérivées de la classe Object La classe Object est l`ultime parent de toute les
hiérarchies de classe La classe Object contient quelques méthodes utiles
qui sont hérité par toutes les classes Par exemple, la méthode toString est définie dans
la classe Object C`est pourquoi la méthode println peut appeler toString pour tous les objets qui lui est passé – tous les objets sont garantis d`avoir une méthode toString par l`héritage
28
Classes Abstraites Une classe abstraite est une classe qui représente
un concept générique dans une hiérarchie Une classe abstraite ne peut-être utilisé Nous utilisons le modificateur abstract sur la
l`entête de la classe pour déclarer une classe abstraite
abstract public class vehicle
29
Que sont les Classes Abstraites?
Une classe abstraite contient souvent des méthodes sans définitions (comme les interfaces), mais ce n`est pas obligatoire
Contrairement à une interface, le modificateur abstract peut-être appliqué à chaque méthode abstraite
Une classe abstraite contient typiquement des méthodes non abstraites avec des méthodes fonctionnelles, faisant la différence entre les classes abstraites et les interfaces
Une classe déclaré abstraite ne doit pas nécessairement contenir des méthodes abstraites.
30
Que sont les Classes Abstraites?
L`enfant d`une classe abstraite doit outrepasser les méthodes abstraites du parent, sinon l`enfant va aussi devenir avstrait
Une méthode abstraite ne peut être définie comme final (car la méthode doit être outrepassée) static (car la méthode n`est pas définie)
L`utilisation d`une classe abstraite est une décision de concept; cela permet de créer des éléments communs dans une classe trop générale pour être utile. Par exemple
Vehicle, FuelConsumption Employee, BenefitsCalculation
31
Utilisation indirecte de membres d`une classe:Références et héritage
Un objet référé peut faire référence à un objet de sa classe, ou à un objet de n`importe quel autre classe relié par héritage
Par exemple, si la classe Holiday est utilisé pour dériver un enfant dénommé Christmas, alors une référence Holiday peut-être utilisé pour pointer sur un objet Christmas
Holiday
Christmas
Holiday day;day = new Christmas();
32
Références et héritage :Ouverture vs fermeture
Conversion d`ouverture («Widening conversion»): Assigner un objet prédécesseur à une référence
d`ancêtre Fait par une simple assignation
Conversion de fermeture («Narrowing conversion»): Assigner un objet d`ancêtre prédécesseur à une
référence de prédécesseur Fait par un conversion («cast»)
33
Utilisation indirecte de membres non hérités
Un membre hérité peut être référencé directement par nom dans la classe enfant, tout comme si il y fût déclaré
Mais, même si une méthode ou variable n`est pas hérité par l`enfant, on peut encore y accéder au travers des méthodes du parent
Voir FoodAnalysis.java (page 403) Voir FoodItem.java (page 404) Voir Pizza.java (page 405)
34
FoodAnalysis.javapublic class FoodAnalysis{
public static void main (String[] args){
Pizza special = new Pizza(275);
System.out.println("Calories per serving: " + special.caloriesPerServing());
}}
Calories per serving: 309
35
FoodItem.javapublic class FoodItem
{final private int CAL_PER_GRAM = 9;private int fatGrams;protected int servings;
public FoodItem(int numFatGrams, int numServings){
fatGrams = numFatGrams;servings = numServings;
}
private int calories(){
return fatGrams*CAL_PER_GRAM;}
public int caloriesPerServing(){
return (calories()/servings);}
}
36
Pizza.javapublic class Pizza extends FoodItem
{public Pizza(int fatGrams){
super(fatGrams, 8);}
}
37
Polymorphisme: Avoir plusieurs formes
Une référence peut être polymorphique, ce qui peut être défini comme «avoir plusieurs formes» Une variable référencé polymorphique peut
référer à différent types d`objets durant l`exécution
Les références polymorphiques sont résolues durant l`exécution; ceci est dénommé «dynamic binding»
L`utilisation prudente de références polymorphiques permet de construire des logiciels élégant et robustes.
Mammal pet;Horse myhorse = new Horse(); // Horse derived from Mammal
// Horse is-a Mammal pet = myhorse;
38
Polymorphisme via héritage
Supposons que la classe Holiday à une méthode dénommé celebrate, et que la classe Christmas l`outrepasse
Considérons maintenant l`invocation suivante:
day.celebrate();
Si day référe à un objet Holiday, il invoce la version celebrate de Holiday; de même pour l`objet Christmas
39
Polymorphisme via héritage Considérons la hiérarchie de classe suivante:
StaffMember
Volunteer Employee
Executive Hourly
• Considérons maintenant la tâche de payer tous les employés
40
Firm.java
public class Firm{ public static void main (String[] args)
{Staff personnel = new Staff();personnel.payday();
}}
Name: SamPhone: 555-3456Paid: 3341.07Name: JoePhone: 555-1432Paid: 1000.0Name: SuePhone: 555-6567Thanks!Name: AnnPhone: 555-7876
41
Staff.java
public class Staff{
private StaffMember[] staffList;
public Staff(){
staffList = new StaffMember[4];
staffList[0] = new Executive("Sam", "555-3456", 2341.07);
staffList[1] = new Employee("Joe", "555-1432", 1000.00);
staffList[2] = new Volunteer("Sue", "555-6567");staffList[3] = new Volunteer("Ann", "555-7876");
}
Continued…
42
Staff.java (cont.)…
public void payday(){
double amount;
for (int count = 0; count < staffList.length; count++){
System.out.println(staffList[count]);amount = staffList[count].pay();if (amount == 0)
System.out.println("Thanks!");else
System.out.println("Paid: " + amount);
}}
}
43
StaffMember.javaabstract public class StaffMember
{protected String name;protected String phone;
public StaffMember(String eName, String ePhone){
name = eName;phone = ePhone;
}
public String toString(){
String result = "Name: " + name + "\n";result += "Phone: " + phone;
return result;}
public abstract double pay();
}
44
Volunteer.javapublic class Volunteer extends StaffMember
{public Volunteer (String eName, String ePhone){
super(eName, ePhone);}
public double pay(){
return 0.0;}
}
45
Employee.javapublic class Employee extends StaffMember{
protected double payRate;
public Employee(String eName, String ePhone, double rate){
super(eName, ePhone);payRate = rate;
}
public double pay(){
return payRate;}
public String toString(){
String result = super.toString();
return result;} }
46
Executive.javapublic class Executive extends Employee
{private double bonus;
public Executive(String eName, String ePhone, double rate)
{super(eName, ePhone, rate);bonus = 1000;
}
public double pay(){
double payment = super.pay() + bonus;
return payment;}
}
47
Hiérarchies d`interface L`héritage peut-être appliqué aux interfaces
aussi bien qu`aux classes Une interface peut-être dérivé d`une autre interface L`interface enfant hérite toutes les méthodes
abstraites du parent Une classe implémentant l`interface enfant doit définir
toutes les méthodes de l`interface du parent ainsi que ceux de l`enfants
Tous les membres d`une interface sont public Notez que les hiérarchies de classes et hiérarchies
d`interface sont distinctes
48
Polymorphisme via Interfaces
Un nom d`interface peut-être utilisé pour déclarer une variable d`objet référence
Les interfaces permettent des références polymorphiques dans lesquelles la méthode qui se fait invoquer est determiné
par l`objet référencé
49
Speakers, Philosophers and Dogs
public interface Speaker{
public void speak();public void announce (String str);
}Assumons les classes Philosopher et Dog sont implementé en
utilisant l`interface Speaker:Speaker guest;guest = new Philosopher();guest.speak();speak method dans la classe Philosopherguest = new Dog();guest.speak; speak method dans la classe Dog
50
Héritage et GUIs:Plus à ce sujet dans le Chapitre 9
Un applet est un excellent exemple d`héritage Rappelons nous que lors de la définition d`un applet,
on étend la classe Applet ou la classe JApplet Les classes Applet et JApplet s`occupent de tous
les détails pour la création et l`exécution d`un applet, incluant les interactions avec le fureteur
Quand nous définissons certaines méthodes, tel que paint d`un applet, en effet nous outrepassons la méthode définie dans la classe Component, qui est ultimement hérité dans les Applet ou JApplet
51
Sommaire: Chapitre 7 Comprendre ce qui suit:
Dériver de nouvelles classes de classes existantes
Créer des hiérarchies de classe: une classe parent et de classes enfants
Le modificateur d`accès protected Le Polymorphisme via l`héritage Hiérarchies héréditaires pour les interface