CLASSE ET OBJETS EN JAVA - Cours java classes et objets POO
I- CLASSES
1- Définition
Une classe est caractérisée par :
·
Un nom
·
Une composante statique
(les données) : des champs (attributs ou propriétés)
·
Une composante dynamique
(fonctions) : des méthodes représentant le comportement des objets de la
classe. Elles manipulent les champs des objets.
2- représentation graphique
Une classe
est représentée avec la notation UML (Unifed Modeling Language).
1- Syntaxe java
(implémentation en java)
i Le nom du fichier
doit être identique à celui de la classe.
Le fichier : Point.java Le
fichier : TestPoint.java
class Point
{
//Attributs
float
x;
float
y;
//Méthodes
void initialiser(float X, float Y){
x=X;
y=Y;
}
void afficher(){
System.out.println("x="+x+"\ty="+y);
}
float distance()
{
float d;
d=(float)Math.sqrt(x*x+y*y);
return d;
}
}
|
class TestPoint
{ public
static void main(String args[]) {
//déclaration d'un objet de type Point
Point
p1;
//Création d'un point p1
p1=new Point();
//p1.x=10; p1.y=20;
p1.initialiser(10,20); //appel de
la méthode initialiser
p1.afficher(); //appel de la méthode afficher
System.out.println("Distance entre O et p1:" +
p1.distance());
//déclaration d'un autre objet de type Point
Point
p2;
//Création d'un point p2
p2=new Point();
p2.initialiser(30,40);
p2.afficher();
System.out.println("Distance entre O et p2:" +
p2.distance());
}
}
|
1- Notion de constructeur
- Un constructeur est une méthode d’initialisation d’un objet.
- Un constructeur est une méthode :
- Ayant le même nom que la classe
- Sans type de retour
- Toute classe possède au
moins un constructeur. Si le programmeur ne l’écrit pas, il en existe
un par défaut (constructeur sans paramètres de code vide).
- Une classe peut avoir plusieurs constructeurs.
Exemple :
class Point
{
//Attributs
float x;
float y;
//Constructeur
Point (float X, float Y){
x=X;
y=Y;
}
//Méthodes
void
afficher(){
System.out.println("x="+x+"\ty="+y);
}
float distance()
{
float
d;
d=(float)Math.sqrt(x*x+y*y);
return d;
}
}
|
class TestPoint
{ public static void main(String args[])
{
//déclaration d'un objet de type Point
Point
p1;
//Création d'un point p1
P1=new Point() ; //erreur le constructeur Point() n’est pas
défini
p1=new Point(10,20);
p1.afficher(); //appel de la méthode afficher
System.out.println("Distance entre O et p1:" +
p1.distance());
//déclaration d'un autre objet de type Point
Point
p2;
//Création d'un point p2
p2=new Point(30,40);
p2.afficher();
System.out.println("Distance entre O et p2:" +
p2.distance());
}
}
|
Remarque :
Une classe peut avoir plusieurs constructeurs de signatures différentes
(surcharge). Le bon constructeur est déclenché selon le nombre, le type et
l’ordre des paramètres, c’est le mécanisme ‘’Look UP’’.
Exemple :
Exemple :
Créer la classe suivante :
Personne
|
Nom : chaine
Prénom : chaine âge : entier |
Personne {}
Personne (chaine, chaine, entier) Personne(Int) Afficher () |
1- Ecrire une classe TestPersonne
qui permet de créer 3 personnes en utilisant les différents constructeurs, puis
afficher leurs informations.
class Personne
{
//Attributs
String nom;
String prenom;
int age;
//constructeurs
//constructeur
1
Personne(){}
//constructeur 2
Personne(String nom, String prenom, int age) { this.nom
= nom;
this.prenom
= prenom;
this.age
= age;
}
//constructeur
3
Personne (int age)
{this.age=age;}
//Méthodes
void Afficher (){
System.out.println(nom+"\t"+prenom+"\t"+age);
}
}//Fin
classe Personne
|
class TestPersonne
{
public static void main(String
args[]) {
//déclaration
de 3 Personnes
Personne p1,p2,p3;
//Création
des personnes
p1=new Personne() ; //Appel
de constructeur 1
p2=new Personne(20); //Appel
de constructeur 3
//Appel de
constructeur 2
p3=new Personne("Salim","Elhachmi",20);
//Affichage
des informations
p1.Afficher();
p2.Afficher();
p3.Afficher();
}
} }//Fin classe TestPersonne
|
I- Objets
1- Définition
·
Un Objet est une instance d’une classe.
·
Il se conforme à la description
de sa classe.
·
Il admet une valeur qui lui
est propre.
·
Il est possible de lui
appliquer toutes les méthodes définies dans la classe.
·
Tout objet admet un
identifiant qui le distingue des autres objets.
2- Notation UML
Chaque Objet
(p1, p2, p3) instance de la classe Point possède sa propre valeur (son propre x
et son propre y)
1- Création d’objet
·
La création s’un objet à
partir d’une classe s’appelle : instanciation
·
L’objet créé s’appel :
instance de la classe.
·
Pour créer un Objet :
o Déclaration de l’objet
o Instanciation et initialisation de l’objet en utilisant
l’operateur new suivi du constructeur de la classe.
Ex :
Point p ; //Déclaration
de l’objet
p=new
Point(10,20) ; //instanciation.
(p est une instance de Point)
Article plus récent Article plus ancien