Академический Документы
Профессиональный Документы
Культура Документы
Concept de classe
Une classe est le support de l'encapsulation : c'est un ensemble de
données et de fonctions regroupées dans une même entité. Une classe est
une description abstraite d'un objet. Les fonctions qui opèrent sur les
données sont appelées des méthodes. Instancier une classe consiste à
créer un objet sur son modèle. Entre classe et objet il y a, en quelque
sorte, le même rapport qu'entre type et variable.
Java est un langage orienté objet : tout appartient à une classe sauf les
variables de type primitif.
Concept de classe
Pour accéder à une classe il faut en déclarer une instance de classe ou
objet.
La classe est la description d'un objet. Un objet est une instance d'une
classe. Pour chaque instance d'une classe, le code est le même, seules les
données sont différentes à chaque objet.
Définition d’une classe
Exemple:
Remarques:
Une méthode peut être déclarée private. Dans ce cas, elle n’est visible qu’à
l’intérieur de la classe où elle est définie.
Il est fortement déconseillé de déclarer des champs avec le mot clé public, cela
nuit à l’encapsulation des données.
Création d’objet
La création d’un objet (on parle d’instanciation) se fait avec le mot clé
new.
Exemple:
int a ; //réservation de mémoire pour contenir une
//variable entière
Exemple:
Un constructeur est une méthode qui porte le même nom que la classe
et qui est sans valeur de retour. Il peut disposer d’un nombre quelconque
d’arguments.
Le constructeur
public class Point1 {
private double x ,y; //champ x et y d’un objet point
//Constructeur pour initialiser un objet de type point
public Point1 ( double abs, double ord){
x = abs ;
y = ord ;
}
//Fonction permettant de déplcaer la position d'un point du plan
public void deplace (double dx, double dy){
x += dx ;
y += dy ;
}
public static void main(String A[]){
Point1 t = new Point1(3, 9);
t.deplace(5, 5);
System.out.println("x = "+t.x+" et y = "+t.y);
}
}
Quelques règles sur les constructeurs
Une classe peut comporter plusieurs constructeurs, ils se différencient par le
nombre et le type de leurs arguments.
Une classe peut ne pas disposer de constructeur, dans ce cas les objets serons
instancier avec le constructeur par défaut (constructeur sans arguments). Mais
dès qu’une classe possède un constructeur, le constructeur par défaut ne peut
plus être utilisé.
Une classe peut disposer d’un constructeur sans arguments (appelé souvent
pseudo-constructeur) qui est bien différent du constructeur par défaut.
Exemple:
public class Point1 {
private double x ,y;
public Point1 ( double abs, double ord){
x = abs ;
y = ord ;
}
public Point1 ajouter (Point1 p){
Point1 r = null ;
r.x = this.x + p.x ;
r.y = this.y + p.y ;
return r ;
}
}
Comparaison d’objets
Exemple:
public class Point1 {
private double x ,y;
public Point1 ( double abs, double ord){
x = abs ;
y = ord ;
}
public static void main(String A[]){
Point1 t1 = new Point1(3, 9);
Point1 t2 = new Point1(3, 9);
System.out.println(t1 == t2); //false
System.out.println(t1.equals(t2)); //false
}
Exemple:
public class MaClasse {
static int compteur = 0;
}
Variables de classes: le mot clé static
L'appartenance des variables de classe à une classe entière et non à un objet
spécifique permet de remplacer le nom de la variable par le nom de la
classe.
Exemple:
Une méthode statique ne peut pas agir sur des champs usuels, c’est-à-
dire non statiques.
Méthodes de classe
Exemple:
Remarquez que les noms des arguments du constructeurs et des attributs sont
identiques.
Appel d’un constructeur dans un autre
Un constructeur peut appeler un autre constructeur de la même classe avec le mot clé
this. L’objectif majeur de l’utilisation de this est de simplifier le code.
Exemple: la classe
public class Compte {
private int numero ;
private double solde ;
private String prop ;
Une classe interne est souvent utilisée pour définir une classe à l’endroit où
une seule autre classe en a besoin, pour définir des classes de type adapter.
Les classes internes simples
public class ClasseParente {
private int x = 10 , y = 20;
public int addition () { return (x + y); }
public class ClasseInterne {//DEBUT CLASSE INTERNE
static int p = 20; //erreur de compilation,
static final int k = 12; //constante statique
public int multiplier(){
return x*y + addition( ); }
} //FIN CLASSE INTERNE
public static void main(String [] args) {
ClasseParente ob_out = new ClasseParente();
//ClasseInterne ob_in0 = new ClasseInterne(); IMPOSSIBLE
ClasseInterne ob_in = ob_out.new ClasseInterne();
System.out.println (ob_in.multiplier());
// System.out.println (ob_out.multiplier());//ERREUR
// System.out.println (ob_in.addition ( )); IMPOSSIBLE
} }
Les classes internes simples
Remarques:
Une classe interne peut être déclarée avec n’importe quel modificateur
d’accès (public, private, protected, par défaut) et les modificateurs
abstract, final, static.
spécifie que l’objet créé est une instance de la classe interne associée à
l’objet résultant de l’instanciation d’une classe de haut niveau.
Exemple:
p et u ne peuvent pas être utilisés dans ClassLocale. Par contre , k est déclarée
finale donc on peut l’utiliser.
Les classes anonymes
Les classes anonymes (anonymous classes) sont déclarées immédiatement
après l'expression d'instanciation d'une classe, permettant directement
d'étendre ou d'implémenter respectivement la classe ou l'interface
instanciée.
Elles sont définies et instanciées à la volée sans posséder de nom.
new Classe([Liste d'arguments]) {... };
new Interface ( ) {... };
Les classes anonymes obéissent aux mêmes restrictions que les classes
locales et de plus, ne peuvent ni être abstraites (abstract) ni être statiques
(static).
Par contre, elles portent toujours implicitement le modificateur final.
En fait, aucun modificateur n'est permis dans une déclaration de classe
anonyme.
On verra l’utilité des classes anonymes en programmation évènementielle.