Besoin de renseignement? Contactez nous....
Envoyer un Email +33 7 81 01 72 30
contact@odellya.com

Débuter avec Java – Les composants d’une classe Java

 

 

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.

Objectif: maitriser les notions de base des composants d’une classe en java

I- Rappel de la structure d’une classe :

Une classe peut contenir ces éléments :

  1. Déclaration du package
  2. Déclaration des importations
  3. Les commentaires
  4. La déclaration et la définition de la classe
  5. Les variables
  6. Les méthodes
  7. Les constructeurs

Package

Importations

Commentaires

Déclaration de la classe

{

Variables Constructeurs
Méthodes
//on peut trouver d’autres éléments comme : les classe internes, les enum et les interfaces internes (ne feront pas partie de nos premières leçons),

}

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 :

class Test
{

Ecole.Etudiant e1 ;

}

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
{

static public nombre_eleves ;

}
package class GroupeE
import Ecole.Etudiant.nombre_eleves ;

public class Groupe
{

Public static void main(String args[])
{

System.out.print(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 :

  • private : signifie que cet attribut ne peut être utilisé qu’à l’intérieur de la même classe. 

 

  • Accés par défaut: L’attribut n’est précédé par aucun mot clé, signifie que l’attribut ne peut être utilisé que par la classe elle-même et par toute classe appartenant aux même package que la classe de l’attribut.

 

  • protected : signifie que l’attribut en question peut être accédé par la classe elle-même, par les classes du même package et par les classes filles (les classes qui héritent de la classe possédant l’attribut). 

 

  • public : Ce modificateur indique que l’attribut est accessible par la classe elle-même, par les classes du même package et celles héritant de cette classe (on verra un peu plus loin la notion d’héritage

                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.

  1. Type de variables : 

Les types primitifs : java a mis à notre disposition 8 types primitifs qui sont déjà prédéfinis :

  • char : peut stocker sur 16 bits un caractère Unicode commençant par \u suivi par 4 chiffres (Java a une table dans laquelle pour chaque lettre, symbole et chiffre correspondant à un code comme le code ascii). Comme il peut stocker une seule lettre de l’alphabet, un symbole ou un chiffre.

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é sanset 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 :

  • byte : l’entier s’écrit sur 8 bits, sa plage de valeurs est comprise entre -128 et 127
  • short : l’entier s’écrit sur 16 bits, sa plage de valeurs est comprise entre -32.768 et 32.767
  • int : l’entier s’écrit sur 32 bits, sa plage de valeurs est comprise entre -(2^31) et (2^31)-1
  • long : l’entier s’écrit sur 64 bits, sa plage de valeurs est comprise entre -(2^63) et (2^63)-1. 

On passe au stockage des nombres décimaux :

  • float : le nombre à virgule flottante s’écrit sur 32 bits avec une simple précision
  • double : le nombre à virgule flottante s’écrit sur 64 bits, avec double précision 

Remarque : en java on ne parle que des nombres signés. 

  • boolean : sur 8 bits on peut uniquement prendre 2 valeurs logiques soit true soit

                             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 (

conversion explicite

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 :

int

La conversion forcée peut faire perdre la précision :

conversion forcée

Donc la nouvelle valeur de i c’est 5 et non 5.98

conversion forcée

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. 

conversion entre objet et type 

  • Les opérateurs :

Ici on parle des opérateurs qu’on peut appliquer sur les variables.

tableau opérateurs

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 :

java ecole

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

code affectation composee

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.

code comparaison

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.

code inversion

L’inversion sert à inverser la valeur d’une variable booléenne uniquement, ne marche pas avec les autres types.

code operateur logique

Je vais expliquer comment fonctionnent ces opérateurs :

  • Pour les variables booléennes on a:

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.

  • Pour les variables binaires on a :

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.

code decalage

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.

  • w<<1: ce nombre décimal sera converti en bit après il y aura un décalage d’un bit de la droite vers la gauche en ajoutant un 0 (s’il s’agit d’un nombre positif sinon 1) à droite (à la fin de la séquence) et on élimine les 0 après le dernier 1 du gauche (le début de la séquence), le résultat en décimal sera w*2^1.
  • W>>1: ce nombre décimal sera converti en bit après il y aura un décalage d’un bit de la gauche vers la droite en ajoutant un 0 (s’il s’agit d’un nombre positif sinon 1) à gauche (au début de la séquence) et on élimine les 0 après le dernier 1 de la droite (à la fin de la séquence), le résultat en décimal sera w/2^1.
  • w>>>1: c’est le même principe que l’opérateur >> sauf que celui-là ne fonctionne que avec les nombres positifs.

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.

operateur ternaire

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.

  • w<<1: ce nombre décimal sera converti en bit après il y aura un décalage d’un bit de la droite vers la gauche en ajoutant un 0 (s’il s’agit d’un nombre positif sinon 1) à droite (à la fin de la séquence) et on élimine les 0 après le dernier 1 du gauche (le début de la séquence), le résultat en décimal sera w*2^1.
  • W>>1: ce nombre décimal sera converti en bit après il y aura un décalage d’un bit de la gauche vers la droite en ajoutant un 0 (s’il s’agit d’un nombre positif sinon 1) à gauche (au début de la séquence) et on élimine les 0 après le dernier 1 de la droite (à la fin de la séquence), le résultat en décimal sera w/2^1.
  • w>>>1: c’est le même principe que l’opérateur >> sauf que celui-là ne fonctionne que avec les nombres positifs.

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.

mots clés java

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 :

etudiant java

groupe java

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 :

etudiant e1

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 :

reference

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() ;

  1. Les constructeurs : 

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 :

code étudiant java

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 :

Code étudiant java suite

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()
{

age=3 ;

}

void signifie que la méthode est une procédure, ne retourne rien.

public Etudiant()
{

age=3 ;

}

  1. Les méthodes : 

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()
{

return new Etudiant() ;

}

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

returna+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)
{

int z ; // variable localez=a+b ;
return z ;

}

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

etudiant java

A Votre avis quel sera le résultat ? nom = e.nom= « Mohamed » ??

Exécutons ensemble :

etudiant java

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 :

groupe java

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 :

  • Garder le même nom
  • Changer le nombre ou le type ou l’ordre des paramètres

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 :

etudiant java

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.

 

 

Si ce tutoriel vous a été utile, soyez généreux, pensez aux autres en le partageant dans les réseaux sociaux. Il vous suffit de cliquer sur les icônes ci-dessous.