DEFINITION DE CLASSE EN JAVA Page 1 /8

DEFINITION DE CLASSES EN JAVA

---------------------

1. Définir sa propre classe

1.1. Structure de la définition d’une classe en Java
<accessibilité> class <nom_de_la_classe>
{
Définition des champs
Ecriture des méthodes
}

Les mot-clés représentant l’accessibilité sont définis comme suit :

 public : toute classe peut accéder directement au champ. En général public est utilisé
quand il s’agit de constantes auxquelles il faut accéder à partir d’autres classes;
 private : l’accès au champ est possible seulement aux méthodes appartenant à la
classe ;
 protected : l’accès au champ est permis seulement aux classes et aux sous-classes du
paquetage ;

Ecriture des méthodes

La structure de l’écriture d’une méthode se présente comme suit:

<accessibilté> <type> <nom_de_la_méthode>(liste des paramètres)

{
Instructions
}

 L’accessibilité (public, private, protected) ;

 Le type : il s’agit du type de donnée retournée (int, double, String, etc.) ; si aucune
valeur n’est retournée, on écrit void ;
 La liste des paramètres : les arguments sont transmis par paramètres. Il s’agit de la
déclaration de variables pour que la méthode puisse recevoir les arguments. Si aucun
argument n’est transmis à la méthode, alors la liste des paramètres reste vide.

Typologie des méthodes d’une classe

Parmi les différentes méthodes que comporte une classe, on a souvent tendance à distinguer :
 Les constructeurs ;
 Les méthodes d’accès (getxxx) qui fournissent les informations relatives à l’état d’un
objet, c’est-à-dire aux valeurs de certains champs sans les modifier ;
 Les méthodes d’altération (setxxx) qui modifient l’état d’un objet, donc les valeurs de
certains de ses champs.
 Les autres méthodes

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC

DEFINITION DE CLASSE EN JAVA Page 2 /8

Un exemple de définition de classe

Client

String nom
int age
String adresse
String telephone
void setNom(String NouvNom)
void setAge(int unAge)
void setAdresse(String NouvAdr)
void setTelephone(String NouvTel)
String getNom()
int getAge()
String getAdresse()
String getTelephone()

public class Client

{
// Définition des champs
private String nom;
private int age;
private String adresse;
private String telephone;
// Méthodes d'accès
public String getNom()
{
return nom;
}

public int getAge()

{
return age;
}

public String getAdresse()

{
return adresse;
}

public String getTelephone()

{
return telephone;
}

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC

DEFINITION DE CLASSE EN JAVA Page 3 /8

// Méthodes d'altération
public void setNom(String unNom)
{
nom = unNom;
}

public void setAge(int unAge)

{
age = unAge;
}

public void setAdresse(String unAdr)

{
adresse = unAdr;
}

public void setTelephone(String unTel)

{
telephone = unTel;
}

Une fois la classe Client conçue, elle pourra être utilisée dans une autre classe.

Création d’une instance de classe :

Client codjo = new Client() ;

On peut également procéder comme suit :

Client codjo ;
codjo = new Client();

Utilisation de la classe Client

public class TestClient

{
public static void main(String[] args)
{
// Créer une instance de la classe Client
Client unClient = new Client();

System.out.println("Le nom du client est: " + unClient.getNom());

System.out.println("L'âge du client est: " +
unClient.getAge() + " ans");

// utilisation des méthodes d'altération

unClient.setNom("KEKEREKE");
unClient.setAge(70);
unClient.setAdresse("01 BP 475 Cotonou");

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC

DEFINITION DE CLASSE EN JAVA Page 4 /8

unClient.setTelephone("90957401");
// Définir les variables pour contenir les champs
String nomClient, adrClient, phoneClient;
int ageClient;
// Utilisation des méthodes d'accès
nomClient = unClient.getNom();
adrClient = unClient.getAdresse();
phoneClient = unClient.getTelephone();
ageClient = unClient.getAge();
// Affichage des champs
System.out.println("Le nom du client est: " + nomClient);
System.out.println("L'âge du client est: " + ageClient + " ans");
System.out.println("L'adresse du client est: " + adrClient);
System.out.println("Le numéro de téléphone du client est: " +
phoneClient);
// On pourrait afficher les champs sans passer
// par des variables intermédiaires
System.out.println("Le nom du client est: " + unClient.getNom());
System.out.println("L'âge du client est: " +
unClient.getAge() + " ans");
System.out.println("L'adresse du client est: " +
unClient.getAdresse());
System.out.println("Le numéro de téléphone du client est: " +
unClient.getTelephone());
System.out.println("La somme: " + unClient.getAge() + unClient.getAge()) ;
}
}

Mise en œuvre d’un programme comportant plusieurs classes

 Un fichier source par classe

 Plusieurs classes dans un même fichier source

Pour mettre plusieurs classes dans un même fichier source, il faut respecter certaines
contraintes :
 Un fichier source peut contenir plusieurs classes mais une seule doit être
publique ;
 La classe contenant la méthode main doit être obligatoirement publique,
afin que la machine virtuelle y ait accès ;
 Une classe n’ayant aucun attribut d’accès reste accessible à toutes les
classes du même paquetage donc à fortiori, du même fichier source.

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC

DEFINITION DE CLASSE EN JAVA Page 5 /8

1.2. La notion de constructeur

- Méthode spéciale
- Automatiquement appelée au moment de la création de l’instance d’une classe avec le
mot-clé new
- Ne retourne aucune valeur
- Même nom que la classe
- Java crée un constructeur par défaut si le programmeur n’en a pas prévu pour une
classe
- Un constructeur par défaut ne fait aucune opération

Le constructeur par défaut pour la classe Client pourrait se présenter comme suit :

public Client()
{
}

Le programmeur peut écrire son propre constructeur qu’il pourrait paramétrer s’il le faut. La
liste des paramètres consiste en une déclaration de variables.

Exemple
// Un constructeur (avec paramètres) de la classe Client,
public Client(String unNom, int unAge, String unAdr, String unPhone)
{
// Appel aux méthodes d’altération
setNom(unNom);
setAge(unAge);
setAdresse(unAdr);
setTelephone(unPhone);
}

Au lieu de faire appel aux méthodes d’altération, on aurait pu initialiser directement les
champs comme suit :

public Client(String unNom, int unAge, String unAdr, String unPhone)

{
nom = unNom;
age = unAge;
adresse = unAdr;
telephone = unPhone;
}

Une classe pour tester le constructeur

public class TestConstructeur

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

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC

DEFINITION DE CLASSE EN JAVA Page 6 /8

// Déclarer 3 variables références

Client client1, client2, client3;
// Créer trois instances de Client avec leurs champs
client1 = new Client("John",70,"Godomey", "21-94-34-60");
client2 = new Client("Bossou",45,"Cotonou", "21-31-45-69");
client3 = new Client("Kassim",25,"Bohicon", "90-09-34-10");

/* On pourrait directement créer les trois instances de Client

avec leurs champs, comme suit:
Client client1 = new Client("John",70,"Godomey", "21-94-34-60");
Client client2 = new Client("Bossou",45,"Cotonou", "21-31-45-69");
Client client3 = new Client("Kassim",25,"Bohicon", "90-09-34-10");
*/

// Accéder aux champs des objets

// puis afficher sans utiliser des variables
System.out.println("Le nom du premier client est: " +
client1.getNom());
System.out.println("Le nom du deuxième client est: " +
client2.getNom());
System.out.println("Le nom du troisième client est: " +
client3.getNom());
}
}

1.3. Surdéfinition de méthodes

- La signature d’une méthode consiste en son nom, son type et sa liste de paramètres.
- Java identifie une méthode non seulement par son nom, mais par sa signature.
- Donc dans la définition d’une classe, on peut écrire plusieurs méthodes avec le même
nom et différente signature.
Si dans une classe, une méthode a le même nom qu’une autre méthode dans la classe, mais
avec différente signature, on parle de surdéfinition de méthode.

Remarque
Il ne faut pas confondre la surdéfinition à la redéfinition et au polymorphisme

1.3.1. Surdéfinition d’un constructeur

 le constructeur par défaut, sans argument, pour la classe Client :

public Client()
{

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC

DEFINITION DE CLASSE EN JAVA Page 7 /8

 Un constructeur avec 4 arguments pour la classe Client :

public Client(String unNom, int unAge, String unAdr, String unPhone)

{
// Appel aux méthodes d’altération
setNom(unNom);
setAge(unAge);
setAdresse(unAdr);
setTelephone(unPhone);
}

1.3.2. Surdéfinition d’une méthode

Par exemple, supposons que notre entreprise de location permette, sous certaines conditions,
des réductions sur les prix des produits. On pourrait alors prévoir une surdéfinition de la
méthode setPrix(), afin de prendre en charge la remise. La nouvelle méthode pourrait se
présenter comme suit :

public double setPrix(double p)

{ prix = p ;return p ;}

public double setPrix(double p, double tauxReduction)

{
double rd = this.setPrix(p) ;
double apresReduction = rd*(100-tauxReduction)/100 ;
return apresReduction ;
}

Le mot-clé this est utilisé pour désigner l’instance dont la méthode s’exécute.

2. Les exceptions
Java utilise des exceptions pour signaler des erreurs, des problèmes ou toute autre situation
anormale pendant l’exécution d’un programme.

Exemple :

public static void main(String[] args)

{
int j=20, i=0;

try{
System.out.println(j/i);
}catch(Exception e)
{

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC

DEFINITION DE CLASSE EN JAVA Page 8 /8

System.out.println(e.getMessage());
}
}

Le model client-serveur est utilisé pour les exceptions :

 Le client fait appel à une méthode du serveur, peut-être en passant des arguments ;
 Le serveur exécute la tâche demandée et pourrait retourner à son tour une valeur au
client. Il utilise des exceptions pour informer le client de problème éventuel :
arguments non valides ou autre chose. Il peut créer et envoyer une instance de la
classe Exception, contenant des renseignements sur la situation.

Java utilise cinq mots-clés pour traiter les exceptions : try, catch, finally, throw, throws.
Les trois premiers sont utilisés par le client alors que les deux derniers sont utilisés par le
serveur.

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC