Chapitre 2 : Concepts OO en JAVA

classes du package auquel appartient la classe.



final : la méthode ne peut être modifiée (redéfinition lors de l'héritage interdite)

Page | 6

Chapitre 2 : Concepts OO en JAVA

 static : la méthode appartient simultanément à tous les objets de la classe (comme

une constante déclarée à l'intérieur de la classe). Il est inutile d'instancier la classe

pour appeler la méthode mais la méthode ne peut pas manipuler de variable

d'instance. Elle ne peut utiliser que des variables de classes.

Exemple

class MaClasse{ public int valeur ; public void afficheValeur() { System.out.println(" nombre entier = " + valeur); } public boolean estPositif (){ if (valeur>0) return true ; else return false ; } } Exercice

Complétez la classe rectangle par les méthodes suivantes :

- La méthode Affiche() permettant d’afficher les caractéristique d’un rectangle. - La méthode calcul_surface() retournant la surface d’un rectangle

class Rectangle {

private int longueur ;

int largeur ;

public void affiche( ) {

System.out.println( " la longueur est : "+longueur+ "la largeur est" : +largeur) ;

}

public int calcul_surface ( ) {

return (longueur*largeur) ;

}

}

Méthode main()

La méthode main de la classe principale, est exécutée la première lors de l'exécution d'un

programme Java. Elle doit avoir obligatoirement la signature suivante :

public static void main(String args[]) ou public static void main(String[] args)

Le nom de l'argument args peut être quelconque. C'est un tableau de chaînes de caractères

représentant les arguments de la ligne de commande.

Passage de paramètres

Page | 7

Chapitre 2 : Concepts OO en JAVA

Les arguments sont passés par valeur : la méthode fait une copie de la variable qui lui est locale.

Lorsqu'un objet est transmis comme argument à une méthode, ce n'est pas l'objet lui même qui

est passé mais une référence sur l'objet qui désigne son emplacement mémoire d'origine. La

référence est bien transmise par valeur et ne peut pas être modifiée mais l'objet peut être

modifié via un message (appel d'une méthode).

Pour transmettre des arguments par référence à une méthode, il faut les encapsuler dans un

objet qui prévoit les méthodes nécessaires pour les mises à jour.

Si un objet O transmet sa variable d'instance var en paramètre à une méthode mmm, deux

situations sont possibles :



si var est une variable primitive alors elle est passée par valeur : il est impossible

de la modifier dans mmm pour que var en retour contienne cette nouvelle valeur.



si var est un objet alors mmm pourra modifier l'objet en utilisant une méthode de

l'objet passé en paramètre.

Envoi de messages

Lorsqu'on demande à un objet d'exécuter l'une de ses méthodes, un message est envoyé.

Syntaxe :

nom_objet.nom_méthode(parametre, … ) ;

Si la méthode appelée ne contient aucun paramètre, il faut laisser les parenthèses vides.

2.3.

Constructeurs

Un constructeur est une méthode particulière permettant lors de la création des objets,

d’attribuer aux variables des valeurs initiales. Elle est systématiquement invoquée lors de la

création d'un objet.

 Le nom d’un constructeur, doit obligatoirement correspondre à celui

de la classe.

 Le constructeur est la seule méthode qui n’a pas de type de retour,

pas même void, donc il ne peut pas y avoir d'instruction return dans

un constructeur.

Page | 8

Chapitre 2 : Concepts OO en JAVA

La définition d'un constructeur est facultative. Si il n'est pas défini, la machine virtuelle appelle

un constructeur par défaut vide créé automatiquement. Dès qu'un constructeur est

explicitement défini, Java considère que le programmeur prenne en charge la création des

constructeurs et que le mécanisme par défaut, qui correspond à un constructeur sans

paramètres, est supprimé. Si on souhaite maintenir ce mécanisme, il faut définir explicitement

un constructeur sans paramètres.

Il existe plusieurs différents types de constructeurs :

 Le constructeur simple (par défaut) : ce type de constructeur ne nécessite pas de

définition explicite: son existence découle automatiquement de la définition de la classe.

Il attribue des valeurs par défaut.

Type de l’attribut

Valeur par défaut

boolean

char

int, byte, short, int long

float, double

objet

Exemple :

false

Caractère de code null

0

0.f ou 0.0

null

public class MaClasse { private int nombre ; public MaClasse() {} // constructeur simple

}

 Le constructeur avec initialisation fixe : il permet d’attribuer des valeurs prédéfinies

Exemple :

public class MaClasse { private int nombre ; public MaClasse() { nombre = 5;} // constructeur avec initialisation fixe

}

 Le constructeur avec initialisation des variables : pour ne pas attribuer les mêmes

valeurs aux attributs des objets lors de leur création, on peut les passer en paramètres

au constructeur.

Page | 9

Chapitre 2 : Concepts OO en JAVA

Exemple :

public class MaClasse { private int nombre ; // constructeur avec initialisation des variables public MaClasse(int valeur) { nombre = valeur; } } Remarque :

On peut définir plusieurs constructeurs dans une même classe

Exemple :

public class MaClasse { private int nombre ; public MaClasse() { nombre = 5;} public MaClasse(int valeur) { nombre = valeur; } } Exercice :

Définir 3 constructeurs pour la classe Rectangle :

- Un constructeur sans paramètres permettant d’initialiser la longueur à 10 et la largeur à

5.

- Un constructeur à deux paramètres qui permettent d’initialiser successivement la

longueur et la largeur du rectangle.

- Un constructeur à un paramètre, qui fait en sorte que la largeur reçoive la valeur du

paramètre passé au constructeur et que la longueur fasse deux fois la valeur de celui-ci.

class Rectangle{

private int longueur ;

private int largeur ;

Rectangle () {longueur =10 ; largeur = 5 ;} // constructeur sans paramètres

Rectangle (int x, int y) {longueur =x ; largeur = y ;} // constructeur avec 2 paramètres

Rectangle (int x) {longueur =2*x ; largeur = x ;} // constructeur avec 1 paramètre

public int calcul_surface ( ) {return (longueur*largeur) ;}

}

2.4.

Destructeurs

En Java, nous n’avons pas réellement besoin d’un destructeur. Un destructeur permet la

libération de la place mémoire occupée par un objet, Or, en java, le garbage collector appelle

automatiquement les destructeurs appelés finaliseurs (finalizers). Pour créer un finaliseur, il

faut redéfinir la méthode finalize() héritée de la classe Object.

Page | 10

Chapitre 2 : Concepts OO en JAVA

3. Objets et Instanciation

Une classe peut être considérée comme un "moule", et on crée des objets par "moulage" à partir

du modèle donné par la classe.

Cette opération s'appelle l'instanciation, car l'objet créé représente une instance de sa classe.

Celle-ci permet donc de reproduire autant d'exemplaires -- d'instances -- que nécessaire.

Notation UML

Rectangle

Représentation explicite de la classe

« Instance of »

Relation d’instanciation

R1 : Rectangle

Nom de la classe

Longueur =10

Largeur =5

Nom de l’objet

Chaque instance ainsi créée possède son propre exemplaire de chacune des variables définies

dans la classe ; on les appelle ses variables d'instance.

Exemple

Si je crée deux objets de type Rectangle, ils auront chacun leur propre variable longueur et leur

propre variable largeur, etc.

Rectangle

R1 : Rectangle

R2 : Rectangle

R3 : Rectangle

Longueur =10

Largeur =5

Longueur =7

Largeur =3

Longueur =9

Largeur =4

Un objet se caractérise par :



ses attributs : ceux-ci portent des valeurs attachées à l’objet. L’ensemble de ces

valeurs à un instant donné constitue l’état de l’objet à cet instant.



ses méthodes : ceux-ci permettent à l’objet d’effectuer des actions et de changer

son état. Elles définissent son comportement et ses réactions.

Page | 11

Chapitre 2 : Concepts OO en JAVA

 Une identité qui permet de le distinguer des autres objets, de manière unique.

3.1.

Création d’objet (Instanciation)

La création d’un objet à partir d’une classe est appelée instanciation. Cet objet est une instance

de sa classe.

Une instanciation se décompose en trois phases

1) Allocation de l’espace mémoire nécessaire et initialisation des attributs en mémoire, à

l’image d’une structure.

2) Appel des méthodes particulières : les constructeurs qui sont définies dans la classe

3) Renvoi d’une référence sur l’objet (son identité) maintenant créé et initialisé.

Référence (handles)

 Pour désigner des objets on utilise des variables d’un type particulier : les références.

 Une référence contient l’adresse d’un objet : pointeur vers la structure de données

correspondant aux attributs (variables d’instance) propres à l’objet.

 Comme un pointeur une référence contient l’adresse d ’une structure. Mais à la

différence des pointeurs la seule opération autorisée sur les références est l’affectation

d’une référence de même type.

 Par défaut, à la déclaration une référence vaut null : elle ne pointe sur aucun objet.



Déclarer une référence ne crée pas d’objet : une référence n’est pas un objet, c’est un

nom pour accéder à un objet.

 Un objet peut posséder plusieurs références. Mais un handle ne peut par contre désigner

qu'un seul objet.

 Pour créer une référence d'objet il suffit de faire précéder le nom que l'on donne à un

objet par le nom de la classe que l'on instancie.

Exemple :

Rectangle r1 ;⟺Rectangle r1=null ;

Syntaxe générale de création d’objet

Nom_Classe nom_Objet ;

nom_Objet=new nomClasse(<liste d’arguments>) ;

Ou en une seule déclaration

Nom_Classe nom_Objet = new nomClasse(<liste d’arguments>) ;

Pour instancier un objet on passe par les 2 étapes suivantes :

1. Déclarer une référence sur l’objet que l’on veut créer. Java y stockera l’adresse de l’objet.

Page | 12

Chapitre 2 : Concepts OO en JAVA

2. Allouer la mémoire nécessaire à l’objet et l’initialiser. cette opération se fait par

l’intermédiaire de l’opérateur new auquel on passe l’appel au constructeur de la classe

désirée.

Exemple

MaClasse m; m = new MaClasse(); ou en une seule déclaration MaClasse m = new MaClasse();

Exercice

Créez deux rectangles, ayant comme longueur 10 et comme largeur 5, l’un en vous basant sur le

constructeur sans paramètres précédemment définit et l’autre en se basant sur le constructeur à

2 paramètres.

Rectangle r 1; Rectangle r2 ;

r1 = new Rectangle (10,5); r2 = new Rectangle (); Ou bien, effectuer les deux étapes en même temps :

Rectangle r1= new Rectangle (10, 5);

Rectangle r2= new Rectangle ();

Remarque :

 L'affectation de l'opérateur new à la référence ne signifie en aucun cas que l'on stocke

l'objet dans la référence, cela indique que la référence pointe vers l'objet nouvellement

créé!

 En Java, tous les objets sont instanciés par allocation dynamique. Dans l'exemple, la

variable r1 contient une référence sur l'objet instancié.

 Si r1 désigne un objet de type Rectangle l'instruction r2 = r1 ne définit pas un nouvel

objet mais r2 et r1 désignent tous les deux le même objet.

 Si l'opérateur new n'obtient pas l'allocation mémoire nécessaire, il lève l'exception

OutOfMemoryError.

 Si on utilise le type String, un objet String est automatiquement créé lors de l'utilisation

d'une constante chaîne de caractères sauf si celle-ci est déjà utilisée dans la classe. Ceci

permet une simplification dans l'écriture des programmes.

Page | 13

Chapitre 2 : Concepts OO en JAVA

public class TestChaines1 {

public static void main(String[] args) { String chaine1 = "bonjour"; String chaine2 = "bonjour"; System.out.println("(chaine1 == chaine2) = " + (chaine1 == chaine2) ); } } Résultat :(chaine1 == chaine2) = true

public class TestChaines2 {

public static void main(String[] args) { String chaine1 = "bonjour"; String chaine2 = new String("bonjour"); System.out.println("(chaine1 == chaine2) = " + (chaine1 == chaine2) ); }} Résultat :(chaine1 == chaine2) = false

 L’objet est détruit lorsque il n’ y a plus des références pour cet objet (sortie d’un bloc de

visibilité, etc....).

 La création des objets se fait généralement dans les classes qui utilisent la classe à

instancier et plus particulièrement dans la méthode qui constitue le point d’entrée

« main ». On va distinguer 2 cas :

 cas1 : la classe à instancier ne possède pas des constructeurs

class Rectangle {

private int longueur ;

private int largeur ;

public int calcul_surface ( ) {return (longueur*largeur) ;}

public void initialise (int x, int y) { longueur =x ; largeur = y ;}

public void initialise (int x) { longueur =2*x ; largeur = x ;}

}

public class Test_Rect {

public static void main (String [] argv) {

Rectangle r1, r3;

Rectangle r2 = new Rectangle ();

r1 = new Rectangle ();

r3 = new rectangle (5); /*erreur car la classe ne définit pas des constructeurs*/ ……… } }

Page | 14

 cas2 : la classe à instancier possède au moins un constructeur

Chapitre 2 : Concepts OO en JAVA

class Rectangle{

private int longueur ;

private int largeur ;

Rectangle (int x, int y) {longueur =x ; largeur = y ;} // constructeur avec 2 paramètres

Rectangle (int x) {longueur =2*x ; largeur = x ;} // constructeur avec 1 paramètre

public int calcul_surface ( ) {return (longueur*largeur) ;}

}

Rectangle r1 = new Rectangle (10,4) // juste car on a un constructeur avec 2 paramètres.

Rectangle r1 = new Rectangle (10) // juste car on a un constructeur avec 1 paramètre.

Rectangle r1 = new Rectangle ()

// faux car on a pas un constructeur sans paramètres. Le constructeur par défaut n’est plus valable

car la classe possède au moins un constructeur.

3.2.

La création d'objets identiques

Exemple :

MaClasse m1 = new MaClasse(); MaClasse m2 = m1; m1 et m2 contiennent la même référence et pointent donc tous les deux sur le même objet : les

modifications faites à partir d'une des variables modifient l'objet.

Pour créer une copie d'un objet, il faut utiliser la méthode clone() : cette méthode permet de

créer un deuxième objet indépendant mais identique à l'original. Cette méthode est héritée de la

classe Object qui est la classe mère de toutes les classes en Java.

Exemple :

MaClasse m1 = new MaClasse(); MaClasse m2 = m1.clone(); m1 et m2 ne contiennent plus la même référence et pointent donc sur des objets différents.

3.3.

Les références et la comparaison d'objets

Les variables déclarés de type objet ne contiennent pas un objet mais une référence vers cet

objet. Lorsque l'on écrive c1 = c2 (c1 et c2 sont des objets), on copie la référence de l'objet c2

Page | 15

dans c1 : c1 et c2 réfèrent au même objet (ils pointent sur le même objet). L'opérateur ==

compare ces références. Deux objets avec des propriétés identiques sont deux objets distincts :

Chapitre 2 : Concepts OO en JAVA

Exemple :

Rectangle r1 = new Rectangle(100,50); Rectangle r2 = new Rectangle(100,50); if (r1 == r1) { ... } // vrai

if (r1 == r2) { ... } // faux

Pour comparer l'égalité des variables de deux instances, il faut munir la classe d'une méthode à

cet effet : la méthode equals héritée de Object.

Pour s'assurer que deux objets sont de la même classe, il faut utiliser la méthode getClass()

de la classe Object dont toutes les classes héritent.

Exemple :

(obj1.getClass().equals(obj2.getClass())

3.4.

Manipulation des objets

Manipuler signifie accéder aux données d'un objet ou appeler une méthode de cet objet (lui

envoyer un message). Dans les deux cas, on utilise en Java l'opérateur "." séparant le nom de

l'objet du nom du membre auquel on veut accéder.

3.4.1. L’accès aux attributs

- Pour accéder aux attributs de l’intérieur de la classe, il suffit d’indiquer le nom de

l’attribut que l’on veut y accéder.

- Pour accéder de l’extérieur de la classe, on utilise la syntaxe suivante :

<nom_Objet>.<nom_attribut>

3.4.2. L’accès aux méthodes

- A l’intérieur d’une classe, les méthodes de cette classe seront appelées en indiquant le

nom et la liste des paramètres effectifs de la méthode.

- A l’extérieur de la classe, l’invocation d’une méthode se fait comme suit :

<nom_Objet>.<nom_méthode> ( [<liste des arguments effectifs>] ) ;

- La liste des arguments effectifs doit concorder en nombre et en type avec la liste des

arguments formels.

Page | 16

Chapitre 2 : Concepts OO en JAVA

Exemple

Dans la méthode « main » de la classe Test_Rect, on peut appeler les méthodes ainsi :

Rectangle r = new Rectangle (10,5) ;

r.affiche() ; // Appel de la méthode affiche

int s = r.calcul_surface() ; //Appel de la méthode calcul_surface

r.setlong(20) ; //Appel de la méthode setlong pour modifier la longueur

3.5.

Membres statiques et Autres mots clés (final, this, null)

3.5.1. Les attributs statiques

Les attributs statiques sont des attributs marqués par le mot clé « static », ils désignent les

attributs communs entre tous les objets.

On accède à un attribut statique via :

- Une instance quelconque de la classe.

- Le nom de la classe directement.

Exemple :

public class MaClasse() { static int compteur = 0; } Public class Test{ public static int main(String[] args) { MaClasse m = new MaClasse(); int c1 = m.compteur; int c2 = MaClasse.compteur;// c1 et c2 possèdent la même valeur. }}

Exercice :

On souhaite sauvegarder le nombre des objets crées et attribuer à chaque objet son numéro

d’ordre. Pour satisfaire à cet objectif, on a certainement besoin d’un attribut de type statique qui

est commun à tous les objets et qui sauvegarde le nombre d’objets déjà crées.

On va reformuler l’exemple de la classe Rectangle, en ajoutant un attribut statique appelé count

qui va indiquer le nombre d’objets crées et un attribut qui s’appelle num qui indique le numéro

d’ordre d’un objet, cet attribut n’est pas statique car sa valeur est propre à chaque objet.

Page | 17

Chapitre 2 : Concepts OO en JAVA

class Rectangle

{static int count =0;

private int longueur, larg;

private int num;

Rectangle (int x, int y) {

Count++ ; num = count ; longueur = x ; largeur = y ;}

……. }

class Test_Rec {

public static void main (String [] args)

{System.out.println (“Nombre des objets = ” + Rectangle.count) ; // affiche 0

Rectangle r = new Rectangle (10,5);

System.out.println (“Nombre des objets = ” + Rectangle.count) ; // affiche 1

System.out.println (“Numéro de l’objet crée = ” + r.num) ; //affiche 1

Rectangle r3= new Rectangle (14);

System.out.println (“Nombre des objets = ” + Rectangle.count) ; //affiche 2

System.out.println (“Numero de l’objet crée = ” + r3.num) ; //affiche 2

Rectangle r2 = new Rectangle();

System.out.println (“Nombre des objets = ” + Rectangle.count) ; //affiche 3

System.out.println (“Numero de l’objet crée = ” + r2.num) ; //affiche 3

}}

3.5.2. Les méthodes statiques

S’appellent aussi méthodes de classe, elles désignent les méthodes dont les actions concernent la

classe entière et non pas un objet particulier.

De même, l’accès à ces méthodes ne nécessite pas la création d’un objet de la classe, car on peut

appeler directement la méthode à travers le nom de la classe. On peut utiliser aussi ces

méthodes statiques pour manipuler des données statiques

Exemple

On va définir une classe Math qui peut contenir des fonctions mathématiques. De préférence, on

déclare ces méthodes comme étant statiques pour pouvoir les utiliser sans instancier des objets

de cette classe.

Page | 18

Chapitre 2 : Concepts OO en JAVA

Public class Math {

static double PI = 3.14 ; //c’est un attribut statique

static double getPI () {Return (PI) ;} // La méthode statique manipule des attributs statiques

static double diametre (double r) {return (PI*2*r)} // c’est une méthode statique

static double puissance (double x) {return (x*x);} // c’est une méthode statique

}

class Test_Math {

public static void main (String [] args) {

double i= Math.puissance (6);

System.out.println (“I=” + i);

Math m = new Math ();

double d = m.diametre (5.1);

System.out.println (“Le diametre = “ + d) ;}}

On remarque que l’accès à une méthode se fait de deux manières soit à travers le nom de la

classe (le premier appel de la méthode power), soit à travers un objet de la classe (Le deuxième

appel de la méthode statique rayon).

3.5.3. Le mot clé « final »

Le mot clé final s'applique aux variables, aux méthodes et aux classes.

Une variable qualifiée de final signifie que la variable est constante. Une variable déclarée final

ne peut plus voir sa valeur modifiée. On ne peut déclarer de variables final locales à une

méthode. Les constantes sont qualifiées de final et static.

Exemple :

public static final float PI = 3.1416f;

 Une méthode final ne peut pas être redéfinie dans une sous classe. Une méthode

possédant le modificateur final pourra être optimisée par le compilateur car il est garanti

qu'elle ne sera pas sous classée.

 Lorsque le modificateur final est ajouté à une classe, il est interdit de créer une classe qui

en hérite.

Page | 19

Chapitre 2 : Concepts OO en JAVA



Il existe 2 types d’utilisations des attributs finaux : ou bien on initialise la valeur de la

variable dès la déclaration, ou bien on initialise plus tard cette variable et son contenu ne

sera jamais modifié.

Remarque : Le mot clé final peut aussi être utilisé avec les méthodes et les classes. Cette

utilisation va être détaillée dans les autres chapitres.

3.5.4. Le mot clé « this »

Cette variable sert à référencer dans une méthode l'instance de l'objet en cours d'utilisation. this

est un objet qui est égale à l'instance de l'objet dans lequel il est utilisé.

La référence « this » peut être utile :

- Lorsqu’une variable locale (ou un paramètre) cache, en portant le même nom, un attribut

de la classe.

- Pour appeler un constructeur depuis un autre constructeur.

Exemple public maclasse{ private int nombre1; private int nombre2;

public maclasse(int nombre1) { this.nombre1 = nombre1; // variable de classe = variable en paramètre du constructeur } public maclasse(int nombre1, int nombre2) { this(nombre1) this.nombre2 = nombre2; } }

 This est aussi utilisé quand l'objet doit appeler une méthode en se passant lui-même en

paramètre de l'appel.

Exercice

class Rectangle {

private int longueur, largeur ;

private String couleur ;

Rectangle (int lo, int largeur)

{ longueur = lo ;

this.largeur = largeur ;

//1er cas : même nom entre le paramètre et l’attribut

}

Rectangle (int lo, int lar, String coul) {

this (lo, lar);// 2 ème cas : appel d’un constructeur à partir d’un autre

couleur = coul;}

}

Page | 20

Chapitre 2 : Concepts OO en JAVA

3.5.5. Le mot clé « null »

L'objet null est utilisable partout. Il n'appartient pas à une classe mais il peut être utilisé à la

place d'un objet de n'importe quelle classe ou comme paramètre. Il permet de représenter la

référence qui ne référence rien. C’est aussi la valeur par défaut d’initialisation des attributs

représentant des références.

null ne peut pas être utilisé comme un objet normal : il n'y a pas d'appel de méthodes et aucune

classe ne puisse en hériter.

Le fait d'initialiser une variable référent un objet à null permet au ramasseur de miettes

(garbage collector) de libérer la mémoire allouée à l'objet.

Exemple

class Test_Rec {

public static void main (String [] args) {

Rectangle r;

if (r==null)

r= new Rectangle (10,12);

r.affiche();}}

4. Classe interne

Java autorise la définition de classes dans une classe. Une classe interne peut avoir accès aux méthodes et attributs de la classe englobante public class A { int a ; class B { … A.this.a = 12 ; } } Une classe interne est définie à l’intérieur d’une autre classe au même niveau qu’une méthode ou

attribut.

 Les classes internes sont visibles uniquement par les méthodes de la classe dont laquelle

sont définies.

 Les éléments de la classe qui englobe les classes internes même privés sont accessibles

aux classes internes (Sauf les classes internes statiques n’ont pas ce privilège).

Page | 21

Chapitre 2 : Concepts OO en JAVA

 On ne peut pas accéder directement aux attributs et aux méthodes de la classe interne.

Toutefois, on peut les appeler indirectement à travers la classe externe qui l’englobe.

Exemple :

La classe Point présentant le centre d’un rectangle est une classe interne à la classe Rectangle.

Class Rectangle {

private int longueur;

private int larg;

Rectangle(int l, int a){

longueur= l;

larg= a; }

class Point {

int x, y;

Point ( int x1, int y1)

{x=x1; y=y1;}

void affichep ()

{System.out.println ("Le centre se trouve dans " + x + " " + y); }

}

Point p = new Point (10,5);

void affiche () {

System.out.println ("Longueur=" + longueur + " Largeur =" + larg); }

}

class test_Rec{

public static void main(String [] args){

Rectangle r = new Rectangle (4,6);

Point p = new Point(12,14); //faux car la classe Point est invisible de l’extérieur

r.p.affichep(); //on peut accéder à une méthode de la classe interne à travers l’attribut

p de l’objet r.

r.affiche() ;

}

}

Remarque :

Une classe interne statique ne peut accéder qu'aux membres statiques de la classe externe.

Page | 22

Chapitre 2 : Concepts OO en JAVA

Exemple :

1) Classe interne statique :

public class ClasseExterne {

private int compteur = 0;

private static String nom = "Exemple";

static class ClasseInterne

{

private int index = 0;

public ClasseInterne() //Constructeur de la classe interne

{

System.out.println("Création d'un objet dans "+nom);

// compteur ne peut être accedé

}

} }

2) Classe interne non statique:

public class ClasseExterne

{

private int compteur = 0;

class ClasseInterne

{

private int index = 0;

public ClasseInterne()

{

compteur++; /*On peut accéder à l’attribut compteur car la classe interne est non

statique*/

}

}

}

5. Package

5.1.

Définition d’un Package

Un package est le regroupement logique et physique d’un