Cours L3 Java Concept Poo

ENI Concepts de POO en Java RV 1
1- L'HERITAGE SIMPLE Ceci renverra une erreur de compilation car un type

Mere n'est pas un type Fille : un objet de type Fille
Définition contient des méthodes et des attributs qu'il n'y a pas
dans la classe Mere.
L'héritage permet de spécialiser une classe qui
possédera non seulement les propriétés et méthodes Transtypage implicite
de son unique mère mais d'autres méthodes
spécifiques ou redéfinies. Dans l'objet fille, on trouve: Si une classe Fille dérive d'une classe Mere, une
• Des méthodes ou propriétés qui surchargent, instance de la classe Fille sera de type Fille bien
c'est-à-dire redéfinissent celles de la classe entendu mais sera également de type Mere par
mère. héritage.
• Les propriétés et méthodes de la classe mère
qui n'ont pas été surchargées.
• De nouvelles méthodes ou propriétés. Compléments sur le transtypage
Pour spécifier qu'une classe dérive d'une autre classe, Le transtypage d'un objet d'un type vers un autre type
on utilise l'opérateur extends lors de la déclaration de permet de modifier la façon dont on "voit" l'objet mais
la classe: ne le modifie pas. Pour transtyper un objet vers un
autre type, la notation est la même que pour le cast
class Voiture extends Vehicule{ primitif: (MaClasseDestination)monObjet
} Il est possible de transtyper un objet vers un type
ascendant ( le type de sa classe mère ou la mère de
La classe mère commune à toutes les autres classes sa mère etc...) même si ce transtypage est fait de
est la classe Object. Tous les objets dérivent façon implicite. En effet, un objet Voiture par exemple
implicitement d'Object et les déclarations suivantes est implicitement un Vehicule - nul besoin de le
sont identiques: transtyper en Vehicule pour accéder à ses propriétés et
méthodes.
class Voiture{
} Dans certains cas cependant, il peut se trouver que les
méthodes ou les propriétés portent le même nom dans
la classe et dans ses classes ascendantes. Il existe
class Voiture extends Object{ alors des règles précises. Observons l'exemple
} suivant:
class Vehicule{
Types et affectation int iAge=10;
int getAge(){
Si mere est de type 'Mere' et fille de type 'Fille ' et que return iAge;
la classe Fille dérive de la classe Mere, }
}
Fille fille=new Fille();
Mere mere=new Mere(); class Voiture extends Vehicule{
int iAge=20;
faire int getAge(){
return iAge;
}
mere=fille;
}
signifie que la référence mere est maintenant une
Instancions un objet de type Voiture: Voiture v1=new
référence sur objet de type Fille et plus sur Mere. Cette
Voiture();
opération est acceptée car l'objet fille était de type
Mere par héritage.
Il est possible de transtyper v1 en Vehicule pour
accéder à la propriété iAge de la classe Vehicule et
mere instanceof Fille; renverra vrai.
non celle de Voiture:
En conséquence, mere peut maintenant appeler des
((Vehicule)v1).iAge pointe vers le iAge de Voiture.
méthodes de la classe Fille. A contrario, il est
impossible de faire :
A contrario, il n'est pas possible d'accéder à la
méthode getAge() de la classe Vehicule à partir de v1:
fille=mere;
1
((Vehicule)v1).getAge() pointe vers la méthode sous-classes non abstraites :

getAge() de la classe Voiture et non de la classe abstract nomDeMéthode (<arguments>);
Vehicule malgré le cast. ce n'est qu'une signature
• une classe est abstraite ne peut être
Ainsi, le transtypage permet d'accéder aux propriétés instanciée.
de la classe vers laquelle nous transtypons l'objet mais • une classe est abstraite peut contenir des
les méthodes utilisées seront toujours les plus méthodes non abstraites et des déclarations
spécialisées, quoiqu'il arrive. de variables ordinaires.
• Une classe abstraite peut être dérivée en une
Il est également possible de transtyper un objet d'un sous-classe
type vers un type plus spécialisé mais seulement dans
certaines conditions: Une méthode abstraite est une simple déclaration sans
implémentation. Lorsqu'une classe dérive d'une classe
Vehicule monVehicule=new Vehicule(); abstraite, elle doit alors implémenter toutes les
Vehicule monVehicule2=(Voiture)monVehicule; méthodes abstraites de celle-ci. Cela permet lors d'un
renverra une exception projet d'éviter d'"oublier" d'implémenter des méthodes
communes.
mais il est possible de faire:
Exemple 1
Voiture v1=new Voiture();
Vehicule monVehicule=(Vehicule)v1; //v1 est vu Dans la classe Véhicule, nous déclarons la méthode
comme un véhicule seGarer() en méthode abstraite. Alors, si Voiture dérive
Voiture v2=(Voiture)monVehicule; //on cast vers un de Véhicule , la classe Voiture doit implémenter la
type plus spécialisé mais cela fonctionne car méthode seGarer() pour décrire sa façon de se garer.
monVehicule était de type Voiture. v1 et v2 La classe Moto doit implémenter la méthode seGarer()
référençient le même objet pour décrire la sienne.
abstract class Vehicule{

……..
2. CLASSES ABSTRAITES abstract void seGarer();
}
class Voiture extends Vehicule{
……….
Dans certains cas, nous pouvons désirer implémenter
void seGarer(){……….}
deux objets proches possédant une partie de
}
méthodes et de propriétés en commun comme Voiture
class Moto extends Vehicule{
et Moto. Certaines de ces méthodes comme rouler()
……….
sont totalement identiques d'un objet à l'autre alors que
void seGarer(){……….}
certaines autres diffèrent comme la méthode seGarer()
}
qui est différente pour une Voiture et pour une Moto.
Pour ce faire, l'OO introduit la notion de classe
Exemple 2
abstraite.
abstract public class FormeGeometrique1 {
Définition double posX, posY;
void deplacer(double x,double y) {
Une classe abstraite est une classe non-instanciable posX=x;
dont une partie des méthodes sont abstraites et restent posY=y;
à implémenter. }
void afficherPosition() {
Remarques: System.out.println("position : ("
+posX+","+posY+")"); }
• une classe est abstraite si elle contient au abstract double surface() ;
moins une méthode abstraite ; elle ne peut pas abstract double perimetre() ;
être instanciée, mais ses sous-classes non }
abstraites le peuvent.
• abstract class NomDeClasseAbstraite { ... } o Cette classe est abstraite car ses méthodes
une classe abstraite est déclarée avec le surface et perimetre sont abstraites, c.a.d. non
modificateur abstract. définies.
• une méthode abstraite ne contient pas de o Une telle classe n'est pas instanciable
corps, mais doit être implémentée dans les
2
Rectangle7.java public static void main (String args[]) {

Rectangle7 rect;
public class Rectangle7 Cercle7 cerc;
extends FormeGeometrique1 { rect = new Rectangle7(9,3,10,20);
double largeur, hauteur; System.out.print("rectangle ");
public Rectangle7() { rect.afficherPosition();
posX=0; posY=0; largeur=0; hauteur=0; System.out.print("Surface rectangle : "+rect.surface());
} System.out.print("Perimetre rectangle :
public Rectangle7(double x, double y, "+rect.perimetre());
double la, double lo) {
posX=x; posY=y; largeur=la; hauteur=lo; System.out.println("surface de r1 : "
} +r1.surface()+"\nsurface de r2 : "
double surface() { +r2.surface());
return largeur * hauteur; r1.doubler();
} System.out.println("surface de r1 "+
double perimetre() { "apres doubler: "+r1.surface());
return 2*(largeur + hauteur); r2.doubler(true,false);
void doubler() { System.out.println("surface de r2 apres"
largeur = 2 * largeur; +" doubler(true,false): "+r2.surface());
hauteur = 2 * hauteur;
}
void doubler(boolean doublerLargeur, cerc = new Cercle7(43,32,100);
boolean doublerHauteur) { System.out.print("cercle ");
if (doublerLargeur) cerc.afficherPosition();
largeur = 2 * largeur; System.out.print("Surface cercle : "+cerc.surface());
if (doublerHauteur) System.out.print("Perimetre rectangle :
hauteur = 2 * hauteur; "+cerc.perimetre());
}
} cerc.deplacer(66,88);
} System.out.print("cercle maintenant ");
cerc.afficherPosition();
o La classe Rectangle7 hérite de la
classe abstraite.
}
o Elle définie toutes ses méthodes, en
}
particulier celles abstraites héritées.
Donc elle n'est pas abstraite. Une classe abstraite peut être héritée d’une autre
classe abstraite. Par exemple,
• Nos objets seront probablement tous de

Cercle7.java couleur et de poids différents..
• Ici, nous partons du principe que tous nos
public class Cercle7 extends FormeGeometrique1 { animaux mangent de la viande. La méthode
double rayon; manger() sera donc définie dans la classe
Cercle7(double x, double y, double r) { Animal.
posX=x; posY=y; rayon=r; } • Idem pour la méthode boire(). Ils boiront tous
double surface() { de l'eau.
return Math.PI*Math.pow(rayon, 2.);
• Ils ne crieront pas et ne se déplaceront pas de
}
la même manière. Nous emploierons donc des
double perimetre() { return 2*rayon*Math.PI;
méthodes polymorphes et déclarerons les
}
méthodes deplacement() et crier() abstraites
}
dans la classe Animal.
o Une classe abstraite permet, entre-autres, de

définir les caractéristiques communes de La figure suivante représente le diagramme des
plusieurs classes d'objets. classes des objets. Ce diagramme permet de voir si
une classe est abstraite : son nom est alors en italique.
Prog50.java
public class Prog50 {

3
Canin.java
public abstract class Canin extends Animal {

void deplacement() {
System.out.println("Je me déplace en meute !");
}
}
Chien.java
public class Chien extends Canin {
public Chien(){
public Chien(String couleur, int poids){

this.couleur = couleur;
this.poids = poids;
}
Voici les codes Java pour les classes correspondants.
void crier() {
Animal.java System.out.println("J'aboie sans raison !");
}
abstract class Animal { }
protected String couleur; Loup.java

protected int poids;
protected void manger(){ public class Loup extends Canin {

System.out.println("Je mange de la viande.");
} public Loup(){
protected void boire(){ }

System.out.println("Je bois de l'eau !");
} public Loup(String couleur, int poids){
abstract void deplacement(); this.poids = poids;
}
abstract void crier();
void crier() {
public String toString(){ System.out.println("Je hurle à la Lune en faisant
String str = "Je suis un objet de la " + this.getClass() ouhouh !");
+ ", je suis " + this.couleur + ", je pèse " + this.poids; }
return str; }
}
}
Felin.java
Lion.java
public abstract class Felin extends Animal {
void deplacement() { public class Lion extends Felin {
System.out.println("Je me déplace seul !");
} public Lion(){
4
}
3. INTERFACES
public Lion(String couleur, int poids){
this.poids = poids; Notion d'héritage multiple via interface
}
Définition
void crier() {
System.out.println("Je rugis dans la savane !");
} Certains langages orientés objet comme le C++
} disposent de l'héritage multiple: une classe peut dériver
de plusieurs classes. Ce concept peut amener à des
incohérences dans certains cas. D'autres langages
comme Java n'acceptent que l'héritage simple.
Tigre.java
Cependant, il peut être intéressant dans certains cas
d'hériter de méthodes ou de propriétés communes à
public class Tigre extends Felin { deux classes mères ou à leur ascendance. Pour
contourner ce problème, nous disposons des
public Tigre(){ } interfaces. Une interface est une sorte de classe de
public Tigre(String couleur, int poids){ déclaration dans laquelle les méthodes sont
this.couleur = couleur; seulement déclarées et les constantes fixées.
this.poids = poids; Cependant, dans une interface, il n'y a aucune
} implémentation. Toute classe ne peut dériver que d'une
classe mère mais implémenter une ou plusieurs
void crier() { interfaces. Si elle implémente une interface, elle doit
System.out.println("Je grogne très fort !"); implémenter toutes les méthodes de l'interface ou alors
} être abstraite.
}
Composition d'une interface
Chat.java Une interface peut contenir:
public class Chat extends Felin { • des déclarations de méthodes de la forme:

public Chat(){ }
public Chat(String couleur, int poids){ [<modificateur>] <type/void> <nomMéthode>
this.couleur = couleur; ([<paramètres formels>]); par exemple ,
this.poids = poids;
} void faire(int i);
Ces méthodes sont implicitement abstraites et
void crier() { publiques.
System.out.println("Je miaule sur les toits !");
} • des constantes de la forme: [<modificateurs>]
} static final int i=10;
Une classe déclarée abstraite n'est pas « instanciable Création d'une interface
», mais rien ne l'oblige à comprendre des méthodes [<modificateurs d'accès>] interface PropriétéPrivée{
abstraites. boolean maMethode(int i);
int autreMethode(float f);
Code : Java - Sélectionner static final int i=10;
1 public class Test { }
2 public static void main(String[] args) {
3 Loup l = new Loup("Gris bleuté", 20);
Implémentation d'une interface
4 l.boire();
class Voiture implements PropriétéPrivée{
5 l.manger();
boolean maMethode(int i){
6 l.deplacement();
.....
7 l.crier();
}
8 System.out.println(l.toString());
int autreMethode(float f){
9 }
...
10 }
5
} void rouler();
}
void freiner();
Remarques : }
On a défini ici ce qu'on attend d'un objet de type

En fait, une interface est une classe abstraite dont véhicule.
toutes les méthodes sont abstraites et dont tous les
attributs sont constants (des constantes, voir le mot-clé On peut maintenant donner une ou plusieurs
final). implémentations de cette interface grâce à l'utilisation
du mot clef implements :
• Représente un "contrat", ce qu'on attend d'un
objet package cours;
• Une classe peut implémenter plusieurs
interfaces (permettant un héritage multiple, en public class Velo implements Vehicule {
les séparant par des virgules après le mot //Champs
implements).
• Une interface n'a pas de constructeurs private String marque;
• Une interface ne peut avoir de champs sauf si private int rayonRoue;
ceux-ci sont statiques.
• Une interface peut être étendue (par extends) //Constructeurs
par une ou plusieurs autre(s) interface(s).
• [<modificateurs d'accès>] interface public Velo(String marque, int rayonRoue)
<nomInterface> [implements <interfaces>] { {
<constantes> <méthodes abstraites> } this.marque = marque;
o les modificateurs d'accés de l'interface this.rayonRoue = rayonRoue; }
peuvent être public ou (sans)
package ; //Methodes
o les constantes sont explicitement ou
implicitement static et final : public void rouler() {
 [<modificateurs>] static final //Coder ici la manière dont le vélo roule
<type> <nomVariable> = }
<valeur> ;
 [<modificateurs>] <type> public void freiner() {
<nomVariable> = <valeur> ; //Coder ici la manière dont le vélo freine
o les méthodes sont explicitement ou }
implicitement abstraites :
 [<modificateur>] <type> //Autres méthodes propres à Velo
<nomMéthode> ([<paramètres }
formels>]);
 [<modificateur>] abstract package cours;
<type> <nomMéthode>
([<paramètres formels>]); public class Auto implements Vehicule {
//Champs
• Une classe qui implémente une interface doit
définir le corps de toutes ses méthodes
private String marque;
abstraites.
private int poids;
• les sous-classes d'une super-classe qui
implémente une interface, héritent (et peuvent
//Constructeurs
redéfinir) des méthodes implémentées.
• public Auto(String marque, int poids)
{
Exemple 1 this.marque = marque;
this.poids = poids;
//Définition de l'interface }
package cours; //Methodes
public interface Vehicule { public void rouler() {

//Coder ici la manière dont l'auto roule
6
}  elle ne peut avoir que des

variables static final (des
public void freiner() { constantes !)
//Coder ici la manière dont l'auto freine  Une telle interface n'est pas
} instanciable, et n'est pas une
classe.
//Autres méthodes propres à Auto.
} Rectangle8.java
Dans cet exemple, nous avons donné deux public class Rectangle8
implémentation de Vehicule. extends Rectangle7
Conséquences : implements Dessinable1 {
public Rectangle8(double x, double y, double la, double lo)
• Ces 2 objets peuvent être vus comme des {
véhicules, c'est ce qu'on appelle le super(x,y,la,lo);
olymorphisme. }
• Par ce biais, on introduit une couche public void dessiner(Graphics g) {
d'abstraction dans notre programmation ce qui g.drawRect((int)posX, (int)posY,
la rend beaucoup plus flexible. (int)largeur, (int)hauteur);
}
Discussion }
o La classe Rectangle8 hérite de la classe

Si, par exemple, nous avions une classe Personne
possédant une méthode conduire(Vehicule v), on peut Rectangle7 et implémente l'interface
alors écrire : Dessinable1.
o Elle définie toutes les méthodes de l'interface :
dessiner
Personne p = new Personne();
p.conduire(new Velo()); //comme la méthode attend un
Vehicule en argument, on peut passer tout objet Texte8.java
implémentant cette interface.
p.conduire(new Auto()); //idem import java.awt.Graphics;
public class Texte8
On peut "instancier" un Vehicule par le biais de ses implements Dessinable1 {
implémentations : String texte;
int posX, posY;
public Texte8(String t,int x,int y) {
Vehicule v = new Auto();
texte=t; posX=x; posY=y;
Vehicule t = new Velo();
}
public void dessiner(Graphics g) {

Dans ce cas v et t sont vus comme des Vehicule et, par
g.drawString(texte,
conséquent, on ne peut appeler sur ces objets que les
(int)posX,(int)posY);
méthodes définies dans l'interface Vehicule.
}
}
Héritage presque multiple
Exemple 1
Dessinable1.java
import java.awt.Graphics;
public interface Dessinable1 {
public void dessiner(Graphics g);
}
o Ceci est une interface :

 toutes ses méthodes sont
abstraites (c.a.d. non définie)
7
o Rectangle8 hérite déja de la superclasse

Rectangle7
o En Java, l'héritage est simple : une classe
n'hérite que d'une superclasse
o l'interface permet de contourner cette limite :
Rectangle8 hérite de Rectangle7 et
impléménte Dessinable1 Exemple 2 : L'héritage chez les interfaces
o La technique de l'implémentation d'interface
permet de réaliser un héritage multiple sans
Une interface peut dériver d'une autre interface et
ses inconvénients.
même de plusieurs. Dans ce cas, la première classe à
o Ajoutons qu'une classe peut implémenter
implémenter une interface devra également
plusieures interfaces, et qu'une interface peut implémenter les méthodes des mères de l'interface.
hériter d'une autre interface.
L’héritage multiple est autorisé pour les interfaces :
Prog51.java interface MonInterfaceB {

void f();
import java.awt.Graphics; }
import java.applet.Applet;
public class Prog51 extends Applet { interface MonInterface1 extends MonInterfaceB {
Dessinable1 TabADessiner[]; void f1();
public void init() { }
Rectangle8 rect =
new Rectangle8(19.0,33.0,100.0,150.0); interface MonInterface2 extends MonInterfaceB{
Texte8 text = void f2();
new Texte8("HELLO WORLD !", 50,50); }
TabADessiner = new Dessinable1[2];
TabADessiner[0] = rect; interface MonInterface extends MonInterface1,
TabADessiner[1] = text; MonInterface2 {
} void fd();
public void paint(Graphics g) { }
for (int i=0; i<TabADessiner.length; ++i)
TabADessiner[i].dessiner(g); Les classes implémentant MonInterface doivent
} implémenter f(), f1(), f2(), et fd().
}
Une interface peut servir à définir des constantes :
EXECUTION
interface Mois{
• l'applet dessine tous les objets "dessinable" du final int JANVIER = 1, FERVRIER = 2, …
tableau DECEMBRE = 12 ;
}
• le tableau contient des objet du type
Dessinable1
Paramètres méthode
la seule méthode mise en oeuvre est dessiner (de
Dessinable1) Contrairement à de nombreux langages de
programmation, Java n’autorise pas de paramètres qui
soient des méthodes. Les interfaces peuvent servir à
simuler ce fonctionnement :
interface X{ class maClasse implements X{

void f(){ ...
} public void f(){
} ...
}
class C{ }
...
public void m(X x){ C c = new C() ;
... maClasse mc = new
8
MaClasse() ; }
x.f() ; c.m(mc) // la méthode m va
} appeler la méthode f définie Exemple 1
} dans maClasse.
package horloge;
import java.awt.*;
4. CLASSES INTERNES import java.awt.event.*;
import java.text.DateFormat;
import java.util.Date;
Une classe est dite interne lorsque sa définition est import javax.swing.*;
située à l'intérieur de la définition d'une autre classe.
Trois raisons justifient l'emploi de classes internes : public class Fenêtre extends JFrame {
private JLabel heure = new JLabel();
1. Les méthodes des classes internes peuvent public Fenêtre() {
accéder aux attributs de la classe conteneur, à super("Horloge");
partir de l'envergure où elles sont définies, y setBounds(100, 100, 180, 80);
compris les attributs qui pourrait être des setDefaultCloseOperation(EXIT_ON_CLOSE);
données privées. heure.setFont(new Font("Arial",
2. Les classes internes peuvent être cachées aux Font.BOLD+Font.ITALIC, 32));
autres classes du même paquetage, ce qui heure.setHorizontalAlignment(JLabel.CENTER);
offre une meilleure protection sur des données add(heure);
sensibles. setResizable(false);
3. Les classes internes anonymes sont utiles setVisible(true);
pour définir des callbacks (des appels de new Minuteur();
méthode automatique) sans écrire beaucoup }
de code.
public static void main(String[] args) {
Une classe interne possède les mêmes attributs de new Fenêtre();
visibilité qu'une variable ou une méthode (public, }
private, etc). Elle a un accès complet sur tous les
attributs des ses classes englobantes. private class Minuteur implements ActionListener {
Une classe interne peut être définie comme membre private Timer minuteur = new Timer(1000, this);
d'une classe , ou à l'intérieur d'une méthode public Minuteur() {
minuteur.start();
1) comme membre d’une classe }
public void actionPerformed(ActionEvent e) {
public class classe1 { heure.setText(DateFormat.getTimeInstance(Date
// attributs1 Format.MEDIUM).format(new Date()));
// constructuer1 }
classe1 (…..) }
{ }
……. La classe Minuteur est une classe interne, qui plus est,
Classe2 p2= new Classe2(..) ; privée. Seule les classes internes peuvent être privées.
// new Classe2(..) ; Il est donc impossible à l'extérieur de la classe Fenêtre
} d'atteindre la classe Minuteur et d'en créer une
instance.
// methodes 1
void methode1 (….)
{
……. 2) à l’intérieur d’une méthode (Classe interne
Classe2 p2= new Classe2(..) ; locale) pour protéger encore plus votre code
// new Classe2(..) ; source, et lorsque vous avez besoin d'une
} seule instance de la classe interne, il est
également possible de définir les classes
public class classe2 { localement à l'intérieur d'une seule méthode.
// attributs2
// constructeur2
// methode 2 pouvant accéder aussi à tous les attributs public class classe1 {
de la classe englobante Classe1 // attributs1
} // Fin Classe2 private int x ;
9
// constructuer1 heure.setText(DateFormat.getTimeInstance(Da
classe1 (…..) teFormat.MEDIUM).format(new Date()));
{ if (beep) Toolkit.getDefaultToolkit().beep();
……. }
methode1(….); }
new Minuteur();
} }
}
// methodes 1
void/type methode1 (….)
{ Exemple 3 ( classe interne locale)
…….
public class classe2 { import java.util.*;
// attributs2
// constructeur2 interface Personne {
// methode 2 public String identite();
} // Fin Classe2 }
new Classe2(….); public class Avion {

// ou bien return new Classe2(….); Personne[] listePilotes = new Personne[3] ;
// ou bien return new Classe2(….).methode2(..); int nbrePilotes=0;
} //: Fin methode 1 public Personne creePilote() {
final String nomParDefaut = new String("Guynemer");
} // Fin Classe1 class Pilote implements Personne {
private String nom ;
Exemple 2 private String prenom ;
private Date dateNaissance ;
package horloge; Pilote(String unNom, String unPrenom, Date uneDate)
{ // le constructeur
import java.awt.*; nom = nomParDefaut ;
import java.awt.event.*; prenom = unPrenom ;
import java.text.DateFormat; dateNaissance = uneDate ;
import java.util.Date; if (nbrePilotes < 3)
import javax.swing.*; listePilotes[nbrePilotes++] = this ; // il y a un pilote de
public class Fenêtre extends JFrame { plus
private JLabel heure = new JLabel(); }
public String identite() {
public Fenêtre() { return nom+ prenom + dateNaissance.toString() ;
super("Horloge"); }
setBounds(100, 100, 180, 80); } // fin de la classe Pilote
setDefaultCloseOperation(EXIT_ON_CLOSE); return new Pilote("St-Exupery","Antoine",new
heure.setFont(new Font("Arial", Date(1905,3,5));
Font.BOLD+Font.ITALIC, 32)); } // fin de la méthode creePilote
heure.setHorizontalAlignment(JLabel.CENTER); }
add(heure);
setResizable(false); 5. LES CLASSES ANONYMES
lancerMinuteur(true);
setVisible(true); Les classes anonymes (anonymous classes) sont
} déclarées immédiatement après l’expression
d’instanciation d’une classe , permettant
public static void main(String[] args) { directement d’étendre ou d’implémenter
new Fenêtre(); respectivement la classe ou l’interface instanciée.
}
new Classe([Liste d’argument]){
private void lancerMinuteur(final boolean beep) { // Instructions de la classe anonyme…
class Minuteur implements ActionListener { };
private Timer minuteur = new Timer(1000, this);
public Minuteur() {
minuteur.start(); Supposons que l'on dispose d'une classe A.
}
public void actionPerformed(ActionEvent e) { Il est possible de créer un objet d'une classe dérivée de
A, en utilisant une syntaxe de cette forme :
10
return resultat;
}
public floatdivision(float a, float b) {

if(b!=0);
System.out.println(resultat);
return resultat;
Tout se passe comme si nous avions procédé ainsi : }
else
return 0;
}
};
obj.addition(x,y);
obj.soustraction(x,y);
obj.multiplication(x,y);
obj.division(x,y);
}
new Interface(){ }
// Instructions de la classe anonyme…
}; Classe Calcul {
public float addition (float a,float b){
La déclaration de la classe anonyme doit être toujours return =a+b;
suivie d’un point virgule immédiatement après son {
accolade fermante, sans quoi une erreur de public float soustraction(float a, float b) {
compilation serait générée. return =a-b;
}
Les classes anonymes obéissent aux mêmes public float multiplication(float a, float b) {
restrictions que les classes locales et de plus, ne return =a*b;
peuvent ni être abstraites (abstract) ni }
être statiques (static). public floatdivision(float a, float b) {
Par contre, elles portent toujours implicitement le return a / b;
modificateur finale. }
}
En effet, aucun modificateur n’est permis dans une
déclaration de classe anonyme. Dans le cas d’une implémentation, la classe anonyme
doit définir chacune des méthodes abstraites de
Dans le cas d’une extension, la classe anonyme doit l’interface à l’instancier, sinon une erreur de
outrepasser une à plusieurs des méthodes de la classe compilation se produira.
à instancier. La surcharge et la définition d’une
nouvelle méthode ne sont pas permis si non elles
provoqueraient une erreur de compilation .
class ClasseExterne {
static int x =10;
class classeExterne{ static int y =12;
static int x =10 ;
static int y= 12; public static void main(string[] args){
public static void main (String [] args){
Calcul obj = new calcul(){ Icalcul obj =new ICalcul() {
Float resultat; public float addition() {
public float addition (float a,float b) resultat = (float)(x+y);
resultat =a+b; return(float)(x+y);
System.out.println(resultat); }
return resultat; public float soustraction() {
} resultat = (float)(x-y);
public float soustraction(float a, float b) { system.out.println(resultat);
resultat =a-b; return resultat
return resultat; public float multiplication() {
} resultat = (float)x*(floaty);
public float multiplication(float a, float b) { system.out.println(resultat);
resultat =a*b; return resultat
11
public float division() {

if(y!=0); } // fin de la méthode creePilote
system.out.println(resultat);
return resultat public static String yatilUnPiloteDansLAvion(Avion2
} monAvion) {
else Personne unPilote = monAvion.creePilote();
return 0; // l'appel à creePilote instancie un objet respectant
} l'interface Personne.
}; // Il est donc maintenant possible de lui demander de
décliner son identité :
obj.addition(); return unPilote.identite();
obj.soustraction(); }
obj.multiplication();
obj.division (); }
}
}
Interface ICalcul{ 6. LES CLASSES MEMBRES STATIQUES
float addition ;
float soustraction;
float multiplication; 1.1 Définition des classes membres statiques
float division;
}
Une classe membre statique est une classe java définie
Une classe anonyme ne peut déclarer explicitement dans la partie déclaration des membres d'une autre
un constructeur, le compilateur Java fournissant classe qui la contient (nommée classe englobante), puis
automatiquement un constructeur anonyme pour ce qualifiée par le modificateur static.
genre de classe.
Une classe membre statique est instanciable.
Une classe anonyme ne possède pas d’identificateur et
est immédiatement utilisée lors de l’instanciation de la Une classe membre statique ne peut pas être associée à
classe ou l’interface concernée. un objet instancié de la classe englobante .
Il est aussi possible de définir des classes anonymes Syntaxe :

internes. En voici un exemple d'utilisation :
public class Enveloppe {
import java.util.Date; < membres genre attributs >
< membres genre méthodes >
interface Personne { < membres genre classes membres statiques >
public String identite(); }
}
public class Avion2 {

public static void main(String args[]) {
Une classe membre statique est analogue aux autres
System.out.println(yatilUnPiloteDansLAvion(new membres statiques de la classe dans laquelle elle est
Avion2())); déclarée (notée Enveloppe ici) :
}
public Personne creePilote() { // Ceci est une
méthode de la classe Avion
// Notre classe est maintenant anonyme
// La seule chose que l'on sait c'est qu'elle respecte
l'interface Personne
return new Personne() {
private String nom = "Antoine";
private String prenom = "St-Exupery";
private Date dateNaissance = new
Date(3,5,1905);
public String identite() {
return nom+ prenom + dateNaissance.toString() ;
}
}; // fin de la classe Anonyme.
notons le point-virgule, obligatoire.
12
nom de la classe englobante pour accéder aux

membres (raccourcis d'écriture) :
On peut dans une autre classe, instancier un objet de

classe statique, à condition d'utiliser le qualificateur de
visibilité qu'est le nom de la classe englobante afin
d'accéder à la classe interne. Une classe membre
statique se comporte en fait comme une classe
ordinaire relativement à l'instanciation : Exemple :
Ci-dessous la classe membre statique clasMembStat1
Soit par exemple, la classe Autre souhaite déclarer et contient une méthode "public void meth( )", qui
instancier un objet Obj0 de classe public invoque la méthode de classe(statique) void meth12
clasMembStat1 : de la classe englobante Enveloppe1, en lui passant un
paramètre effectif statique int a1. Nous écrivons 4
appels de la méthode meth12( ) :
class Autre { public static class clasMembStat1 {

Enveloppe1.clasMembStat1 Obj0 = new
Enveloppe1.clasMembStat1( ) ; public void meth( ){
....... meth12(a1);
} Enveloppe1.meth12(a1);
meth12(Enveloppe1.a1);
Soit en plus à instancier un objet local Obj1 dans une Enveloppe1.meth12(Enveloppe1.a1);
méthode de la classe Autre : }
}
class Autre{
Enveloppe1.clasMembStat1 Obj0 = new Nous notons que les 4 appels de méthodes sont
Enveloppe1.clasMembStat1() ; strictement équivalents, en effet ils différent
void meth( ){ uniquement par l'utilisation ou la non utilisation de
Enveloppe1.clasMembStat1 Obj1 = new raccourcis d'écriture.
Enveloppe1.clasMembStat1() ;
}
} o Le quatrième appel :
"Enveloppe1.meth12(Enveloppe1.a1)" est celui qui
1.2 Caractérisation d'une classe membre statique utilise le nom de la classe englobante pour accéder
aux membres statiques comme le prévoit la syntaxe
Une classe membre statique accède à tous les générale.
membres statiques de sa classe englobante qu'ils o Le premier appel : "meth12(a1)" est
soient publics ou privés, sans nécessiter d'utiliser le celui qui utilise la syntaxe particulière aux classes
13
membres statiques qui autorise des raccourcis

d'écriture.
Une classe membre statique n'a pas accès aux

membres d'instance de la classe englobante :
Remarque importante :
Un objet de classe interne statique

ne comporte pas de référence à l'objet
de classe externe qui l'a créé.
14

Cours L3 Java Concept Poo

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours L3 Java Concept Poo

Transféré par

Droits d'auteur :

Formats disponibles

ENI Concepts de POO en Java RV 1

1- L'HERITAGE SIMPLE Ceci renverra une erreur de compilation car un type

((Vehicule)v1).getAge() pointe vers la méthode sous-classes non abstraites :

abstract class Vehicule{

Rectangle7.java public static void main (String args[]) {

• Nos objets seront probablement tous de

o Une classe abstraite permet, entre-autres, de

public class Prog50 {

public abstract class Canin extends Animal {

public class Chien extends Canin {

public Chien(String couleur, int poids){

protected String couleur; Loup.java

protected void manger(){ public class Loup extends Canin {

protected void boire(){ }

Chat.java Une interface peut contenir:

public class Chat extends Felin { • des déclarations de méthodes de la forme:

On a défini ici ce qu'on attend d'un objet de type

package cours; //Methodes

public interface Vehicule { public void rouler() {

}  elle ne peut avoir que des

o La classe Rectangle8 hérite de la classe

public void dessiner(Graphics g) {

o Ceci est une interface :

o Rectangle8 hérite déja de la superclasse

Prog51.java interface MonInterfaceB {

interface X{ class maClasse implements X{

new Classe2(….); public class Avion {

public floatdivision(float a, float b) {

public float division() {

Il est aussi possible de définir des classes anonymes Syntaxe :

public class Avion2 {

nom de la classe englobante pour accéder aux

On peut dans une autre classe, instancier un objet de

class Autre { public static class clasMembStat1 {

membres statiques qui autorise des raccourcis

Une classe membre statique n'a pas accès aux

Un objet de classe interne statique

Vous aimerez peut-être aussi