Java - fil

publicité
Introduction
Objectifs de Java
Java
• un langage simple, OO, portable
• philosophie WORA ("Write Once, Run Anywhere")
1 source s'exécute à l'identique sur +sieurs CPU/OS
(Solaris, Linux, Win xx, MacOS) pourvu d'une machine virtuelle (VM)
Principe
Lionel Seinturier
source
.java
Université des Sciences et Technologies de Lille
compil.
exécution
VM
bytecode
.class
[email protected]
6/03/05
Java
1
Lionel Seinturier
∀ plate-forme, à partir d'un .java
Contrepartie
- .class obtenu par compilation identique
- .class s'exécute à l'identique
.class - performant code natif (.exe)
mais ...
Java
Introduction
Lionel Seinturier
Introduction
Historique
Disponibilité
1991
1993
1996
1997
1998
2004
3 éditions
J. Gosling, B. Joy, A. Van Hoff : OAK (électronique grand public)
JDK 1.0, lien avec Web (applet)
Java Beans
JDK 1.1, Enterprise Java Beans, JavaCard, Java OS
Java 2 (JDK 1.2, 1.3, 1.4)
Java 5 (JDK 1.5) : annotations, types génériques, enum, auto-boxing
En cours de développement
Java SE (Standard Edition)
Java EE (Enterprise Ed.)
Java ME (Micro Ed.)
"le" JDK (compilateur + VM + librairies)
serveur pour des applications d'entreprise
client/serveur (nécessite Java SE)
VM + librairies pour des systèmes embarqués
(PDA, tel., ...)
Outils
2006
Java 6 (beta 2) : amélioration API, intégration SGBD
2007 ? Java 7 : VM multi-langage Java, JavaScript, PHP, Python, …
Nombreuses technologies pour les applications client/serveur
JSP, servlet, JDBC, JMS, JavaIDL, JavaMail, RMI, JCE, JAAS, JNDI, JTS, JTA,
JavaCard, JMX, JMI, ......
Java
2
3
Lionel Seinturier
- IDE
Eclipse, JBuilder, VisualAge, JDeveloper, Forte, NetBeans, ...
- VM
Jikes RVM, Kaffe, kissme, LaTTe, SableVM, ...
- compilateur
Jikes, GCJ, KJC, Espresso, Manta, …
- manipulation bytecode ASM, BCEL, BAT, CFParse, Jasmin, Javassist, …
- ... nombreux autres
Java
4
Lionel Seinturier
Plan
1. Origines
Origines de Java
1. Origines
2. Principes
Influence : Simula, Smalltalk, C++
3. Premiers exemples
Analogies
Mais
4. Eléments syntaxiques de base
- modèle d'objets à la C++
- instructions à la C++
- typage à la C++
- syntaxe à la C++
- pas d'héritage multiple
- gestion des erreurs + rigoureuse
- règles de conversion simplifiées
- simple et rigoureux
5. Classes
6. Héritage
7. Classes abstraites
8. Relation de typage
9. Exceptions
Java
5
Lionel Seinturier
Java
6
2. Principes
Lionel Seinturier
2. Principes
3 principes
Principe 1 : langage basé sur des classes et objets
• langage basé sur des classes et objets
• interactions entre objets par échanges de messages
• héritage
Classe : données (variables) et traitements (méthodes) manipulant les données
Objet : instance de classe
Programmation procédurale vs programmation objet
données
procédures
objets
Compte p1, p2;
p1 = new Compte(15);
p2 = new Compte(20);
p1.crediter(5);
p2.debiter(5);
Compte p1, p2;
initialiser(p1,15);
initialiser(p2,20);
crediter(p1,5);
debiter(p2,5);
Java
7
Lionel Seinturier
Java
8
Lionel Seinturier
2. Principes
2. Principes
Principe 2 : interactions par échanges de messages
Principe 3 : héritage
= invocation de méthodes entre objets
Construction d'une classe par rapport à une autre
clavier1
uc1
ecran1
UC
Ecran
Ö compléter/étendre/spécialiser une classe existante
- ajout de données et/ou de méthodes
- modification de méthodes
instance de
Véhicule
Clavier
ref
Véhicule terrestre
Toutes les méthodes d'une classe sont-elles invocables de l'extérieur ?
Ö interface de la classe (= ens. des méthodes invocables de l'extérieur)
Voiture
Les interf. définissent seulement des déclarations (nom+param.) de méthodes
pas de code
Java
9
Lionel Seinturier
Véhicule aquatique
Bateau
Véhicule aérien
Radeau
Voiture amphibie
Java
3. Premiers exemples
10
Lionel Seinturier
3. Premiers exemples
Un programme simple
Un programme simple avec héritage
class Point2D {
private int abs;
private int ord;
public Point2D(int x,int y) { abs=x; ord=y; }
public Point2D() { abs=0; ord=0; }
public void move(int dx,int dy) { abs+=dx; abs+=dy; }
public void where() { System.out.println("x="+x+"; y="+y);
}
class Point2DColor extends Point2D {
private int color;
public Point2DColor(int x,int y,int c) { super(x,y); color=c; }
public Point2DColor() { super(0,0); color=0; }
public void paint(int c) { color=c; }
public void whichColor() { System.out.println("c="+c); }
}
public class Test {
public static void main( String[] args ) {
Point2D p1, p2;
p1 = new Point2D();
p2 = new Point2D(10,20);
p1.where();
p1.move(10,10);
p1.where();
}
}
Java
11
Lionel Seinturier
Java
12
Lionel Seinturier
3. Premiers exemples
3. Premiers exemples
Conventions d'écriture
Outils du JDK
Règles "communautaire" d'écriture des programmes Java
→ améliore la lisibilité des programmes
Compilateur javac
javac MaClasse.java
Ö autant de fichiers .class qu'il y a de classes définies dans MaClasse.java
• noms de classe, d'interface
- commence par une majuscule puis minuscules
- majuscule pour chaque partie d'un nom composé (ex. EventListener)
VM
java MaClasse
Ö exécution de la méthode main de la classe MaClasse
• noms de variables, méthodes
- commence par une minuscule
- puis majuscule pour chaque partie d'un nom composé (ex. baseObject)
• 1 classe par fichier
- nom de fichier identique nom classe
• noms de package en minuscules (ex. javax.transaction)
Java
13
Options javac
-d
répertoire d'écriture des .class (par défaut répertoire courant)
-classpath
lib (.jar) ou rép contenant des .class nécessaires à la compil.
ex Unix
-classpath /tmp/foo.jar:/home/classes:../classes
Win
-classpath \tmp\foo.jar;\home\classes;..\classes
alternativement var. d'environnement CLASSPATH du shell
Options java
-classpath
Lionel Seinturier
idem javac
Java
4. Eléments syntaxiques
14
Lionel Seinturier
4. Eléments syntaxiques
Méthode
Méthode
Bloc d'instructions nommé
- [prenant des paramètres en entrée]
- [retournant un paramètre en sortie]
Visibilité des méthodes
partout
uniquement de la classe courante
classe courante + ses sous-classes (héritage)
classe courante + classes package courant (package public)
méthode de classe (pas d'accès aux variables d'instance)
Syntaxe
- public
- private
- protected
- rien
- static
[visibilité] typeRetour nom '(' [listeParamètres] ')' [exceptions] '{' instructions '}'
1 seule valeur possible parmi les 4 1ères
public boolean estPair( int nb ) { ... }
private double plus( double v1, double v2 ) { ... }
void méthodeSansRetour() { ... }
Cas spécial de la méthode main (point d'entrée du programme)
Instruction return fournit la valeur à retourner
Pas de return si type retour void
- toujours la même signature
- récupère les arguments de la ligne de commande
- peut éventuellement lever des exceptions
Ö défini uniquement à l'intérieur d'une classe
public static void main( String[] args ) { ... }
Java
15
Lionel Seinturier
Java
16
Lionel Seinturier
4. Eléments syntaxiques
4. Eléments syntaxiques
Attribut (field)
Attribut (field)
Espace mémoire typé pour le stockage de l'information
Visibilité des attributs
Ö défini uniquement à l'intérieur d'une classe
idem méthode
- public, private, protected, rien
- static attribut propre à une classe → partagé par tous les objets de la classe
- final constante → initialisation obligatoire
Syntaxe
[visibilité] type nom [ '=' valeurInitiale ] ';'
int i = 1;
public double salaire;
final static protected double tva = 18.6;
[visibilité] type ( nom [ '=' valeurInitiale ] )* ';'
int i,j=10,k;
Java
17
Lionel Seinturier
Java
4. Eléments syntaxiques
18
Lionel Seinturier
4. Eléments syntaxiques
Tests
Boucles
if (condition) { instructions; }
else { instructions; }
while (condition) { instructions; }
do { instructions; } while (condition);
• while : instructions peuvent ne pas être exécutées
• do/while : instructions exécutées au moins 1 fois
• else facultatif
• {} facultatives s'il n'y a qu'une seule instruction
• else se rapporte toujours au dernier if
for ( initialisation ; condition ; incrément )
{ instructions; }
≡
if (cond1) { instructions; }
if (cond2) { instructions; }
else { /*cond2 faux*/ instructions; }
initialisation
while (condition) {
instructions;
incrément;
}
Ö ok mais à éviter (risque d'erreur trop important)
• l'initialisation peut contenir des déclarations de variables
for ( i=0 ; i<10 ; i++ ) { System.out.println(i); }
for ( int i=13, float j=15.7 ; ... ; ... ) { ... }
Java
19
Lionel Seinturier
Java
20
Lionel Seinturier
4. Eléments syntaxiques
4. Eléments syntaxiques
Branchements
Types de base
switch( expression scalaire ) {
case valeur 1 : instructions; break;
case valeur 2 : instructions; break;
...
default : instructions;
}
Ensemble des valeurs légales pour une variable
• entiers
• réels
• booléens
• caractères
• expression scalaire = entier ou caractère
• ne marche pas avec les chaînes
• break omis : les instructions du case suivant sont aussi exécutées
: byte, short, int, long
: float, double
: boolean
: char
Pas un type de base, mais très utilisé
chaîne : String
Conversion sur les types de base numériques (cast)
var = (type cible) expr
int y = (int) (3.14*r*r);
Java
21
Lionel Seinturier
Java
4. Eléments syntaxiques
22
Lionel Seinturier
4. Eléments syntaxiques
Types de base : entiers
Types de base : entiers
Représentation signée (complément à 2)
Règles de conversion (suite)
• byte
• short
• int
• long
• la VM traite les byte et les short comme des int
Ö reconversion paradoxale si nécessaire
: 1 octet
: 2 octets
: 4 octets
: 8 octets
[-128,+127]
[-32768,+32767]
[-231, 231-1]
[-263, 263-1]
short a=1,b=2; short c = (short)(a*b)
Règles de conversion
Bases de numérotation
• opérations avec des types hétérogènes
Ö résultat : le "+ grand" des types mis en jeu
int x=3; long y=2;
x*y de type long
• conversion automatique lorsque le type cible d'une affectation
est "+ grand" que le type de la valeur
• nb hexadécimal préfixé par 0x
• nb octal (base 8) préfixé par 0
11 en base 8 = 9 en base 10
ex : 0x1F
ex : 011
int t=4; long u=t;
• sinon conversion explicite
int m=12; int i = (int)m;
Java
23
Lionel Seinturier
Java
24
Lionel Seinturier
4. Eléments syntaxiques
4. Eléments syntaxiques
Types de base : réels
Opérations sur les types de base
Représentation IEEE 754-1985
Comparaison
Arithmétiques
• float : 4 octets
• double : 8 octets
== != < > <= >=
+ - * / % ++ -- -
Manipulation de bits
• notation scientifique
17.5e-3 -8.0 0.57e3
• mêmes types de règles de conversion que pour les entiers
• les valeurs sont par défaut des double
Ö pour les float utilisation du suffixe f
^
~
>>
>>>
& | ^ ~ << >> >>>
XOR
NOT
décalage à droite en conservant le signe
décalage à droite en ajoutant des 0
float pi = 3.14f;
Affectations
Logiques
Types de base : booléens et caractères
• boolean
• char
= += -= *= /= <<= >>= >>>= &= ~= !=
&& || !
ternaire ?:
: 2 valeurs true et false
: caractères entre apostrophes 'e'
utilisation anti-slash '\'' '\\'
Java
25
Lionel Seinturier
Java
26
4. Eléments syntaxiques
Lionel Seinturier
4. Eléments syntaxiques
Chaînes de caractères
Tableaux
• type (classe) String
Déclaration
ex
• entre guillemets "informatique"
• utilisation anti-slash "a\"\\b"
typeElement[] nom
int[] tabEntiers;
Initialisation avec {} ou allocation avec new
• concaténation de chaînes avec l'opérateur + ou +=
tabEntiers = new int[5];
tabEntiers = { 12, 7, -8 };
String res = "hello" + " ";
res += "world";
• test d'égalité de chaînes avec la méthode equals (pas avec ==)
• accès aux éléments avec []
tabEntiers[3]
• indices de 0 à taille-1
• pas de contrôle de dépassement d'indice à la compilation
Ö erreur à l'exécution si dépassement
• ∀ tableau, attribut length contient sa taille
String s = "hello";
s.equals("hello") → true
s.equals("Hello") → false
for ( int i=0 ; i < tabEntiers.length ; i++ ) {
System.out.println(tabEntiers[i]);
}
Java
27
Lionel Seinturier
Java
28
Lionel Seinturier
4. Eléments syntaxiques
4. Eléments syntaxiques
Tableaux
Références d'objets
• déclaration seule ne suffit pas
• mais int[5] tab interdit
déclaration et allocation obligatoires
int[] tab = new int[5]
• +sieurs références peuvent "pointer" sur le même objet
• affectation possible entre références
• tests == et != possibles sur les références
• référence nulle null
Tableaux multi-dimensionnels
ref1
ref2
ref3
ref4
float[][] matrice;
initialisation
matrice = {{1,2},{},{4}};
ou allocation
matrice = new int[5][4],
ou allocation
matrice = new int[2][];
matrice[0] = new int[7];
matrice[1] = new int[2];
=
=
=
=
new MaClasse();
ref1;
new MaClasse();
null;
ref1
→ true
→ true
ref2
ref1 == ref2
ref1 != ref3
ref3
ref4
Java
29
Lionel Seinturier
Java
30
4. Eléments syntaxiques
Lionel Seinturier
4. Eléments syntaxiques
Passage de paramètres
Surcharge
Passage par valeur
≡ la méthode travaille sur une copie de la valeur
Plusieurs méthodes dans la même classe avec
- 1 nom identique
- des paramètres ≠
void inc(int x) { x++; System.out.println(x); }
.. main(..) { int y=4; System.out.println(y);
inc(y); System.out.println(y); }
ex
Affichage : 4 5 4
Les références sont aussi passées par valeur
≡ les objets sont passés par référence
void afficher( int i );
void afficher( float f );
void afficher( int i, float f );
Pas de surcharge sur le type de retour
class Foo { int x; Foo(int x){this.x=x;} }
void inc(Foo f) { f.x++; System.out.println(f.x); }
.. main(..) { Foo f=new Foo(4); System.out.println(f.x);
inc(f); System.out.println(f.x); }
ex
void afficher( int i );
boolean afficher( int i );
interdit (considéré comme une tentative de redéfinition de la même méthode)
Affichage : 4 5 5
Java
31
Lionel Seinturier
Java
32
Lionel Seinturier
4. Eléments syntaxiques
4. Eléments syntaxiques
Surcharge
Instructions de saut
Algorithme de résolution de surcharge
Instructions de saut utilisables à l'intérieur d'un bloc
But : trouver la méthode à appeller en cas de surcharge
- break
- continue
class Foo {
void fun( int a, double b ) {..}
void fun( double a, long b ) {..}
void fun( int a, float b ) {..} }
// fun0
// fun1
// fun2
while ( i < 10 ) {
...
if ( i == 6 ) continue;
...
// instructions sautées si i==6
}
fun(12,(float)3.14) → appel de fun0 ? ou de fun2 ?
Recherche du profil le + proche selon ⊆ des types
int ⊆ int et float ⊆ double Ö (int,float) ⊆ (int,double)
: sortie de bloc
: saut à la fin du bloc (on reste dans le bloc)
Ö appel de fun2
Remarques
Il peut ne pas y avoir de solution
fun(12,3) ? fun0 ? fun1 ? fun2 ? (les 3 "conviendraient")
- break
: sortie de bloc
- return
: sortie de méthode
- System.exit(0) : sortie de programme
fun2 ⊆ fun0 mais fun2 et fun1 ne sont pas comparables par ⊆
Ö pas possible de def. le profil le + proche Ö erreur de compilation
Instructions de saut avec des étiquettes (à la goto) Ö proscrire
Java
33
Lionel Seinturier
Java
4. Eléments syntaxiques
34
5. Classes
Packages
Classes
Permettent de regrouper des classes ayant un lien logique entre elles
Unité fondamentale de structuration des applications en Java
1ère étape de modélisation OO : trouver les classes
ex :
java.io classes pour les entrées/sortie
java.net classes pour la gestion du réseau
Syntaxe simplifiée
• organisation hiérarchique (ex : jussieu.master.srcs.tp1)
• un package peut contenir des classes et/ou d'autres packages
• les noms de package java et javax sont réservés pour le JDK
[public] class nom '{' instructions '}'
public class MaClasse { ... }
class MaClasse2 { ... }
• un prog. utilisant les classes d'un autre package doit les importer (mot clé import)
ex : import java.io.IOException;
import java.net.*;
// toutes les classes du package
• mot clé package pour définir le package courant
• ordre des mots-clés obligatoire dans un programme : package, import, class
35
• public : classe visible de partout
• rien : classe visible du package courant (package protected)
Dans 1 fichier
• 1 classe public et 1 seule (nom fichier = nom classe publique)
• 0 ou n classes package protected
• les classes du package java.lang sont importées automatiquement
• les classes du package courant sont importées automatiquement
Java
Lionel Seinturier
Lionel Seinturier
Java
36
Lionel Seinturier
5. Classes
5. Classes
Constructeurs de classe
Constructeurs de classe
Méthode d'initialisation exécutée juste après l'instanciation de la classe (new)
class Point2DColor {
private int color;
private int abs, ord;
public Point2DColor(int x,int y,int c) { ... }
public Point2DColor(int c) { ... }
public Point2DColor() { ... }
...
}
Permet
• d'initialiser des données
• d'exécuter des traitements initiaux
• d'allouer des ressources pour l'instance (ouverture de fichiers, ...)
Syntaxe
[public|protected|rien] nom '(' [paramètres] ')' '{' ... '}'
public class MaClasse {
public MaClasse(int init) { ... } }
• nom du constructeur = nom de la classe
• pas de type de retour (implicitement retourne une réf. Ö celle de l'obj. construit)
• possibilité de surcharge
Java
37
Lionel Seinturier
public class Test {
public static void main( String[] args ) {
Point2DColor p1 = new Point2DColor();
Point2DColor p2 = new Point2DColor(4);
Point2DColor p3 = new Point2DColor(10,0,2);
Point2DColor p4 = new Point2DColor(10,0);
}
}
Java
5. Classes
38
// erreur
Lionel Seinturier
5. Classes
Constructeurs de classe
Attributs et méthodes de classe (static)
Mot clé this dans les constructeurs
Attribut de classe
Ö appel d'un autre constructeur de la même classe
Ö si utilisé, uniquement en 1ère instruction du constructeur
- information partagée par tous les objets de la classe (constantes, ...)
- compteurs globaux (ex : # d'objets de la classe, ...)
Ö en général un constructeur avec toutes les initialisations
Ö + les autres constructeurs font référence à ce 1er avec des valeurs par défaut
Méthode de classe
- méthode non liée à un objet spécifique (ex : fonction mathématique, ...)
class Point2DColor {
private int color;
private int abs, ord;
public Point2DColor(int x,int y,int c) { abs=x; ord=y; color=c; }
public Point2DColor(int c) { this(0,0,c); }
public Point2DColor() { this(0,0,0); }
...
}
Java
39
Lionel Seinturier
class Point2DColor {
private static int nbPoint2DColor;
private int color;
private int abs, ord;
public Point2DColor(int x,int y,int c) {
abs=x; ord=y; color=c;
nbPoint2DColor++;
}
... }
Java
40
Lionel Seinturier
5. Classes
5. Classes
Attributs et méthodes de classe (static)
Auto-référence
Attention
MaClasse
Mot clé this : désigne la référence de l'objet courant
o1 = new MaClasse();
o2 = new MaClasse();
static int s
int cpt
Permet de
// toutes var. init. à 0
o1.cpt++; // = 1
o2.cpt++; // = 1
o1.s++;
o2.s++;
// = 1
// = 2
s
cpt
s
cpt
o1
o2
Désignation des attributs en cas d'ambiguïté
• chaque cpt est propre à son instance
• s est partagé par toutes les instances de MaClasse
Java
- désigner les attributs de l'instance en cas d'ambiguïté de nom
(avec variable locale ou paramètre)
- construire des structures de données chaînées
- implanter des mécanismes de rappel d'objet (callback)
- enchaîner des appels de méthodes
class Carre {
int color;
public void setColor(int color) { this.color = color ; }
}
41
Lionel Seinturier
Java
42
5. Classes
5. Classes
Auto-référence
Auto-référence
Implantation d'un mécanisme de rappel (callback)
Echaînement d'appels de méthodes
class MaClasse {
void foo() {
Gestionnaire g =
new Gestionnaire();
g.bar(this);
}
void fb() { ... }
}
class Fraction {
int num=0, den=1;
public Fraction doubler() { num*=2; return this; }
}
MaClasse
foo
Java
Gestionnaire
fb
bar
Fraction f1 = new Fraction();
f1.doubler().doubler();
1
fb
class Gestionnaire {
void bar(MaClasse mc)
{ mc.fb(); }
}
Lionel Seinturier
2
Rq : il est toujours possible de ne pas récupérer la valeur retournée
par une méthode (ici c'est le cas de 2)
43
Lionel Seinturier
Java
44
Lionel Seinturier
5. Classes
5. Classes
Interfaces
Interfaces
Classe "dégradée" ne contenant que des définitions
Implémentation des interfaces
- de constantes (automatiquement public final static)
- et/ou de profils de méthodes
(automatiquement public)
Chaque classe qui implémente une interface
Pas de code
Mot clé interface
- récupère toutes les constantes
- doit fournir du code pour toutes les méthodes de l'interface
Ö sinon erreur de compilation
- peut ajouter n'importe quel élément (attribut, méthode) constitutif d'une classe
interface LampeInterf {
final int off = 0;
final int on = 1;
void allumer();
boolean estAllume();
}
class Lampe implements LampeInterf {
private int etat;
// implantation des méthodes de l'interface LampeInterf
public void allumer() { etat = on; }
public boolean estAllume() { return (etat==on); } }
- une classe peut implémenter +sieurs interfaces (implements Itf1,Itf2)
Java
45
Lionel Seinturier
Java
5. Classes
46
5. Classes
Classe - fonctionnalités diverses
Classes incluses (inner classes)
Méthode toString
Classe définie à l'intérieur d'une autre
Ö obtention d'une représentation "chaîne de caractères" (stringified) d'un objet
Ö but : pouvoir afficher des infos pertinentes concernant un objet
Ö classe liée à une classe conteneur (dite outer)
qui l'utilise pour ses besoins internes
Ö la déf. de la classe inner comme classe autonome ne se justifie pas
Ö automatiquement invoquée lorsqu'on concatène (opérateur +)
un objet à une chaîne de caractères
class Outter {
...
public class Inner { ... }
public void foo() { ... new Inner() ... } }
class Fraction {
...
public String toString() { return num+"/"+den; }
}
• les classes inner peuvent avoir une visibilité (public, private, static, ...)
• une classe inner peut s'instancier à l'extérieur de la classe outter
si la visibilité le permet
Fraction f = new Fraction(8,3);
System.out.println( "La fraction vaut : " + f );
Outter outter = new Outter();
Outter.Inner inner = new Outter.Inner();
Appel à f.toString()
Java
47
Lionel Seinturier
Lionel Seinturier
Java
48
Lionel Seinturier
5. Classes
5. Classes
Classes anonymes
Blocs de code static
Définition de classes incluses sans nom (anonyme)
Blocs de code exécutés 1 fois et 1 seule lors du chargement de sa classe
• la classe est définie en même temps qu'elle est instanciée (new)
• la classe anonyme étend une classe de base (celle du new)
• la classe anonyme ne peut être utilisée qu'une fois
public void foo() {
Thread t =
new Thread()
class Foo {
...
static { ... }
...
}
classe étendue
{
classe anonyme
public void run() { ... }
• utilisation : initialisation des attributs static de la classe
• +sieurs blocs static possibles
• les blocs static sont exécutés dans l'ordre de leur définition
};
}
méthode de la classe Thread
redéfinie dans la classe anonyme
Java
49
Lionel Seinturier
Java
6. Héritage
50
Lionel Seinturier
6. Héritage
Héritage
Héritage
Définir de nouvelles classes à partir de classes existantes
class Point2DColor extends Point2D {
private int color;
public Point2DColor(int x,int y,int c) { super(x,y); color=c; }
public Point2DColor() { super(0,0); color=0; }
public void paint(int c) { color=c; super.paint(); }
public void whichColor() {
System.out.println("c="+c);
}
}
Spécialisation/enrichissement
d'une classe par ajout et/ou
redéfinition
super-classe (classe parente)
héritage
Mot clé extends
pour désigner la super-classe
sous-classe
(classe fille)
Mot clé super pour désigner les méthodes/constructeurs de la super-classe
- nécessairement même type de retour (sinon erreur de compilation)
- interdiction de restreindre le droit d'accès (on peut l' Ê)
- contraintes sur les exceptions (voir + loin)
- attribut final : une méthode déclarée final ne peut pas être redéfinie
(attribut final utilisable également pour les classes)
Redéfinition de constructeurs
- super nécessairement 1ère instruction (sauf si on utilise this)
- appel au super-constructeur non obligatoire
Java
51
Redéfinition de méthodes
Lionel Seinturier
Java
52
Lionel Seinturier
6. Héritage
7. Classes abstraites
Héritage
Classes abstraites
Redéfinition d'attribut
Classe dont 1 ou +sieurs méthodes n'ont pas de code
- type modifiable
- accès à l'attribut de la super-classe avec super
Ö permet d'abstraire des comportements dans une hiérarchie d'héritage
Ö n'a d'utilité que si les méthodes abstraites sont "concrétisées"
dans une sous-classe
Classe java.lang.Object
Mot clé abstract devant chaque méthode abstraite, devant la classe
- super-classe de toutes les classes Java
- lien d'héritage défini automatiquement par le compilateur
- définit des méthodes appelables sur tout objet Java
- getClass, toString, hashCode, equals
- notify, notifyAll, wait (gestion Thread & synchronisation)
abstract class CapteurTemperature {
double temp;
double getTemp() { return temp; }
abstract void calibrer();
// pas de code pour calibrer
// devra être défini ultérieurement dans une sous-classe
}
Java
53
Lionel Seinturier
Java
7. Classes abstraites
54
8. Relation de typage
Classes abstraites
Relation de typage
• 1 classe abstraite ne peut pas être instanciée
• 1 classe abstraite peut hériter d'une classe abstraite ou non
Définition d'une relation de (sous)-typage par
- implémentation d'interface(s)
- héritage de classe
• 1 classe peut être définie abstraite alors qu'aucune méthode ne l'est
Ö interdire son utilisation telle quelle
Ö obliger le développeur à la sous-classer
ex : java.lang.ClassLoader
Mot clé instanceof permet de tester ∈ d'un objet
à une hiérarchie d'héritage et/ou d'implantation
class C1 implements I1,I2 { ... }
class C3 extends C1 implements I3 { ... }
• si toutes les méthodes abstraites et pas de constantes ≡ interface
interface
interface
Java
est implan
tée par 0,n
implante
0,n
classe
classe
55
est instan
ciée en 0,n
est inst
ance d’ 1
Lionel Seinturier
C1 c1 = new C1();
C3 c3 = new C3();
objet
(c1 instanceof I1) == true
(c3 instanceof I3) == true
objet
Lionel Seinturier
Java
(idem I2,C1)
(idem I2,I1,C1 par héritage)
(idem C3)
56
Lionel Seinturier
8. Relation de typage
8. Relation de typage
Relation de typage
Relation de typage
Affectation d'une instance à une référence
dont le type est un sous-type de l'instance
Une référence peut être convertie vers un sur-type
compatible avec l'instance référencée
C1
C1
I2
C2
I3
C3
I2
C2
I2bis
I3
C4
I3bis
I5
C3 c3 = new C3();
Java
C4
I3bis
C5
I5
I2 refI2 = new C3();
C2 refC2 = c3;
I2bis refI2 = c3;
C5 refC5 = c3;
C4 refC4 = c3;
I5 refI5 = c3;
C3
I2bis
C5
I3 refI3 = (I3) refI2;
C3 refC3 = (C3) refI2;
// interdit C5 n'est pas un sous-type de C3
// interdit C4 n'est pas un sous-type de C3
// interdit I5 n'est pas un sous-type de C3
57
Lionel Seinturier
C5 refC5 = (C5)refI2; // interdit C5 n'est pas un sous-type de C3
C4 refC4 = (C4)refI2; // interdit C4 n'est pas un sous-type de C3
I5 refI5 = (I5)refI2; // interdit I5 n'est pas un sous-type de C3
Java
9. Exceptions
58
Lionel Seinturier
9. Exceptions
Exceptions
Exceptions
Mécanisme permettant de signaler la fin de l'exécution d'une méthode
de façon "anormale"
Syntaxe
déclaration
class MonException extends Exception { ... }
levée
void foo() throws MonException {
... throw new MonException(); ...
}
récupération
try {
... // appel d'une méthode levant MonException
} catch( MonException me ) {
... // code lorsque MonException est levée
}
ex : division par 0, dépassement d'indice dans un tableau, fichier non trouvé, ...
• les exceptions sont des classes Java qui héritent de java.lang.Exception
• vocabulaire : une exception est levée, puis récupérée, éventuellement propagée
2 types d'exception
- runtime :
levées par la JVM, sous-classe de RuntimeException
communes à tous les prog. Java
- utilisateur : propre à un programme
Java
59
Lionel Seinturier
Java
60
Lionel Seinturier
9. Exceptions
Exceptions
Exemple
public class Math {
public static double div( double a, double b ) throws DivParZero {
if (b==0.0) throw new DivParZero("Division par zéro");
return a/b;
}
public static void main(String[] args) {
try { double res = div(12.0,0.0); }
catch( DivParZero dpz ) { dpz.getMessage(); }
}
}
class DivParZero extends Exception {
public DivParZero( String mess ) { super(mess); } }
- la division par 0 sur des int lève java.lang.ArithmeticException
- la division par 0 sur des float ou double renvoie une valeur spéciale "Infinity"
Java
61
Lionel Seinturier
Téléchargement