Java - héritage

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 exemple
Default Package
package1
classe1.java
classe2.java
package3
classe3.java
package2
package4
classe4.java
classe5.java
référence aux classes des autres
packages
Deux 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 constructrice
public Cercle (double r) {
rayon = r;
}
// méthodes d'accèes
public double getRayon() {
return rayon; }
public int setRayon( double r) {
if ( r>0 ) {
rayon = r;
return 0;
}
else return -1;
}
}
Vers l’extérieure
getRayon
setRayon
rayon
Classe Cercle
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
camion
4x4
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 constructrice
public 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
{
classe mère
// méthode constructrice
(superclass)
public Etudiant (boolean s, String n) {
super (s,n,"etudiant");
}
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émonstration
public 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();
La méthode sePresenter
try {System.in.read();}
existe pour la classe
catch (java.io.IOExceptiondérivée
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écriture
public class EtreHumaine {
public String nom;
classe mère
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 dérivée
public class Hongrois extends EtreHumaine {
public Hongrois(String n) {
super(n);
méthode surécrite
}
// méthodes surécrites
public void sePresenter() {
// référence à la méthode de la classe mère
super.sePresenter();
System.out.println("Je suis hongrois.\n");
}
méthode surécrite
public void saluer() {
System.out.println("Jo napot kivanok!\n");
}
}
démonstration
public 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
classe abstraite
public abstract class CourbeFermee
{
public abstract double aire();
public abstract double circonference();
}
en-têtes (sans bloc de code)
Ces méthodes doivent être
implémentées dans les classes
classe sans méthode dérivées
constructrice
première classe dérivée
public class TriangleEquilateral extends CourbeFermee {
public double coteLongueur;
public TriangleEquilateral (double a) {
coteLongueur = a;
implémentation
}
// implémentation des méthodes héritées
public double aire() {
return coteLongueur*Math.cos(Math.PI/6)*
coteLongueur/2;
}
public double circonference() {
return 3 * coteLongueur;
une méthode existante de la classe
}
java.lang.Math
}
deuxième classe dérivée
public class Cercle extends CourbeFermee {
public double rayon;
public Cercle (double r) {
rayon = r;
}
// implémentation des méthodes héritées
public double aire() {
return Math.PI * Math.pow(rayon,2);
}
public double circonference() {
return 2*rayon*Math.PI;
}
}
démonstration
public 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 – exemple
public 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)