Vous êtes sur la page 1sur 13

Chapitre II : Programmation Orientée Objet (P.O.

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).

Créer une Classe:


public class Nom_Classe
{
//Attributs
//Methodes
}
Création d'objets
Les objets peuvent être créés à l'aide du mot clé new suivi du nom de la classe
sur lequel l‘objet sera basé, comme suit :
Nom_Classe object1
object1 = new Nom_Classe();
OU Nom_Classe object1 = new Nom_Classe();
1|Page
Accéder aux membres d'un objet
L'accès aux membres d'un objet se fait grâce au nom de l'objet, suivi d'un point
puis du nom du membre.
Par exemple : Nom_Objet.Nom_membre = Valeur;
Le mot clé this
Le mot clé this permet de désigner l'objet dans lequel on se trouve, c'est-à-dire
que lorsque l'on désire faire référence dans une méthode à l'objet dans lequel
elle se trouve, on utilise this.
L'objet courant this est en réalité une variable système qui permet de désigner
l'objet courant.
Ainsi, lorsque l'on désire accéder à une donnée membre d'un objet à partir
d'une méthode du même objet, il suffit de faire précéder le nom du membre par
this..
II- Les Méthodes De CLASSE
Les méthodes de classe sont de 4 types
 Les constructeurs
 Les méthodes d'accès (accessor) de la forme getXXX qui fournissent des
informations relatives à l'état d'un objet, c'est-à-dire des valeurs de
certains champs sans les modifier
 Les méthodes d'altération (mutator) de la forme setXXX qui modifient
l'état d'un objet, c'est-à-dire les valeurs de certains champs
 Les méthodes simples
CONSTRUCTEURS :
Quand une instance d'une classe d'objet est créée, une fonction particulière est
exécutée. Cette fonction s'appelle le constructeur.
Le constructeur est une méthode portant le même nom de la classe et sans
valeur de retour. Le constructeur de classe est de 2 types
 Le constructeur sans paramètres (par défaut ):
Un constructeur sans paramètres
public Equation()
{
2|Page
//Instructions ;
}
 Le constructeur avec paramètres (initialisation) :
Un constructeur avec paramètres
public Equation(double X2, double X1, double X0)
{
coeffX2 = X2;
coeffX1 = X1;
coeffX0 = X0;
}
Remarque :
 un constructeur porte le même nom que la classe dans laquelle il est
défini
 un constructeur n'a pas de type de retour (même pas void)
 un constructeur peut avoir des arguments
 la définition d'un constructeur n'est pas obligatoire lorsqu'il n'est pas
nécessaire
Les niveaux d'accès :
Java définit trois niveaux d'accès pour les variables d'instances (données
membres) et les méthodes :
 public : un élément public est accessible de partout et sans aucune
restriction. Certaines classes (comme la classe principale main) doivent
obligatoirement être déclarées publiques (pour pouvoir exécuter
l'application...)
 protected : un élément protected (protégé) est accessible uniquement
aux classes d'un package et à ses classes filles
 private : un élément private (privé) est accessible uniquement au sein de
la classe dans laquelle il est déclaré. Ces éléments ne peuvent être
manipulés qu'à l'aide de méthode spécifiques appelés
Les accesseurs

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.

public class Homme extends personne {

...

public void dessiner () {

System.out.println ("Gribouillis" ) ;

}}

public class Leonard extends Homme {

...

public void dessiner () {

System.out.println (" Joconde " ) ;

}}

Attention :

Il ne faut pas confondre la redéfinition (en anglais « overriding ») et la


surcharge (en anglais « overloading »)

Annotation pour la redéfinition :

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 :

public class Point {

private int x , y ;

...

@Override public String toString( ) {


10 | P a g e
return " ( " + 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.

Voici la syntaxe type d'une classe gérant des exceptions :

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;
}
}

Les exceptions personnalisées


Pour générer une exception, il suffit d'utiliser le mot clé throw.
Si l'on veut générer une exception dans une méthode avec throw, il faut
l'indiquer dans la déclaration de la méthode, en utilisant le mot clé throws suivi
par le nom de la classe testErreur.

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

Vous aimerez peut-être aussi