Médiaforma

All posts tagged final

Propriétés et méthodes de classes

Lorsque vous définissez une propriété et une méthode dans une classe en la faisant précéder du mot clé static, ces deux objets sont définis une fois pour toutes les instances de cette classe. Il est même possible d’y faire référence sans instancier la classe.

Si, au contraire, vous omettez le mot static lorsque vous définissez les propriétés et méthodes d’une classe, elles seront redéfinies dans chaque instance de la classe.

Supposons par exemple que vous définissiez une propriété et une méthode static dans une classe nommée Init :

class Init{
  static int i;
  static void m(){
    i = 1;
  }
}

Pour accéder à cette variable et à cette méthode dans une autre classe, il suffira de préciser le nom de la classe où elles ont été définies :

public class Test{
  public static void main (String args[]) {
    Init.i = 5;
    System.out.println(Init.i);
    Init.m();
    System.out.println(Init.i);
  }
}

Définissez les classes Init et Test en créant les fichiers Init.java et Test.java. Compilez ces fichiers avec le compilateur javac et vérifiez le bon fonctionnement de la classe Test.

Protection des membres

Java fournit plusieurs niveaux de protection pour les membres d’une classe (propriétés, méthodes) :

  • Les membres public sont accessibles par tous les autres objets de l’application.
  • Les membres private ne sont accessibles que par les méthodes de la même classe. Il est plus fréquent de rencontrer des données private que des méthodes private.
  • Tout comme les membres private, les membres protected ne sont accessibles que par les méthodes de la même classe. Par contre, les fonctions membres d’une classe héritée d’une classe qui possède des membres protégés peuvent accéder à ces derniers.

Constantes de classe

Si vous êtes amené à manipuler plusieurs fois une donnée définie dans une classe dont la valeur n’évoluera pas, il est pratique de la définir en tant que constante. Pour ce faire, vous utiliserez le mot clé final. Par exemple :

public class Test {
  final int Maxima = 25;
  final int Nombre[] = {1, 2, 3, 4, 5, 6, 7};
}

Vous pouvez tout aussi bien définir un tableau de constantes :

final int Nombre[] = {1, 2, 3, 4, 5, 6, 7};

Attention :

Le mot clé final ne peut être utilisé qu’à l’intérieur d’une classe.

Définir une classe

Nous allons développer l’exemple précédent pour aborder pas à pas la démarche permettant de définir une nouvelle classe.

Avant de pouvoir utiliser une classe, il faut la déclarer comme suit :

class Cylindre{
   ...
  // Propriétés et méthodes de la classe
  ...
};

A l’intérieur des accolades sont propriétés et les méthodes de la classe. Par exemple :

class Cylindre {
  double rayon;     // Rayon de la base du cylindre
  double hauteur;   // Hauteur du cylindre

  double Calcule() {
    return 3.1415 * rayon * rayon * hauteur;
  }
}

Cette déclaration indique au compilateur le contenu de la classe Cylindre, mais ne réserve en rien l’espace mémoire qui permettra de travailler avec cette classe. Pour ce faire, vous devez définir une instance de la classe Cylindre (on parle aussi d’objet) avec une instruction du type suivant :

Cylindre Cyl = new Cylindre();

Cette instruction définit le bloc de mémoire Cyl dans lequel les propriétés rayon et hauteur et la méthode Calcule() pourront être manipulées.

La classe Cylindre ainsi définie n’est pas accessible de l’extérieur. En effet, toutes les propriétés et méthodes d’une classe sont par défaut de type private (privé). Elles ne peuvent donc être initialisées par des instructions extérieures à la classe. Pour résoudre ce problème, il suffit d’ajouter un spécificateur d’accès public comme suit :

public class Cylindre {
  static public double rayon;     // Rayon de la base du cylindre
  static public double hauteur;   // Hauteur du cylindre

  static public double Calcule() {
    return 3.1415 * rayon * rayon * hauteur;
  }
}

Dans cet exemple, les deux propriétés et la méthode sont rendues publiques. Elles sont accessibles à toutes les méthodes de l’application, qu’elles fassent partie d’autres classes ou non. Nous pouvons donc y accéder avec des instructions “à point” :

public class Calcul
{

  public static void main(String args[])
  {

    Cylindre Cyl = new Cylindre();  // Définition de l'objet Cyl de type Cylindre
    Cyl.rayon = 4.6;    // rayon de la base : 4,6 cm
    Cyl.hauteur = 12;   // hauteur du cylindre : 12 cm
    System.out.println("Volume du cylindre : " + Cyl.Calcule());
  }
}

Dans la procédure principale main, un objet de classe Cylindre est défini :

Cylindre Cyl = new Cylindre();  // Définition de l'objet Cyl de type Cylindre

Grâce à cette instruction, l’objet Cyl a désormais une existence réelle. Les deux instructions suivantes initialisent les variables membres rayon et hauteur :

Cyl.rayon = 4.6;    // rayon de la base : 4,6 cm
Cyl.hauteur = 12;   // hauteur du cylindre : 12 cm

Enfin, la dernière instruction utilise la fonction membre Calcule() pour calculer le volume du cylindre, et affiche le résultat sur l’écran :

System.out.println("Volume du cylindre : " + Cyl.Calcule());

Comme nous le verrons par la suite, il est parfois important que les variables utilisées dans une classe ne soient pas accessibles aux fonctions extérieures à la classe. Pour cela, il suffit de les faire précéder du spécificateur d’accès private :

public class Cylindre {
  static private double rayon;     // Rayon de la base du cylindre
  static private double hauteur;   // Hauteur du cylindre

static public double Calcule()
  {
    return 3.1415 * rayon * rayon * hauteur;
  }
}

Mais alors, les variables rayon et hauteur d’un objet Cylindre ne peuvent pas être initialisées directement. Les instructions suivantes sont donc illicites :

Cylindre Cyl = new Cylindre();  // Définition de l'objet Cyl de type Cylindre
Cyl.rayon = 4.6;   // Impossible d'initialiser une variable
Cyl.hauteur = 12; // private depuis une fonction extérieure

Pour initialiser ces variables, on utilise généralement une fonction membre public à laquelle on passe les valeurs à affecter aux variables privées :

static public void DefDonnees (double r, double h){
  rayon = r;
  hauteur = h;
};

Inversement, il peut être intéressant pour une fonction extérieure à la classe de connaître les valeurs courantes du rayon et de la hauteur. Pour cela, on définit deux fonctions membres publiques :

static double LitRayon() {
  return rayon;   // Le rayon est retourné par la fonction publique
}

static double LitHauteur() {
  return hauteur;   // La hauteur est retournée par la fonction publique
}

Le code permettant de définir la classe Cylindre devient :

public class Cylindre{
  static private double rayon;     // Rayon de la base du cylindre
  static private double hauteur;   // Hauteur du cylindre

  static public void DefDonnees (double r, double h) {
    rayon = r;
    hauteur = h;
  };

  static double LitRayon() {
    return rayon;   // Le rayon est retourné par la fonction publique
  }

  static double LitHauteur() {
    return hauteur;   // La hauteur est retournée par la fonction publique
  }

  static public double Calcule() {
    return 3.1415 * rayon * rayon * hauteur;
  }
}

L’application qui calcule le volume du cylindre doit être modifiée comme suit :

public class Calcul {
  public static void main(String args[])  {
    Cylindre Cyl = new Cylindre();  // Définition de l'objet Cyl de classe Cylindre
    double R = 4.6; // Rayon passé à la classe
    double H = 12;  // Hauteur passée à la classe
    Cylindre.DefDonnees(R, H); // Initialisation indirecte du rayon et de la hauteur
    System.out.println("Volume du cylindre : " + Cyl.Calcule());
  }
}


Comme tous les langages, Java est composé d’un certain nombre de mots-clés. Nous allons les passer en revue dans cette section.

Commentaires

Pour faciliter la compréhension et la maintenance du code, il est souvent utile d’ajouter des commentaires dans le source d’une application ou d’une applet.

Le langage Java supporte trois types de commentaires :

Commentaires – Premier type

Les caractères “//” définissent un commentaire sur une (et une seule) ligne qui s’étend jusqu’au retour chariot de fin de ligne.

Les deux exemples ci-après sont corrects :

// Ce commentaire occupe une ligne
for (i=1; i<10; i++) // Le traitement est répété 10 fois

Par contre, l’exemple ci-après est incorrect. Les caractères “//” ne peuvent pas être placés à l’intérieur d’une instruction :

for (i=1; // Le traitement est répété 10 fois i<10; i++)

Commentaires – Deuxième type

Les signes “/*” et “*/” peuvent être utilisés pour placer des commentaires sur plusieurs lignes ; par exemple :

/* Ceci est un commentaire
   qui occupe deux lignes */

Contrairement au premier type de commentaire (//), il est ici possible de placer un commentaire à l’intérieur d’une instruction :

for (i=1; /* Le traitement est répété 10 fois */ i<10; i++)

Commentaires – Troisième type

Ce type de commentaire est destiné au programme javadoc.exe, livré avec le SDK. Il permet de documenter automatiquement une application.

Sans entrer dans les détails, sachez que les lignes de code qui commencent par les caractères “/**” contiennent des commentaires qui seront automatiquement insérés dans un document HTML lors de l’exécution du programme Javadoc.

Exemple :

/** Ces commentaires
  sont destinés au
  système JAVADOC
  qui génère de la documentation
  API à partir du code */

Identificateurs

Le terme “identificateurs” désigne les constantes, les variables et les objets utilisés dans le langage. Ces derniers commencent obligatoirement par une lettre (A à Z, a à z, ou une autre lettre appartenant au jeu de caractères Unicode dont la valeur hexadécimale est supérieure à H00C0), un caractère de soulignement (_) ou un dollar ($). Les caractères suivants peuvent être des lettres, des caractères de soulignement, des dollars ou des chiffres.

Par exemple, les noms suivants peuvent être utilisés pour référencer un identificateur :

Var12_5
Bien_que_très_long_ce_nom_est_acceptable
$Celui-ci_aussi

Par contre, ces deux identifiants ne sont pas autorisés :

Nombre d'itérations
4Var

Le premier, parce qu’il contient un espace. Le second, parce qu’il commence par un chiffre.

Remarque
Unicode est un standard qui permet des échanges de texte dans différentes langues.

Mots réservés du langage

Le tableau ci-après liste les mots clés du langage. Ces derniers ne peuvent pas être utilisés comme noms de variable, d’objet, de classe, etc. Leur utilisation sera décrite dans la suite de l’ouvrage.

Mot clé Signification
abstract Définit une classe ou une fonction qui n’a pas été totalement implémentée.
boolean Déclaration d’une variable booléenne.
break Fin prématurée d’une boucle.
byte Déclaration d’une variable byte.
case Teste si une variable a une valeur particulière dans un bloc switch.
catch Traitement suite à une exception.
char Déclaration d’une variable char.
class Déclaration d’une classe.
const Ce mot est réservé mais pas utilisé dans le langage.
continue Interdit l’exécution d’une boucle lorsqu’une condition logique est satisfaite.
default Permet d’exécuter un bloc d’instructions lorsque aucune des constantes case ne concorde avec l’expression placée après le mot switch.
do Boucle do while.
double Déclaration d’une variable double.
else Dans une instruction if else, permet d’exécuter un bloc d’instructions si la condition if n’est pas satisfaite.
extends Permet de sous-classer une classe parent.
false Valeur booléenne false.
final Indique à Java que la classe courante ne peut être sous-classée.
finally Permet d’exécuter systématiquement une portion de code à chaque occurrence d’une exception.
float Déclaration d’une variable float.
for Exécute répétitivement un bloc d’instructions.
goto Ce mot est réservé mais pas utilisé dans le langage.
if Teste une condition logique.
implements Détermine l’interface à utiliser.
import Fait référence à un package Java externe.
instanceof Détermine le type d’un objet.
int Déclaration d’une variable int.
interface Indique à Java que le code qui suit doit être utilisé pour définir une nouvelle interface.
long Déclaration d’une variable long.
native Permet d’appeler un programme externe.
new Permet de définir une nouvelle instance de classe.
null Correspond à une valeur non existante.
package Indique à Java le nom du package auquel se réfère le code qui suit.
private Définit une classe, une méthode ou une variable private.
protected Définit une classe, une méthode ou une variable protected.
public Définit une classe, une méthode ou une variable public.
return Définit la valeur retournée par une classe ou une méthode.
short Déclaration d’une variable short.
static Définit une classe, une méthode ou une variable static.
super Fait référence à la classe parent de la classe courante.
switch Permet d’effectuer un test multiple sur une variable.
synchronized Indique à Java qu’une seule instance de cette méthode peut être exécutée à la fois.
this Fait référence à l’objet courant.
throw Indique à Java qu’une exception particulière (autre que Errors et Runtime) doit être traitée dans le prochain bloc catch.
throws Détermine les exceptions gérées par le programmeur dans une déclaration de méthode.
true Valeur booléenne true.
try Définit un bloc de code dans lequel une ou plusieurs exceptions peuvent se produire. Un bloc try doit être suivi d’un bloc catch qui traite les exceptions correspondantes.
void Déclare une procédure Java qui ne renvoie aucune valeur.
volatile Les variables de type volatile peuvent changer de valeur indépendamment du programme Java (date et heure système par exemple)
while Exécute répétitivement un bloc d’instructions.