Académique Documents
Professionnel Documents
Culture Documents
O)
I- Introduction
L’orienté objet est un moyen de regrouper des variable pour pouvoir traiter des
ensemble comme des entités.
JAVA est un langage fortement orienté objet.
La « définition de l’objet » est appelée la classe et la variable contenant l’objet
est appelées l’instance.
CLASSES ET OBJETS
Un objet: est une entité rassemblant des données et du code travaillant sur ces
données.
Une Classe: est une description abstraite d’un objet (Type défini par
l’utilisateur).
3|Page
Un accesseur est une méthode permettant de récupérer le contenu d'une
donnée membre protégée. Pour accomplir sa fonction :
doit avoir comme type de retour le type de la variable à renvoyer.
ne doit pas nécessairement posséder d'arguments.
par convention le nom de l'accesseur est commencé par get.
Syntaxe :
public TypeDeMaVariable getMaVariable(){
return maVariable;
}
Exemple :
class Toto{
private int age;
public int getAge()
{
return age;
}
}
Le Mutateur
Un mutateur est une méthode permettant de modifier le contenu d'une donnée
membre protégée. Un mutateur, pour accomplir sa fonction :
doit avoir comme paramètre la valeur à assigner à la donnée membre. Le
paramètre doit donc être du type de la donnée membre
ne doit pas nécessairement renvoyer de valeur (il possède dans sa plus
simple expression le type void)
par convention le nom de mutateur est commencé par set
Syntaxe :
public void setMaVariable(TypeDeMaVariable maValeur)
{
maVariable = maValeur;
}
Exemple :
4|Page
public void setAge(int nouveauAge)
{
age = nouveauAge;
}
Indication :
L'intérêt principal d'un tel mécanisme est le contrôle de la validité des données
membres qu'il procure.
Exemple :
public int setAge(int nouveauAge)
{
if (nouveauAge < 200)
{
age = nouveauAge;
return 1;
}
else
return 0;
}
Les méthodes :
Une méthode est une fonction faisant partie d'une classe. Elle permet
d'effectuer des traitements sur (ou avec) les données membres.
La déclaration d'une méthode :
La déclaration d'une fonction se fait selon la syntaxe suivante :
type_de_donnee Nom_De_La_Methode(type1 argument1, type2
argument2, ...)
{
liste d'instructions ;
}
Remarque:
type_de_donnee représente le type de valeur que la méthode est sensée
retourner (char, int, float, void...)
5|Page
le nom de la méthode suit les mêmes règles que les noms de variables :
Les arguments sont facultatifs, mais s'il n'y a pas d'arguments, les
parenthèses doivent rester présentes
Il ne faut pas oublier de refermer les accolades
Une fois cette étape franchie, votre méthode ne s'exécutera pas tant que
l'on ne fait pas appel à elle quelque part dans la classe!
Appel de méthode :
Si la méthode retourne une valeur, il faut stocker cette valeur dans une variable
selon la syntaxe suivante :
Nom_variable=Nom_Objet.Nom_Méthode() ;
Exemple : N=Elv.Nombre() ;
Si le type de la méthode est Void, il faut appeler la méthode selon la syntaxe
suivante :
Nom_Objet.Nom_Méthode() ;
Exemple : Elv.Afficher() ;
Exemple Générale :
//Classe Principale
import java.util.Scanner;
class test{
public static void main (String[] args){
System.out.println("salut java");
eleve elv=new eleve();
Scanner r=new Scanner(System.in);
System.out.print("Taper votre code:");
p.setcd(r.nextInt());
p.afficher();
}
}
//Classe Eleve
public class eleve
{
6|Page
private int cd;
private String nom ;
//Accesseur du Cd
public int getcd()
{
return cd;
}
// Le Mutateur du Cd
public void setcd(int n)
{
cd=n;
}
//Accesseur du Nom
public int getNom()
{
return nom;
}
// Le Mutateur du Nom
public void setNom(String ch)
{
nom=ch;
}
// La méthode Afficher
public void afficher()
{
System.out.println("le code est:"+cd);
System.out.println("le nom est:"+nom);
}
}
Le mot clé static
7|Page
Le mot clé static s'applique aux variables et aux méthodes. Il permet d’éviter
l’instanciation à des variables et des méthodes
Exemple :
public class Cercle {
static float pi = 3.14;
float rayon;
}
La surcharge de méthode
En Java, on a la possibilité d'appeler plusieurs méthodes avec le même nom, à
condition que leurs arguments diffèrent (en type et/ou en nombre).
Ce principe est appelé surcharge de méthode. Il permet de donner le même
nom à des méthodes comportant des paramètres différents.
En effet, une méthode est déterminée par ce que l'on appelle sa signature,
c'est-à-dire :
son nom
ses paramètres
Il est ainsi possible de définir une méthode réalisant la même opération sur des
variables différentes en nombre ou en type :
Exemple :
int somme( int p1, int p2){
return (p1 + p2);
}
float somme( float p1, float p2){
return (p1 + p2);
}
float somme( float p1, float p2, float p3){
return (p1 + p2 + p3);
}
III- L’héritage
La notion d'héritage
8|Page
L'héritage est un mécanisme permettant de créer une nouvelle classe à partir
d'une classe existante en lui proférant ses propriétés et ses méthodes.
Ainsi, pour définir une nouvelle classe, il suffit de la faire hériter d'une classe
existante et de lui ajouter de nouvelles propriétés/méthodes.
Donc l'héritage consiste en la création d'une nouvelle classe dite classe
dérivée à partir d'une classe existante dite classe de base ou classe
parente.
Remarque :
Avec Java, l'arborescence est stricte, c'est-à-dire qu'une classe donnée ne peut
posséder qu'une seule superclasse. Par contre, une classe peut posséder un
nombre illimité de sous-classes.
L'héritage avec Java
Pour faire hériter une classe d'une superclasse, Java fournit le mot-clé
extends, c'est-à-dire que les quelques lignes de code ci-dessus sont
équivalentes à:
class Ccm extends superClasse {
// Corps de la classe
}
Le mot-clé super
Au même titre que le mot-clé this permet de faire référence à l'objet en cours,
le mot-clé super permet de désigner la superclasse, c'est-à-dire qu'à l'aide du
mot-clé super, il est possible de manipuler les données membres et les
méthodes de la superclasse.
Pour manipuler une proriété de la superclasse, il suffit d'utiliser la syntaxe
suivante :
super.nom_de_la_propriete
De la même façon, pour manipuler une méthode de la superclasse, il suffit
d'utiliser la syntaxe suivante :
super.nom_de_la_methode()
Enfin, il est possible de faire appel au constructeur de la classe parente en
fournissant des arguments au mot-clé super de la façon suivante :
9|Page
super(parametre1,parametre2,...)
La redéfinition :
On appelle redéfinition (en anglais « overriding ») d’une méthode, la possibilité
de définir le comportement d’une méthode selon le type d’objet l’invoquant, de
donner une nouvelle implémentation à une méthode héritée sans changer sa
signature.
...
System.out.println ("Gribouillis" ) ;
}}
...
}}
Attention :
On peut noter les redéfinitions de méthodes par @Override. Ceci est très utile
pour repérer des fautes de frappe dans le nom de la méthode : le compilateur
envoie un message d’erreur si la méthode ne redéfinit aucune méthode.
Exemple :
private int x , y ;
...
IV Les exceptions
La gestion des exceptions avec Java consiste à définir au sein d'une méthode
une clause "try{}" contenant les instructions qui risquent de provoquer une
exception et de la faire suivre immédiatement par une clause "catch{}"
contenant comme paramètre l'exception attendue précédée de son type (pour
une erreur mathématique ce sera ArithmeticException) et dont le contenu
sera une liste d'instruction à exécuter lorsque l'exception se produira.
class Nom_de_la_classe {
public static void main(String[] args) {
// Instructions inoffensives (affectations, ...);
try {
// Instructions susceptibles de provoquer des erreurs;
}
catch (TypeException e) {
// Instructions de traitement de l'erreur;
}
// Instructions si aucune erreur est apparue;
}
}
11 | P a g e
En cas de nécessité, on peut créer ses propres exceptions. Elles descendent des
classes Exception.
Il est préférable d'inclure le mot « Exception » dans le nom de la nouvelle classe
(classe de test l’erreur).
Exemple :
//Classe testErreur
public class testErreur extends Exception {
public testErreur() {
super();
}
public testErreur(String s) {
super(s);
}
}
//Classe Principale
public class classP {
public void méthode() throws testErreur {
if (condition)
throw new SaisieErroneeException("Message à afficher");
}
Exemple :obliger de taper n>=0
public void setcd(int n) throws testErreur
{
if (n <0)
throw new testErreur("Saisie erronee : valeur négative");
else
cd=n;
}
//Classe test
class Nom_de_la_classe {
public static void main(String[] args) {
12 | P a g e
try {
// Instructions susceptibles de provoquer des erreurs;
}
catch (testErreur e) {
System.out.println(e);
}
}
}
Exemple :
import java.util.*;
class test{
public static void main (String[] args){
try{
prt p;
Scanner r;
p=new prt();
r=new Scanner(System.in);
System.out.print("Taper votre code:");
p.setcd(r.nextInt());
}
catch (testErreur e){
System.out.println(e);
}
}
}
13 | P a g e