Votre première classe

• Java Orienté Objet
• Sommaire
• L'héritage

Dans la première partie de cet ouvrage sur la programmation en Java, nous avons travaillé avec une seule classe. Vous allez apprendre qu'en faisant de la programmation orientée objet, nous travaillerons en fait avec de nombreuses classes. Rappelez-vous la première partie : vous avez déjà utilisé des objets… Oui ! Lorsque vous faisiez ceci : String str = new String("tiens… un objet String");.

Ici str est un objet String. Vous avez utilisé un objet de la classe String : on dit que vous avez créé une instance de la classe String(). Le moment est venu pour vous de créer vos propres classes.

• Structure de base
• Les constructeurs
• Accesseurs et mutateurs
• Les variables de classes
• Le principe d'encapsulation

Structure de base

Une classe peut être comparée à un moule qui, lorsque nous le remplissons, nous donne un objet ayant la forme du moule ainsi que toutes ses caractéristiques. Comme quand vous étiez enfants, lorsque vous vous amusiez avec de la pâte à modeler.

Si vous avez bien suivi la première partie de ce cours, vous devriez savoir que notre classe contenant la méthode main ressemble à ceci :

1
2
3
4
5
6
7

class ClasseMain{

  public static void main(String[] args){ 
    //Vos données, variables, différents traitements…
  }//Fin de la méthode main

}//Fin de votre classe

Créez cette classe et cette méthode main (vous savez le faire, maintenant). Puisque nous allons faire de la POO (Programmation Orientée Objet), nous allons créer une seconde classe dans ce fameux projet ! Créons sans plus tarder une classe Ville. Allez dans File > New > Class ou utilisez le raccourci dans la barre d'outils, comme sur la figure suivante :

Nommez votre classe « Ville » (avec un « V » majuscule, convention de nommage oblige). Cette fois, vous ne devez pas y créer la méthode main.

Au final, vous devriez avoir le rendu de la figure suivante :

Ici, notre classe Ville est précédée du mot clé public. Vous devez savoir que lorsque nous créons une classe comme nous l'avons fait, Eclipse nous facilite la tâche en ajoutant automatiquement ce mot clé, qui correspond à la portée de la classe. Retenez pour l'instant que public class UneClasse{} et class UneClasse{} sont presque équivalents !

En programmation, la portée détermine qui peut faire appel à une classe, une méthode ou une variable. Vous avez déjà rencontré la portée public : cela signifie que tout le monde peut faire appel à l'élément. Ici dans le cas qui nous intéresse il s'agit d'une méthode. Une méthode marquée comme public peut donc être appelée depuis n'importe quel endroit du programme.

Nous allons ici utiliser une autre portée : private. Elle signifie que notre méthode ne pourra être appelée que depuis l'intérieur de la classe dans laquelle elle se trouve ! Les méthodes déclarées private correspondent souvent à des mécanismes internes à une classe que les développeurs souhaitent « cacher » ou simplement ne pas rendre accessibles de l'extérieur de la classe…

Bon. Toutes les conditions sont réunies pour commencer activement la programmation orientée objet ! Et si nous allions créer notre première ville ?

Les constructeurs

Vu que notre objectif dans ce chapitre est de construire un objet Ville, il va falloir définir les données qu'on va lui attribuer. Nous dirons qu'un objet Ville possède :

• un nom, sous la forme d'une chaîne de caractères ;
• un nombre d'habitants, sous la forme d'un entier ;
• un pays apparenté, sous la forme d'une chaîne de caractères.

Nous allons faire ceci en mettant des variables d'instance (de simples variables identiques à celles que vous manipulez habituellement) dans notre classe. Celle-ci va contenir une variable dont le rôle sera de stocker le nom, une autre stockera le nombre d'habitants et la dernière se chargera du pays ! Voici à quoi ressemble notre classe Ville à présent :

1
2
3
4
5

public class Ville{
  String nomVille;
  String nomPays;
  int nbreHabitants; 
}

Contrairement aux classes, les variables d'instance présentes dans une classe sont public si vous ne leur spécifiez pas de portée. Alors, on parle de variable d'instance, parce que dans nos futures classes Java qui définiront des objets, il y aura plusieurs types de variables (nous approfondirons ceci dans ce chapitre). Pour le moment, sachez qu'il y a trois grands types de variables dans une classe objet :

1. Les variables d'instance : ce sont elles qui définiront les caractéristiques de notre objet.
2. Les variables de classe : celles-ci sont communes à toutes les instances de votre classe.
3. Les variables locales : ce sont des variables que nous utiliserons pour travailler dans notre objet.

Dans l'immédiat, nous allons travailler avec des variables d'instance afin de créer des objets différents. Il ne nous reste plus qu'à créer notre premier objet, pour ce faire, nous allons devoir utiliser ce qu'on appelle des constructeurs.

Un constructeur est une méthode d'instance qui va se charger de créer un objet et, le cas échéant, d'initialiser ses variables de classe ! Cette méthode a pour rôle de signaler à la JVM (Java Virtual Machine) qu'il faut réserver de la mémoire pour notre futur objet et donc, par extension, d'en réserver pour toutes ses variables.

Notre premier constructeur sera ce qu'on appelle communément un constructeur par défaut, c'est-à-dire qu'il ne prendra aucun paramètre, mais permettra tout de même d'instancier un objet, et vu que nous sommes perfectionnistes, nous allons y initialiser nos variables d'instance. Voici votre premier constructeur :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public class Ville{   
  //Stocke le nom de notre ville
  String nomVille;
  //Stocke le nom du pays de notre ville
  String nomPays;
  //Stocke le nombre d'habitants de notre ville
  int nbreHabitants;

  //Constructeur par défaut
  public Ville(){
    System.out.println("Création d'une ville !");      
    nomVille = "Inconnu";
    nomPays = "Inconnu";
    nbreHabitants = 0;
  } 
}

Vous avez remarqué que le constructeur est en fait une méthode qui n'a aucun type de retour (void, double…) et qui porte le même nom que notre classe ! Ceci est une règle immuable : le (les) constructeur(s) d'une classe doit (doivent) porter le même nom que la classe !

Son corollaire est qu'un objet peut avoir plusieurs constructeurs. Il s'agit de la même méthode, mais surchargée ! Dans notre premier constructeur, nous n'avons passé aucun paramètre, mais nous allons bientôt en mettre.

Vous pouvez d'ores et déjà créer une instance de Ville. Cependant, commencez par vous rappeler qu'une instance d'objet se fait grâce au mot clé new, comme lorsque vous créez une variable de type String.

Maintenant, vu que nous allons créer des objets Ville, nous allons procéder comme avec les String. Vérifions que l'instanciation s’effectue comme il faut. Allons dans notre classe contenant la méthode main et instancions un objet Ville. Je suppose que vous avez deviné que le type de notre objet sera Ville !

1
2
3
4
5

public class Sdz1{ 
  public static void main(String[] args){   
    Ville ville = new Ville(); 
  } 
}

Exécutez ce code, vous devriez avoir l'équivalent de la figure suivante sous les yeux :

Maintenant, nous devons mettre des données dans notre objet, ceci afin de pouvoir commencer à travailler… Le but sera de parvenir à une déclaration d'objet se faisant comme ceci :

1

Ville ville1 = new Ville("Marseille", 123456789, "France");

Vous avez remarqué qu'ici, les paramètres sont renseignés : eh bien il suffit de créer une méthode qui récupère ces paramètres et initialise les variables de notre objet, ce qui achèvera notre constructeur d'initialisation.

Voici le constructeur de notre objet Ville, celui qui permet d'avoir des objets avec des paramètres différents :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

public class Ville {

  //Stocke le nom de notre ville
  String nomVille;
  //Stocke le nom du pays de notre ville
  String nomPays;
  //Stocke le nombre d'habitants de notre ville
  int nbreHabitants;

  //Constructeur par défaut
  public Ville(){
    System.out.println("Création d'une ville !");          
    nomVille = "Inconnu";
    nomPays = "Inconnu";
    nbreHabitants = 0;
  }

  //Constructeur avec paramètres
  //J'ai ajouté un « p » en première lettre des paramètres.
  //Ce n'est pas une convention, mais ça peut être un bon moyen de les repérer.
  public Ville(String pNom, int pNbre, String pPays)
  {
    System.out.println("Création d'une ville avec des paramètres !");
    nomVille = pNom;
    nomPays = pPays;
    nbreHabitants = pNbre;
  }        
}

Dans ce cas, l'exemple de déclaration et d'initialisation d'un objet Ville que je vous ai montré un peu plus haut fonctionne sans aucun souci ! Mais il vous faudra respecter scrupuleusement l'ordre des paramètres passés lors de l'initialisation de votre objet : sinon, c'est l'erreur de compilation à coup sûr ! Ainsi :

1
2
3
4

//L'ordre est respecté -> aucun souci
Ville ville1 = new Ville("Marseille", 123456789, "France");
//Erreur dans l'ordre des paramètres -> erreur de compilation au final
Ville ville2 = new Ville(12456, "France", "Lille");

Par contre, notre objet présente un gros défaut : les variables d'instance qui le caractérisent sont accessibles dans votre classe contenant votre main ! Ceci implique que vous pouvez directement modifier les attributs de la classe. Testez ce code et vous verrez que le résultat est identique à la figure suivante :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public class Sdz1 {

  public static void main(String[] args)
  {
    Ville ville =  new Ville();
    System.out.println(ville.nomVille);
    ville.nomVille = "la tête à toto ! ! ! !";
    System.out.println(ville.nomVille);

    Ville ville2 = new Ville("Marseille", 123456789, "France");
    ville2.nomPays = "La tête à tutu ! ! ! ! ";
    System.out.println(ville2.nomPays);
  }

}

Vous constatez que nous pouvons accéder aux variables d'instance en utilisant le « . », comme lorsque vous appelez la méthode subString() de l'objet String. C'est très risqué, et la plupart des programmeurs Java vous le diront. Dans la majorité des cas, nous allons contrôler les modifications des variables de classe, de manière à ce qu'un code extérieur ne fasse pas n'importe quoi avec nos objets ! En plus de ça, imaginez que vous souhaitiez faire quelque chose à chaque fois qu'une valeur change ; si vous ne protégez pas vos données, ce sera impossible à réaliser… C'est pour cela que nous protégeons nos variables d'instance en les déclarant private, comme ceci :

1
2
3
4
5
6
7
8

public class Ville {

  private String nomVille;
  private String nomPays;
  private int nbreHabitants;

  //…     
}

Désormais, ces attributs ne sont plus accessibles en dehors de la classe où ils sont déclarés ! Nous allons maintenant voir comment accéder tout de même à nos données.

Accesseurs et mutateurs

Un accesseur est une méthode qui va nous permettre d'accéder aux variables de nos objets en lecture, et un mutateur nous permettra d'en faire de même en écriture ! Grâce aux accesseurs, vous pourrez afficher les variables de vos objets, et grâce aux mutateurs, vous pourrez les modifier :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

public class Ville {

  //Les variables et les constructeurs n'ont pas changé…

  //*************   ACCESSEURS *************

  //Retourne le nom de la ville
  public String getNom()  {  
    return nomVille;
  }

  //Retourne le nom du pays
  public String getNomPays()
  {
    return nomPays;
  }

  // Retourne le nombre d'habitants
  public int getNombreHabitants()
  {
    return nbreHabitants;
  } 

  //*************   MUTATEURS   *************

  //Définit le nom de la ville
  public void setNom(String pNom)
  {
    nomVille = pNom;
  }

  //Définit le nom du pays
  public void setNomPays(String pPays)
  {
    nomPays = pPays;
  }

  //Définit le nombre d'habitants
  public void setNombreHabitants(int nbre)
  {
    nbreHabitants = nbre;
  }  
}

Nos accesseurs sont bien des méthodes, et elles sont public pour que vous puissiez y accéder depuis une autre classe que celle-ci : depuis le main, par exemple. Les accesseurs sont du même type que la variable qu'ils doivent retourner. Les mutateurs sont, par contre, de type void. Ce mot clé signifie « rien » ; en effet, ces méthodes ne retournent aucune valeur, elles se contentent de les mettre à jour.

À présent, essayez ce code dans votre méthode main :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

Ville v = new Ville();
Ville v1 = new Ville("Marseille", 123456, "France");       
Ville v2 = new Ville("Rio", 321654, "Brésil");

System.out.println("\n v = "+v.getNom()+" ville de  "+v.getNombreHabitants()+ " habitants se situant en "+v.getNomPays());
System.out.println(" v1 = "+v1.getNom()+" ville de  "+v1.getNombreHabitants()+ " habitants se situant en "+v1.getNomPays());
System.out.println(" v2 = "+v2.getNom()+" ville de  "+v2.getNombreHabitants()+ " habitants se situant en "+v2.getNomPays()+"\n\n");

/*
  Nous allons interchanger les Villes v1 et v2
  tout ça par l'intermédiaire d'un autre objet Ville.        
*/       
Ville temp = new Ville();
temp = v1;
v1 = v2;
v2 = temp;

System.out.println(" v1 = "+v1.getNom()+" ville de  "+v1.getNombreHabitants()+ " habitants se situant en "+v1.getNomPays());
System.out.println(" v2 = "+v2.getNom()+" ville de  "+v2.getNombreHabitants()+ " habitants se situant en "+v2.getNomPays()+"\n\n");

/*       
  Nous allons maintenant interchanger leurs noms
  cette fois par le biais de leurs mutateurs.
*/   
v1.setNom("Hong Kong");
v2.setNom("Djibouti");

System.out.println(" v1 = "+v1.getNom()+" ville de  "+v1.getNombreHabitants()+ " habitants se situant en "+v1.getNomPays());
System.out.println(" v2 = "+v2.getNom()+" ville de  "+v2.getNombreHabitants()+ " habitants se situant en "+v2.getNomPays()+"\n\n");

À la compilation, vous devriez obtenir la figure suivante :

Vous voyez bien que les constructeurs ont fonctionné, que les accesseurs tournent à merveille et que vous pouvez commencer à travailler avec vos objets Ville. Par contre, pour afficher le contenu, on pourrait faire plus simple, comme par exemple créer une méthode qui se chargerait de faire tout ceci… Je sais ce que vous vous dites : « Mais les accesseurs, ce ne sont pas des méthodes ? ». Bien sûr que si, mais il vaut mieux bien distinguer les différents types de méthodes dans un objet :

• les constructeurs -> méthodes servant à créer des objets ;
• les accesseurs -> méthodes servant à accéder aux données des objets ;
• les méthodes d'instance → méthodes servant à la gestion des objets.

Avec nos objets Ville, notre choix est un peu limité par le nombre de méthodes possibles, mais nous pouvons tout de même en faire une ou deux pour l'exemple :

• faire un système de catégories de villes par rapport à leur nombre d'habitants ( <1000 -> A, <10 000 -> B…). Ceci est déterminé à la construction ou à la redéfinition du nombre d'habitants : ajoutons donc une variable d'instance de type char à notre classe et appelons-la categorie. Pensez à ajouter le traitement aux bons endroits ;
• faire une méthode de description de notre objet Ville ;
• une méthode pour comparer deux objets par rapport à leur nombre d'habitants.

Par contre, un problème va se poser ! Vous savez déjà qu'en Java, on appelle les méthodes d'un objet comme ceci : monString.subString(0,4);. Cependant, vu qu'il va falloir qu'on travaille depuis l'intérieur de notre objet, vous allez encore avoir un mot clé à retenir… Cette fois, il s'agit du mot clé this. Voici tout d'abord le code de notre classe Ville en entier, c'est-à-dire comportant les méthodes dont on vient de parler :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

public class Ville {

  private String nomVille;
  private String nomPays;
  private int nbreHabitants;
  private char categorie;

  public Ville(){
    System.out.println("Création d'une ville !");          
    nomVille = "Inconnu";
    nomPays = "Inconnu";
    nbreHabitants = 0;
    this.setCategorie();
  }

  public Ville(String pNom, int pNbre, String pPays)
  {
    System.out.println("Création d'une ville avec des paramètres !");
    nomVille = pNom;
    nomPays = pPays;
    nbreHabitants = pNbre;
    this.setCategorie();
  }  

  //Retourne le nom de la ville
  public String getNom()  {  
    return nomVille;
  }

  //Retourne le nom du pays
  public String getNomPays()
  {
    return nomPays;
  }

  // Retourne le nombre d'habitants
  public int getNombreHabitants()
  {
    return nbreHabitants;
  } 

  //Retourne la catégorie de la ville
  public char getCategorie()
  {
    return categorie;
  } 

  //Définit le nom de la ville
  public void setNom(String pNom)
  {
    nomVille = pNom;
  }

  //Définit le nom du pays
  public void setNomPays(String pPays)
  {
    nomPays = pPays;
  }

  //Définit le nombre d'habitants
  public void setNombreHabitants(int nbre)
  {
    nbreHabitants = nbre;
    this.setCategorie();
  }  

  //Définit la catégorie de la ville
  private void setCategorie() {

    int bornesSuperieures[] = {0, 1000, 10000, 100000, 500000, 1000000, 5000000, 10000000};
    char categories[] = {'?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};

    int i = 0;
    while (i < bornesSuperieures.length && this.nbreHabitants > bornesSuperieures[i])
      i++;

    this.categorie = categories[i];
  }

  //Retourne la description de la ville
  public String decrisToi(){
    return "\t"+this.nomVille+" est une ville de "+this.nomPays+ ", elle comporte : "+this.nbreHabitants+" habitant(s) => elle est donc de catégorie : "+this.categorie;
  }

  //Retourne une chaîne de caractères selon le résultat de la comparaison
  public String comparer(Ville v1){
    String str = new String();

    if (v1.getNombreHabitants() > this.nbreHabitants)
      str = v1.getNom()+" est une ville plus peuplée que "+this.nomVille;

    else
      str = this.nomVille+" est une ville plus peuplée que "+v1.getNom();

    return str;
  }
}

Pour expliciter le fonctionnement du mot clé this, prenons l'exemple de la méthode comparer(Ville V1). La méthode va s'utiliser comme suit :

1
2
3
4

Ville V = new Ville("Lyon", 654, "France");
Ville V2 = new Ville("Lille", 123, "France");

V.comparer(V2);

Dans cette méthode, nous voulons comparer le nombre d'habitants de chacun des deux objets Ville. Pour accéder à la variable nbreHabitants de l'objet V2, il suffit d'utiliser la syntaxe V2.getNombreHabitants() ; nous ferons donc référence à la propriété nbreHabitants de l'objet V2. Mais l'objet V, lui, est l'objet appelant de cette méthode. Pour se servir de ses propres variables, on utilise alors this.nbreHabitants, ce qui a pour effet de faire appel à la variable nbreHabitants de l'objet exécutant la méthode comparer(Ville V).

Explicitons un peu les trois méthodes qui ont été décrites précédemment.

La méthode categorie()

Elle ne prend aucun paramètre, et ne renvoie rien : elle se contente de mettre la variable de classe categorie à jour. Elle détermine dans quelle tranche se trouve la ville grâce au nombre d'habitants de l'objet appelant, obtenu au moyen du mot clé this. Selon le nombre d'habitants, le caractère renvoyé changera. Nous l'appelons lorsque nous construisons un objet Ville (que ce soit avec ou sans paramètre), mais aussi lorsque nous redéfinissons le nombre d'habitants : de cette manière, la catégorie est automatiquement mise à jour, sans qu'on ait besoin de faire appel à la méthode.

La méthode decrisToi()

Celle-ci nous renvoie un objet de type String. Elle fait référence aux variables qui composent l'objet appelant la méthode, toujours grâce à this, et nous renvoie donc une chaîne de caractères qui nous décrit l'objet en énumérant ses composants.

La méthode comparer(Ville V1)

Elle prend une ville en paramètre, pour pouvoir comparer les variables nbreHabitants de l'objet appelant la méthode et de celui passé en paramètre pour nous dire quelle ville est la plus peuplée ! Et si nous faisions un petit test ?

1
2
3
4
5
6
7
8

Ville v = new Ville();
Ville v1 = new Ville("Marseille", 1236, "France");       
Ville v2 = new Ville("Rio", 321654, "Brésil");

System.out.println("\n\n"+v1.decrisToi());
System.out.println(v.decrisToi());
System.out.println(v2.decrisToi()+"\n\n");
System.out.println(v1.comparer(v2));

Ce qui devrait donner le résultat de la figure suivante :

Je viens d'avoir une idée : et si nous essayions de savoir combien de villes nous avons créées ? Comment faire ? Avec une variable de classe !

Les variables de classes

Comme je vous le disais au début de ce chapitre, il y a plusieurs types de variables dans une classe. Nous avons vu les variables d'instance qui forment la carte d'identité d'un objet ; maintenant, voici les variables de classe.

Celles-ci peuvent s'avérer très utiles. Dans notre exemple, nous allons compter le nombre d'instances de notre classe Ville, mais nous pourrions les utiliser pour bien d'autres choses (un taux de TVA dans une classe qui calcule le prix TTC, par exemple).

La particularité de ce type de variable, c'est qu'elles seront communes à toutes les instances de la classe !

Créons sans plus attendre notre compteur d'instances. Il s'agira d'une variable de type int que nous appellerons nbreInstance, et qui sera public ; nous mettrons aussi son homologue en private en place et l'appellerons nbreInstanceBis (il sera nécessaire de mettre un accesseur en place pour cette variable). Afin qu'une variable soit une variable de classe, elle doit être précédée du mot clé static. Cela donnerait dans notre classe Ville :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class Ville {

  //Variables publiques qui comptent les instances
  public static int nbreInstances = 0;

  //Variable privée qui comptera aussi les instances
  private static int nbreInstancesBis = 0;        

  //Les autres variables n'ont pas changé

  public Ville(){
    //On incrémente nos variables à chaque appel aux constructeurs
    nbreInstances++;
    nbreInstancesBis++;          
    //Le reste ne change pas.
  }

  public Ville(String pNom, int pNbre, String pPays)
  {  
    //On incrémente nos variables à chaque appel aux constructeurs
    nbreInstances++;
    nbreInstancesBis++;          
    //Le reste ne change pas
  }
  public static int getNombreInstancesBis()
  {
    return nbreInstancesBis;
  }  
  //Le reste du code est le même qu'avant
}

Vous avez dû remarquer que l'accesseur de notre variable de classe déclarée privée est aussi déclaré static : ceci est une règle ! Toutes les méthodes de classe n'utilisant que des variables de classe doivent être déclarées static. On les appelle des méthodes de classe, car il n'y en a qu'une pour toutes vos instances. Par contre ce n’est plus une méthode de classe si celle-ci utilise des variables d'instance en plus de variables de classe…

À présent, si vous testez le code suivant, vous allez constater l'utilité des variables de classe :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Ville v = new Ville();                
System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.nbreInstances);
System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.getNombreInstancesBis());

Ville v1 = new Ville("Marseille", 1236, "France");        
System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.nbreInstances);
System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.getNombreInstancesBis());

Ville v2 = new Ville("Rio", 321654, "Brésil");        
System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.nbreInstances);
System.out.println("Le nombre d'instances de la classe Ville est : " + Ville.getNombreInstancesBis());

Le résultat, visible à la figure suivante, montre que le nombre augmente à chaque instanciation.

Lorsque vous avez vu les méthodes, vous les avez déclarées public. Vous auriez également pu les déclarer private, mais attention, dans les deux cas, il faut aussi qu'elles soient static, car elles sont exécutées dans un contexte static : la méthode main.

Le principe d'encapsulation

Voilà, vous venez de construire votre premier objet « maison ». Cependant, sans le savoir, vous avez fait plus que ça : vous avez créé un objet dont les variables sont protégées de l'extérieur. En effet, depuis l'extérieur de la classe, elles ne sont accessibles que via les accesseurs et mutateurs que nous avons défini. C'est le principe d'encapsulation !

En fait, lorsqu'on procède de la sorte, on s'assure que le fonctionnement interne à l'objet est intègre, car toute modification d'une donnée de l'objet est maîtrisée. Nous avons développé des méthodes qui s'assurent qu'on ne modifie pas n'importe comment les variables.

Prenons l'exemple de la variable nbreHabitants. L'encapsuler nous permet, lors de son affectation, de déduire automatiquement la catégorie de l'objet Ville, chose qui n'est pas facilement faisable sans encapsulation. Par extension, si vous avez besoin d'effectuer des opérations déterminées lors de l'affectation du nom d'une ville par exemple, vous n'aurez pas à passer en revue tous les codes source utilisant l'objet Ville : vous n'aurez qu'à modifier l'objet (ou la méthode) en question, et le tour sera joué.

Si vous vous demandez l'utilité de tout cela, dites-vous que vous ne serez peut-être pas seuls à développer vos logiciels, et que les personnes utilisant vos classes n'ont pas à savoir ce qu'il s'y passe : seules les fonctionnalités qui leurs sont offertes comptent. Vous le verrez en continuant la lecture de cet ouvrage, Java est souple parce qu'il offre beaucoup de fonctionnalités pouvant être retravaillées selon les besoins, mais gardez à l'esprit que certaines choses vous seront volontairement inaccessibles, pour éviter que vous ne « cassiez » quelque chose.

• Une classe permet de définir des objets. Ceux-ci ont des attributs (variables d'instance) et des méthodes (méthodes d’instance + accesseurs).
• Les objets permettent d'encapsuler du code et des données.
• Le ou les constructeurs d'une classe doivent porter le même nom que la classe et n'ont pas de type de retour.
• L'ordre des paramètres passés dans le constructeur doit être respecté.
• Il est recommandé de déclarer ses variables d'instance private, pour les protéger d'une mauvaise utilisation par le programmeur.
• On crée des accesseurs et mutateurs (méthodes getters et setters) pour permettre une modification sûre des variables d'instance.
• Dans une classe, on accède aux variables de celle-ci grâce au mot clé this.
• Une variable de classe est une variable devant être déclarée static.
• Les méthodes n'utilisant que des variables de classe doivent elles aussi être déclarées static.
• On instancie un nouvel objet grâce au mot clé new.

• Java Orienté Objet
• Sommaire
• L'héritage