Dans le tutoriel précédant nous avons vu en détail la déclaration du package, les commentaires, la déclaration et la définition de la classe. Dans ce tuto nous allons traiter les importations, les variables, les méthodes et les constructeurs.
I- Rappel de la structure d’une classe :
Une classe peut contenir ces éléments :
Package
Importations
Commentaires
Déclaration de la classe
{
}
➦ Les importations :
Les classes et les interfaces faisant partie d’un même package peuvent s’utiliser entre elles sans avoir besoin de mentionner le package dans les autres cas soit on import le package à utiliser :
import ecole.* ; //importer toutes les classes du package ecole
importecole.Etudiant ; // importer seulement la classe Etudiant
Soit lors de l’utilisation de la classe importée on la précède du nom du package auquel elle appartient :
}
Remarque : les classes se trouvant sous le package par défaut sont importées automatiquement dans les autres packages du même projet
➦ Les importations statiques :
Il s’agit d’importer les propriétés statiques d’une classe.
Avant tout expliquons le terme statique, le mot clé static figurant dans la déclaration d’une variable ou d’une méthode signifie que cette propriété est une propriété de classe et non d’instance autrement dit elle peut être appelée en étant directement précédée par le nom de la classe sans devoir créer une instance.
package Ecole
public class Etudiant
{
}
package class GroupeE
import Ecole.Etudiant.nombre_eleves ;
}
}
Variables :
Ici on parle des variables qui représentent les attributs d’une classe, et un attribut est une propriété de la classe.
Ces attributs ont un modificateur d’accès, un type et une valeur par défaut.
Remarque : les modifications d’accès sont applicables sur les attributs et non sur les variables locales (les variables déclarées à l’intérieur d’une méthode) ni sur les paramètres des méthodes.Les
➦ modificateurs d’accès :
Commençons par les modificateurs d’accès :
➦ Les modificateurs de non accès :
En plus de ces modificateurs, dans une déclaration d’un attribut on peut ajouter d’autres mots clés qu’on appelle les modificateurs de non accès (non access modifier) :
static : ce mot clé signifie que cet attribut est un attribut de classe et non d’instance c’est à dire pour toute instance de la classe créée une seule copie de cet attribut est partagée entre elles, chaque modification exercée sur la valeur de l’attribut par n’importe quelle instance s’applique sur la valeur du même l’attribut.
Public static int n ;
final : indique que la valeur initiale de l’attribut ne pourra pas être changée, tout au long du programme l’attribut gardera la même valeur, pas de possibilité d’une seconde affectation.
public final int n=3 ;
Remarque :
static est applicable seulement sur les attributs et non sur les variables locales.
final peut être appliquer sur les attributs comme sur les variables locales.
Les types primitifs : java a mis à notre disposition 8 types primitifs qui sont déjà prédéfinis :
Toutes ces formes de valeur doivent être représentées entre deux ‘ et non pas «
char cacar=\u0001 ; //à l’affichage ça donne le symbole ?
char carac=’a’ ; //à l’affichage ça donne la lettre a
Ou bien on peut aussi stocker un nombre qui ne dépasse pas 16 bits représenté sans ‘ et qui sera converti en caractère correspondant
Remarque :
–66 est différent de \u0066.
-Le type char n’accepte pas un entier négatif.
–charcarac=66 ;// à l’affichage ça donne B
–charcarac=\u0066 ; // à l’affichage ça donne f
Pour stocker une valeur entière, on utilise l’un de ces 4 types selon leurs plages de valeurs :
On passe au stockage des nombres décimaux :
Remarque : en java on ne parle que des nombres signés.
boolean test=true ;
La déclaration d’une variable engendre la réservation d’un espace mémoire de x bits (selon le type) qui sera associé à celle-ci.
Les valeurs par défaut des types primitifs cités au-dessus :
char : \u0000 ;
byte : 0
short : 0
int : 0
long : 0L ou 0l
float : 0.0f ou 0.0F
double : 0.0d ou 0.0D
boolean : false
➦ La conversion (cast) :
La conversion c’est le changement d’un type à un autre. Il y a 2 types de conversions :
➦ Conversion implicite : c’est la conversion automatique faite par java quand on affecte une valeur dont la capacité de son type est moins large que le type de la variable à laquelle on l’affecte :
Conversion explicite : qu’on appelle aussi conversion forcée, c’est la conversion faite par l’intervention du développeur en utilisant (
Donc pour éliminer l’erreur on fait recours à la conversion forcée de syntaxe :
Nouvelle_var=(type_nouvelle_var) Ancienne_var ;
Pour cet exemple ce sera comme suit :
La conversion forcée peut faire perdre la précision :
Donc la nouvelle valeur de i c’est 5 et non 5.98
Remarque : on ne peut pas faire une conversion entre un objet et un type primitif, on doit avoir recours à des méthodes qu’on verra un peu plus tard.
Ici on parle des opérateurs qu’on peut appliquer sur les variables.
On va voir quelques-uns selon notre niveau d’avancement et ceci à l’aide d’exemples que vous allez exécuter chez vous pour voir les résultats :
Remarque : aussi on peut utiliser le type char pour l’incrémentation et décrémentation, par exemple :
char a=’b’ ;
a++ ;
Ce qui changera la valeur de la variable de la valeur ‘b’ à la valeur ‘c’ (la lettre de l’alphabet qui succède).
Une affectation composée est une combinaison d’une opération arithmétique sur au moins 2 opérandes de type nombrable (int, double,…) suivie d’affectation du résultat à la variable de la gauche à condition que le résultat ne dépasse pas la capacité du type de la variable.
Pour la comparaison le résultat est toujours de type boolean soit true soit false.
Remarque : l’opérateur == peut aussi être utilisé pour comparer 2 chaines de caractères ou 2 objets mais dans ces cas, c’est l’adresse en mémoire qui se compare et pas les valeurs des variables.
L’inversion sert à inverser la valeur d’une variable booléenne uniquement, ne marche pas avec les autres types.
Je vais expliquer comment fonctionnent ces opérateurs :
f&&c ➙ il suffit que l’un des 2 soit false pour que le résultat soit false sinon ce sera true.
f||c ➙ il suffit que l’un des 2 soit true pour que le résultat soit true sinon ce sera false.
f^c ➙ il faut que les 2 valeurs soient différentes pour que le résultat donne true sinon ce sera false.
C’est une comparaison verticale bit par bit puis une conversion du résultat vers le int.
g&h ➙ il suffit que l’un des 2 bits de même poids soit à 0 pour retourner à 0 sinon ça retournera à 1.
g|h ➙ il suffit que l’un des 2 bits de même poids soit à 1 pour retourner à 1 sinon ça retournera à 0.
g^h ➙ il faut que les 2bits de même poids soient différents pour que le résultat donne 1 sinon ce sera 0.
Il s’agit d’effectuer un décalage de bits vers la droite ou vers la gauche ce qui change la valeur du nombre initial. A gauche de l’opérateur c’est le nombre à modifier et à droite de l’opérateur c’est le nombre de décalage à faire.
Remarque : ici on a choisi que le nombre de décalage soit égal à 1, ce n’est pas un nombre fixe on peut trouver 2, 3 et plus.
Il s’agit d’effectuer un décalage de bits vers la droite ou vers la gauche ce qui change la valeur du nombre initial. A gauche de l’opérateur c’est le nombre à modifier et à droite de l’opérateur c’est le nombre de décalage à faire.
Remarque : ici on a choisi que le nombre de décalage soit égal à 1, ce n’est pas un nombre fixe on peut trouver 2, 3 et plus.
➦ Variable de référence :
Comme les variables de types primitifs, il y a aussi les variables qui se comportent comme référence sur un objet stocké en mémoire c’est-à-dire il ne s’agit plus de réserver une zone mémoire selon la taille du type mais plutôt stocker l’adresse mémoire de l’objet sur lequel elle pointe.
Une telle variable a comme type le nom d’une classe, Java un type d’objet déjà prédéfini String, prend comme valeur à une chaine de caractères saisie entre deux « .
String chaine= « Bienvenue « ;
Comme on peut déclarer une variable qui se pointe sur un objet dont la classe est créée par le développeur.
La valeur par défaut d’une variable de référence est null ;
Voyons ensemble cet exemple :
La commande Etudiant e (Etudiant e1) déclare une variable e (e1) correspondant à un objet de la classe Etudiant mais c’est juste une déclaration sans initialisation ce qui engendre seulement une réservation d’un espace mémoire pour stocker la référence qui est l’adresse en mémoire de l’objet où lors de sa création sera stocké) et ça donne cette composition :
Par l’instruction e= new Etudiant() ;
new : la commande permettant de créer une instance d’un objet.
Etudiant() : c’est le constructeur par défaut de la classe Etudiant.
La combinaison de ces
On verra les détails dans la partie réservée aux constructeurs
1 une instance de la classe Etudiant se créée
2 un espace mémoire permettant de stocker la variable e sera réservé
3 les attributs de l’instance e seront initialisés par leurs valeurs par défaut correspondantes.
Le résultat en mémoire sera comme suit :
Remarque : Si le réfèrent (l’objet en mémoire) n’est référencé par aucune variable il sera éliminé de la mémoire par le Garbage Collector de java.
Un objet en mémoire n’est plus référencé ça eut être par deux méthodes :
-la référence prend la valeur null
-la référence se pointe sur un autre objet
Pour accéder aux attributs ou aux méthodes d’un objet on utilise ‘.’
e.nom ;
Si l’attribut ou la méthode sont statiques :
Nom_Classe.Nom_Methode_Statique() ;
Un constructeur est une méthode conçue spécialement pour instancier et retourner un objet de la classe dans laquelle elle est définie.
Tout constructeur doit porter le même nom que la classe dans laquelle il est défini.
Dans une même classe on peut avoir 0 ou plusieurs constructeurs dont la différence résulte dans le nombre, type et ordre des paramètres.
Si le développeur n’écrit aucun constructeur alors automatiquement java crée un, qu’on appelle le constructeur par défaut ne comportant aucun paramètre, n’admettant aucun type de retour et dont le corps sert à initialiser les attributs de l’instance par les valeurs par défaut selon leurs types :
public Etudiant()
{
nom=null ;
age=0 ;
}
Un constructeur peux contenir des instructions d’initiation comme il peut contenir d’autres instructions (calcul, affichage, appel d’une méthode…), comme il peut ne rien contenir (corps vide).
Comme le montre la figure ci-dessous, une fois que le développeur crée un constructeur, le constructeur par défaut de java ne sera pas créé donc n’est plus reconnu et un appel à ce dernier engendre une erreur de compilation :
Un constructeur peut appeler un autre constructeur de la même classe en utilisant le mot clé this. En effet this est utilisé pour faire référence à l’objet courant, peut être utilisé avec un attribut, une méthode ou un constructeur :
Remarque : même une simple méthode peut porter le nom de la classe mais elle n’est jamais considérée comme un constructeur car elle admet un type de retour.
public void Etudiant()
{
}
☛ void signifie que la méthode est une procédure, ne retourne rien.
public Etudiant()
{
}
Une méthode est un ensemble d’instructions (opérations) identifiées par un nom. Dans une classe on utilise les méthodes pour définir le comportement de l’objet en question.
Une méthode peut être une procédure ou une fonction selon son type de retour
– void pour indiquer que c’est une procédure qui exécute un traitement mais ne retourne rien comme résultat.
– un type primitif (char, byte, int, long, float, double, boolean) ou un type d’objet (String, Etudiant,…), là il s’agit d’une fonction qui exécute un traitement et retourne un résultat en utilisant la commande return qui indique la fin de la méthode.
public Etudiantfonction()
{
}
Remarque :
Une fonction ne peut retourner qu’un seul résultat.
La procédure aussi peut contenir le mot clé return suivi d’un ;
public void procedure()
{
System.out.println( » procédure « ) ;
return;
}
➦ Les modificateurs d’accès :
Ce sont les mêmes qu’on a cité précédemment pour les variables, c’est le même principe.
➦ Les modificateurs de non accès :
-final : Quand une méthode est marquée par final on comprend que celle-ci ne peut pas être redéfinie par les sous-classes (on verra les détails dans la section de l’héritage).
-static : Une méthode statique est une méthode de classe qui ne peux être appelée que par le nom de la classe et non par ses instances.
Remarque : Une méthode statique ne peut pas utiliser une variable non statique ou appeler une autre méthode non statique, le contraire est autorisé.
-abstract : Ce mot clé indique que la méthode est une méthode abstraite ça veut dire qu’elle n’admet pas de corps, elle est déclarée et pas définie. Cette méthode ne peut apparaitre que dans une classe abstraite :
abstract intnombre() ;
-synchronized : Dans le cas des threads, pour synchroniser l’accès à la méthode entre les threads :
synchronized voidentrer()
{
}
➦ Les paramètres :
Les variables qu’on passe dans l’entête de la méthode s’appellent les paramètres de la méthode.
Une méthode peut avoir 0 ou plusieurs paramètres.
public intcalcul(inta,int b)
{
}
➦ Les variables locales
Ces variables sont les variables déclarées à l‘intérieur d’une méthode ou d’un bloc dans une méthode (boucle, instruction if, …). Elles ne sont visibles qu’au sein de celle-ci :
protected intcalcul(inta,int b)
{
}
➦ Les priorités entre les variables :
Dans le cas où un attribut et un paramètre
(ou une variable locale) portent le même nom alors la priorité sera pour paramètre (ou la variable locale) :
A Votre avis quel sera le résultat ? nom = e.nom= « Mohamed » ??
Exécutons ensemble :
Comme on vient de voir la valeur de l’attribut n’a pas changé car l’affectation s’est faite au paramètre lui-même donc pour faire la distinction et éviter les confusions, java a mis à notre disposition le mot clé this (qu’on a vu dans la partie des constructeurs) avant le nom de la variable pour spécifier qu’il s’agit de l’attribut et non du paramètre (ou de la variable locale).
Donc on va rectifier l’exemple précèdent :
Donc pour résumer :
Priorité_Paramètre /Priorité_variable locale>Priorité_Attribut
➦ Les portées des variables :
La portée d’une variable signifie la visibilité de celle-ci dans une classe, accessible dans toute la classe ou seulement dans un bloc.
Pour mieux comprendre on va s’aider par un exemple :
L’attribut statique nom de la classe Etudiant est visible dans toute la classe Groupe, l’attribut age de l‘instance e est visible uniquement à l’intérieur du bloc dans lequel elle est déclarée, l’attribut attribut de la classe groupe est aussi visible dans toute la classe Groupe car c’est la classe dans laquelle il est défini et finalement la variable locale var_local est visible uniquement à l’intérieur de la méthode main (elle est déclarée là-dedans).
Donc on peut conclure que :
Portée_Attributstatique>Portée_attribut d’instance >Portée_Paramètre / Portée_variables locales >Portée_variable locale déclarée dans un bloc d’instructions délimité par des accolades à l’intérieur d’une méthode.
➦ La surcharge :
Comme on a vu précédemment dans la partie des constructeurs, qu’une même casse peut contenir plus qu’un constructeur en changeant le nombre, le type et l’ordre des paramètres.
Cette notion s’applique aussi sur les méthodes d’une même classe, pour surcharger une méthode il faut respecter les règles ci-dessous :
Remarque : Changer uniquement le type de retour ou le modificateur d’accès n’est pas considéré comme une surcharge, ça engendre une erreur de compilation car la nouvelle méthode sera considérée comme déjà existante :
Comme le montre l’exemple en changeant uniquement le type de int à void, une erreur de compilation apparait.
Voilà donc notre tuto est terminé, on a achevé la découverte et l’explication en détails, accompagnée d’exemples des composants d’une classe java.
Le prochain tuto sera consacré essentiellement à l’héritage.
Merci de nous avoir fait confiance.
Je vous invite à consulter quotidiennement le site d’Odellya pour profiter des prochains tutoriels qui seront bientôt à votre disposition.
