Upload
lance-de
View
103
Download
0
Tags:
Embed Size (px)
Citation preview
Java
Héritage, interfaces
Menu rappel:
– package– modificateurs de visibilité– utilité de l’héritage
héritage– utilisation des modificateurs (extends, super)– surécriture des méthodes (override)– classes et méthodes abstraites (abstract)
les interfaces (interface, implements) résumé des modificateurs classes/interfaces (packages) existantes du JAVA
Rappel
utilisation des modificateurs de visibilité public, protected, private
Organisation des classes en packages un certain nombre de classes peut être
regroupés en packages chaque package peut contenir d’autres
packages chaque package correspond à un répertoire
dans le projet les packages forment une arborescence par défaut, toutes les classes appartiennent à
Default Package
arborescence des packages - exempleDefault Package
package1 package2
classe1.java package3 package4
classe2.java classe3.java classe4.java
classe5.java
référence aux classes des autres packagesDeux possibilités : opérateur point:
package1.package2 instruction import au début du fichier:
import package1.package2
toutes les propriétés et les méthodes de cette classe peuvent être référencées directement
exemple: java.lang.Math.sin est une méthode de la classe Math du package java.lang
créer un nouveau package sous MS J++ commande Project/New Folder faire glisser les classes dans le répertoire
correspondant à Project Explorer ou créer les nouvelles classes dans le répertoire
au début du fichier .java il apparait
package nom_package;
la notion de visibilité
propriété : une propriété est dite visible par une classe si les méthodes de cette classe peuvent avoir accès à sa valeur et peuvent la modifier.
méthode : une méthode est dite visible par une classe si les méthodes de cette classe peuvent l’appeler.
visibilité des propriétés et des méthodes public : visible de partout (à partir des
autres classes des autres packages également)
protected : (protégé) visible uniquement à partir des classes du même package
private : (privé) visible uniquement dans la classe
important
Une classe ne peut pas être privée
private class toto {} Une classe ne peut pas être protégée
protected class toto {}
Comment rendre accessible une propriété privée?
Même si une propriété est privée, on peut y accéder à l’aide des méthodes publiques ou protégées.
Ces méthodes peuvent être accessible par une autre classe.
Ces méthodes servent comme une interface entre les propriétés privées et des classes extérieures.
Ces méthodes peuvent réaliser le contrôle d’accès et la validité des valeurs, donc la protection des données.
Les méthodes d’accès à une propriété privée - exemple
public class Cercle {private double rayon;// méthode constructricepublic Cercle (double r) {
rayon = r;}// méthodes d'accèespublic double getRayon() {
return rayon; }public int setRayon( double r) {
if ( r>0 ) { rayon = r;return 0;
}else return -1;
}}
Classe Cercle
rayon
getRayon setRayon
Vers l’extérieure
Accès à la valeur
modifier la valeur
La méthode permet d’assurer la validité de la valeur en cas de modification
extérieure.
Héritage
extends, abstract, final, super
Hiérarchie des classes
Example : classification des espèces (Darwin)
La hiérarchie va des classes générales vers les classes spécifiques
véhicule
voiture
4x4
camion
utilitaire
moto
héritage (öröklődés)
la classe dérivée possède – LES PROPRIETES DE SA CLASSE MERE en
fonction des modificateurs– LES METHODES DE LA CLASSE MERE en
fonction des modificateurs
Héritage des propriétés (exemple)
voiture
fabriquant
chauffeur
Utilitaire
fabriquant, chauffeur
cargaison
quantité
Propriétés héritées
Héritage des méthodes (exemple)
voiture
démarrer
arrêter
Utilitaire
démarrer, arrêter
charger
décharger
Méthodes héritées
héritage sous JAVA Dans l’en-tête da la classe dérivée, le mot clé
extends sert à préciser la classe mère. Une classe dérivée peut avoir une seule classe
mère. Tous les propriétés et les méthodes de la classe
mère sont héritées (i.e. utilisables dans la classe dérivée) sauf celles déclarés avec le modificateur final
Les classes avec les modificateur final ne peuvent pas être des classes mères
public class EtreHumaine {public boolean sexe;public String nom;public String profession;// méthode constructricepublic EtreHumaine(boolean s, String n,String p) {
sexe = s;nom = n;profession = p;}
public void sePresenter() {String s = (sexe) ? "homme" : "femme";System.out.println("Mon nom est : " +nom);System.out.println("Je suis un(e) " + s);System.out.println("Ma profession : "
+ profession+"\n");}}
classe dérivée
public class Etudiant extends EtreHumaine{
// méthode constructricepublic Etudiant (boolean s, String n) {
super (s,n,"etudiant");}
}
classe mère (superclass)
appel du constructeur de la classe mère
Code très compact, néanmoins, la classe dérivée possède les mêmes propriétés et les
même méthodes que sa classe mère
démonstrationpublic class ClasseMain { public static void main(String[] args) {
EtreHumaine moi = new EtreHumaine(true,”Kiss","enseignant");
moi.sePresenter();
Etudiant qui = new Etudiant(false,"Claire");qui.sePresenter();
try {System.in.read();}catch (java.io.IOException e) {}}
}
La méthode sePresenter existe pour la classe dérivée aussi
Remarques
sous JAVA, l’héritage est dit simple : une classe ne peut avoir qu’une seule classe mère (l’héritage multiple existe sous C++)
une classe peut être la mère de plusieurs classes dérivées
l’héritage permet de déclarer les propriétés et les méthodes une seule fois : code très compact et réutilisation systématique!
Exercices
ajouter une classe aux précédentes : chauffeur
ajouter une classe aux précédentes : docteur
override (surécriture, felülírás)
Dans la classe dérivée, on peut redéfinir les propriétés et les méthodes de la classe mère.
La redéfinition passe par un identificateur identique.
Les méthodes surécrites de la classe mère sont masqués.
Cependant, on peut avoir accès aux propriétés et méthodes de la classe mère avec le mot clé super (voir la méthode constructrice de l’exemple précédent) en fonction des modificateurs
exemple pour la surécriturepublic class EtreHumaine {
public String nom;
public EtreHumaine(String no) { nom = no;}public void sePresenter() { System.out.println("Je m'appelle "+nom+"\n");}public void saluer() { System.out.println("Bonjour!\n");}
}
classe mère
classe dérivéepublic class Hongrois extends EtreHumaine {
public Hongrois(String n) {super(n);
}// méthodes surécritespublic void sePresenter() {
// référence à la méthode de la classe mèresuper.sePresenter();System.out.println("Je suis hongrois.\n");
}public void saluer() {
System.out.println("Jo napot kivanok!\n");}
}
méthode surécrite
méthode surécrite
démonstrationpublic class ClasseMain {
public static void main(String[] args) {EtreHumaine qqn = new
EtreHumaine("Pierre");qqn.sePresenter();qqn.saluer();Hongrois moi = new Hongrois("Balint");moi.sePresenter();moi.saluer();try {System.in.read();}catch (java.io.IOException e) {}
}}
quelques règles de surécriture Les propriétés et les méthodes masquées de
la classe mère sont référencées à l’aide du mot clé super:– super.nom_méthode– super.nom_propriété
On ne peut pas référencer les méthodes et propriétés privées (private) de la classe mère si elles sont surécrites.
Les méthodes finales (final) ne peuvent jamais être surécrites dans la classe dérivée.
méthodes et classes abstraites une méthode est abstraite si on ne déclare que son
en-tête. une classe est abstraite si toutes ses méthodes sont
abstraites. une classe abstraite ne peut pas être instanciée.
(classe sans objet et sans constructeur) dans une classe dérivée, les méthodes héritées
doivent être implémentées. Une propriété ne peut pas être abstraite. Une classe abstraite ne peut avoir aucun
constructeur.
exemple d’une classe abstraite
public abstract class CourbeFermee{
public abstract double aire();public abstract double circonference();
}
classe abstraite
en-têtes (sans bloc de code)Ces méthodes doivent être implémentées dans les classes dérivéesclasse sans méthode
constructrice
première classe dérivéepublic class TriangleEquilateral extends CourbeFermee {
public double coteLongueur;public TriangleEquilateral (double a) {
coteLongueur = a;}// implémentation des méthodes héritéespublic double aire() {
return coteLongueur*Math.cos(Math.PI/6)*coteLongueur/2;
}public double circonference() {
return 3 * coteLongueur;}
}
implémentation
une méthode existante de la classe java.lang.Math
deuxième classe dérivéepublic class Cercle extends CourbeFermee {
public double rayon;public Cercle (double r) {
rayon = r;}// implémentation des méthodes héritéespublic double aire() {
return Math.PI * Math.pow(rayon,2);}public double circonference() {
return 2*rayon*Math.PI;}
}
démonstrationpublic class ClasseMain {
public static void main(String[] args){ TriangleEquilateral t1 =
new TriangleEquilateral(13.56); Cercle c1 = new Cercle(34.76); System.out.println("Aire du cercle : "+c1.aire()); System.out.println("Circ. du triangle : "
+t1.circonference()); try {System.in.read();} catch (java.io.IOException e) {}}
}
Interfaces
le mot clé implements
Interface – approche abstraite Une interface pour un objet regroupe les méthodes
de cet objet qui ne sont pas liées à sa classe. Considérons par exemple la classe des appareils
télés. Le fait qu’un appareil télé peut avoir un prix dans
un supermarché et peut avoir une panne chez un réparateur, n’est pas directement lié au fait qu’il s’agit d’un télé.
Par conséquent, il est mieux de déclarer séparément quels sont les caractéristiques des objet qui sont vendables et réparables – cela se ferra dans des interfaces.
Interface – approche abstraite
Une classe peut être muni de plusieurs interfaces.
Équiper une classe par des interfaces est un type d’héritage.
Comme une classe peut avoir plusieurs interfaces, il s’agit de l’héritage multiple.
Interface en Java
En Java, une interface est une classe tel que:– Toutes les variables sont des variables de classe
(static)– Toutes les variables sont finales (final)– Toutes les méthodes sont publique et abstraites
(public, abstract)
Interface – conseil d’utilisation
Ne pas mettre beaucoup de méthode dans une classe.
Regrouper autant de méthodes en interfaces qu’on peut.
Conséquence: on peut enrichir le code d’une classe par l’implémentation d’une nouvelle interface.
Implémentation des interafaces
En-tête d’une classe qui implémente une interface
class nomClasse implements nomInterface1, nomInterface2…
La même classe peut implémenter plusieurs interfaces – héritage multiple
Interface – exemplepublic class EtreHumaine {
public String Nom;
public EtreHumaine(String n) {Nom = n;
}}
public interface Presentable{
public abstract void sePresenter();}
Classe mère
Interface
Résumé des modificateurs
abstract, final, public, protected, private, static
abstract
si une classe est abstraite, alors elle possède au moins une méthode abstraite
une classe abstraite n’a pas de constructeur car elle ne peut pas avoir des objets
si une méthode est abstraite, alors on ne déclare que son en-tête
final
si une classe est finale, alors elle ne peut être la classe mère des autres classes
si une méthode est finale, alors elle ne peut pas être surécrite dans une classe dérivée
si une propriété est finale, alors elle ne peut pas être modifiée (il s’agit d’un constant)
public
si une classe/méthode/propriété est publique, alors elle est visible dans les classes des autres packages
protected
si une propriété/méthode est protégée, alors elle est visible uniquement dans les classes du package où sa classe se trouve
une classe ne peut pas être protégée
private
si une propriété/méthode est privée, alors elle est visible uniquement dans la classe où elle se trouve
une classe ne peut pas être privée
static
si une propriété est statique, alors il s’agit d’une variable de classe sont il existe un seul exemplaire pour tous les objets de la classe
si une méthode est statique, alors elle manipule les propriétés statiques de sa classe
une classe ne peut pas être statique
Classe dérivée qui implémente une interface
public class Etudiant extends EtreHumaine implements Presentable{
public String Profession;
public Etudiant(String n){
super(n);Profession = "etudiant";
}
public void sePresenter(){ System.out.println("Je m'appelle " + Nom); System.out.println("Je suis un(e) " + Profession +".");}
}
classes (packages) existantes
JAVA est fourni avec des packages et classes standards
pour faciliter la tâche des programmeurs, les concepteurs du JAVA ont prévu une très large gamme de classes, organisées en divers packages: java.lang, java.awt, java.io, java.util, java.sun, etc...
Exemple : quelques classes du java.lang Integer : semblable au primitif int Double : semblable au primitif double String : on à déjà utilisé Math : beaucoup de méthodes et propriétés
(statiques) de mathématique : Math.PI, Math.sin, etc…
pour le reste : voir l’aide en ligne (Microsoft Studio Developpement Network)