Chapitre 1 : Déclaration et contrôle d'accès

II-A-1. La classe Enum▲

public enum Planetes <T> {//erreur de compilation
  TERRE, MARS, MERCURE,VENUS,JUPITER,
  SATURNE,URANUS,NEPTUNE;
  
  T value;
}

public class Ecole {
  enum Titre {MONSIEUR, MADAME}//ok
  
  public class Classe {
     enum Titre {CHEF, SOUS_CHEF}// erreur de compilation
  }  
}

static EnumTypeName[] values()
static EnumTypeName valueOf(String name)

enum Planetes{
  TERRE, MARS, MERCURE, VENUS, JUPITER,
  SATURNE, URANUS, NEPTUNE
}

public class Univers {
  
  public static void main(String[] args){
     Planetes[] values = Planetes.values();

         for(Planetes value : values){
            System.out.print(value+", ");
         }
  }
}
//output : TERRE, MARS, MERCURE, VENUS, JUPITER, SATURNE, URANUS, NEPTUNE

II-A-2. Déclaration▲

//Énumération dans une classe
public class Univers {
  public enum Planetes{
    TERRE, MARS, MERCURE, VENUS, JUPITER,
    SATURNE, URANUS, NEPTUNE
  }
  
public static void main(String[] args){
   Planetes[] values = Planetes.values();
        for(Planetes value : values){
            System.out.print(value+", ");
        }
 }
   }

//Énumération dans le fichier  Planetes.java
 public enum Planetes{
    TERRE, MARS, MERCURE, VENUS,  JUPITER, SATURNE, URANUS, NEPTUNE
}

public enum Planetes{
    TERRE(30), MARS(40), MERCURE(50);
        
        private double rayon;
        
        Planetes(double rayon){
           this.rayon = rayon;
        }       
        
        public double getRayon(){
           return rayon;
        }
}

public enum Planetes{           
        private double rayon;
    
   TERRE, MARS, MERCURE;//erreur de compilation les constantes doivent venir en premier
}

public enum Planetes{                     
   TERRE, MARS, MERCURE
}

//son équivalent  en terme de constante Java est le suivant :

   public enum Planetes{                  
      public static final Planetes TERRE = new Planetes();
      public static final Planetes MARS = new Planetes();
      public static final Planetes MERCURE = new Planetes();
   }

public enum Planetes{                     
   TERRE(){ public String getName(){return "Terre";}}, 
   MARS(){ public String getName(){return "Mars";}},
   MERCURE(){ public String getName(){return "Mercure";}};
   
   public abstract String getName();
}

public enum Planetes{                     
   TERRE, MARS, MERCURE //OK
}

public enum Planetes{                     
   TERRE, MARS, MERCURE //erreur la liste des constantes doit s'achever avec un " ; "   
   public String rayon;
}

public enum Planetes{                     
   TERRE, MARS, MERCURE; //OK   
   public String rayon;
}

II-A-3. Constructeur▲

public enum Planetes{                     
   TERRE, MARS, MERCURE;
  
  private double rayon;

  public Planetes(){
     rayon = 0;
  }
  
  public static void main(String[] args){
     Planetes ptes = new Planetes();//Erreur de compilation
  }
}

public enum Astre {
    Mars("planete",12),scrunch("asteroide",1.25f);
    private final float diametre;
    private final String type;
    private Astre(String type,float diametre){
        this.diametre=diametre;
        this.type=type;
    }
}

• Si la variable n'est pas un booléen, le préfixe d'un getter doit être « get ».
• Si la variable est un booléen, le préfixe du getter est « get » ou « is ».
• Le préfixe d'un setter doit être « set ».
• Pour compléter le nom d'un getter ou d'un setter, on transforme la première lettre de la variable en majuscule puis on l'ajoute au préfixe.
• Un setter doit être public, il ne doit retourner aucune valeur (le type retour est void), il prend en paramètre un argument de même type que la variable.
• Un getter doit être public, il ne prend aucun argument et retourne une valeur de même type que l'argument du setter.
• Exemple de composant JavaBean :

public class JavaBean {

   private boolean visible;
   private int taille;
   
   public JavaBean(){}
   
   public boolean isVisible(){ return visible; }
   
   public void setVisible(boolean visible){ this.visible = visible;}
   
   public int getTaille(){ return taille}
   
   public void setTaille(int taille){ this.taille = taille;}      
}

Les événements en Java sont des mécanismes permettant aux composants d'envoyer des signaux à d'autres. Ainsi, lorsqu'un composant a besoin d'un signal particulier pour pouvoir accomplir une action, il va demander à se faire enregistrer pour ledit événement. Et à chaque fois que l'événement va se produire, le composant sera informé jusqu'à ce qu'il soit déconnecté. Afin de normaliser les méthodes d'enregistrement et de déconnexion auprès des événements, les conventions de nommage suivantes ont été définies :

• une méthode d'écoute, chargée d'enregistrer un écouteur doit avoir comme préfixe « add », suivi du type de l'écouteur. Exemple : addActionListener() ;
• une méthode d'écoute charger de supprimer un écouteur doit avoir comme préfixe « remove », suivi du type de l'écouteur. Exemple removeActionListener() ;
• la méthode d'écoute doit prendre en paramètre un argument du type de l'écouteur à supprimer ou à enregistrer ;
• le nom de la méthode d'écoute doit s'achever par le mot « Listener ».
• Exemple de classe JavaBean avec méthodes d'écoute :

public class JavaBean {

   private boolean visible;
   private int taille;
   
   private List<ActionListener> listeners = new ArrayList();
   
   public JavaBean(){}
   
   public boolean isVisible(){ return visible; }
   
   public void setVisible(boolean visible){ this.visible = visible;}
   
   public int getTaille(){ return taille}
   
   public void setTaille(int taille){ this.taille = taille;}   

   public void addActionListener(ActionListener istener){listeners.add(listener);}   
   
   public void removeActionListener(ActionListener listener){listeners.remove(listener);}
}

• Il peut y avoir uniquement une classe public par fichier de code source.
• Les commentaires peuvent apparaître à n'importe quel endroit dans un fichier source.
• Si un fichier source contient une classe public, le nom du fichier doit correspondre au nom de la classe public.
• Si la classe appartient à un package, l'instruction package doit être la première instruction du fichier avant les instructions imports.
• S'il y a des instructions imports, elles doivent être placées entre l'instruction package (si le fichier appartient à un package) et la déclaration de la classe.
• Les instructions imports et package sont valables pour toutes les classes contenues dans un fichier source.
• Un fichier source peut contenir plusieurs classes non public.

//Le fichier a pour nom Voiture.java
public class Voiture {}

class Totoyota  extends Voiture{}

class Peugeot extends Voiture{}

• Un fichier source sans classe public n'a pas l'obligation d'avoir un nom similaire à l'une des classes qu'il contient.

//Le nom du fichier peut être quelconque exemple : Marques.java
class Voiture {}

class Toyota  extends Voiture{}

class Peugeot extends Voiture{}

• Une classe ayant un modificateur d'accès par défaut n'est accessible que par les classes du même package. On l'obtient en ne faisant précéder la déclaration de la classe d'aucun modificateur.

public class Voiture {} //modificateur d'accès public

class Toyota {} //modificateur d'accès par defaut

• Une classe avec le modificateur d'accès public est accessible par toutes les classes de n'importe quels packages.
• Une déclaration de classe précédée du mot clé final signifie que l'on ne peut pas étendre cette classe.
• Une classe abstract ne peut pas être instanciée. Sa principale raison d'être se trouve dans l'extension.
• Une méthode abstract se termine par un point-virgule sans accolades.

abstract class Voiture {
   
   public abstract void rouler();
} 

public class Toyota {

   public Toyota(){
      Voiture v = new Voiture();//Erreur à la compilation
   }
}

• Si dans une classe on a une méthode abstract, il faut que la classe soit aussi déclarée abstract.
• Il est possible de mettre des méthodes concrètes dans une classe abstract.
• Une classe abstract peut avoir un constructeur.
• Toute classe concrète qui étend une classe abstract doit obligatoirement fournir une implémentation de toutes les méthodes abstract.
• Les combinaisons suivantes sont illégales :

static abstract void DoSomething();
strictfp abstract void DoSomething();
native abstract void DoSomething();
synchronized abstract void DoSomething();
private abstract  void DoSomething();

• Une interface peut étendre une ou plusieurs interfaces.
• Une interface ne peut pas étendre une classe.
• Une interface ne peut pas implémenter (implements) une classe ou une autre interface.
• La déclaration d'une interface se fait à l'aide du mot clé interface.
• Une classe qui implements une interface doit fournir une implémentation concrète de toutes les méthodes contenues dans l'interface. Sinon, la classe doit être déclarée abstract.

• Toutes les variables d'une interface sont implicitement public, static, final. Bref tous les attributs d'une interface sont des constantes.
• Partant de la règle précédente (tous les attributs d'une interface sont des constantes), il en vient que tous les attributs d'une interface doivent être initialisés à la création.
• Une interface ne peut pas contenir une variable non initialisée.

public interface MyInterface {
   int value; //Erreur de compilation. car value est implicitement public static final
   
   int value1 = 1;//ok
   public int value2 = 1;//ok
   static int value3 = 1;//ok
   final int value4 = 1;//ok
   public static final int value5 = 1;//ok
   static final int value6 = 1;//ok
}

• Une interface peut uniquement avoir des méthodes abstraites (abstract).
• Toutes les méthodes d'une interface sont implicitement public et abstract.
• Partant de la règle précédente (les méthodes d'une interface sont public et abstract), on déduit que les méthodes d'une interface ne peuvent pas être : static, final, strictfp ou native.

• Il y a deux types de variables en Java :
• Une variable d'instance est une variable définie à l'intérieur d'une classe et en dehors des méthodes ou du constructeur.

class Toyota {

   public int nbreRoues;   //variable d'instance
   
   public Toyota(){
      String nom = "";//variable locale
   }
   
   public int vitesse(){
      double speed = 0;//variable locale
   }
}

• Une variable d'instance peut être : public, private, protected, final, transient. Mais ne peut pas être abstract, synchronized, strictfp, static, native.
• Les variables static sont des variables de classes pas des variables d'instances. Car une variable static appartient à toutes les instances d'une même classe.
• Les variables locales sont des variables définies à l'intérieur d'une méthode, d'un constructeur ou d'un bloc d'initialisation.
• Une variable locale doit être initialisée avant d'être utilisée.

class Toyota {
   public int vitesse(){
    boolean isOk;
        while(isOk){}//Erreur à la compilation. isOk doit être initialisée avant toute utilisation
   }
}

• Une variable final ne peut pas être initialisée deux fois.

class Toyota {

   private final int nbreRoues;
   private final int vitesse = 0;
   
   public Toyota(){
      nbreRoues = 15;//ok
           vitesse = 12;//erreur de compilation la variable final a déjà été initialisée
   }      
}

Cette fonctionnalité a été ajoutée à Java 5.0, elle permet aux développeurs de créer des méthodes avec un nombre d'arguments variable. Et se comporte comme un tableau :

class Toyota {

   public Toyota(){
      rouler();//ok
        rouler(12);//ok
        rouler(12,0,12);//ok
   }      
   
   public void rouler(int... values){
     for(int i = 0; i < values.length; i++){
             System.out.println("i = "+values[i]);
          }
    }
 }

• Pour définir un argument variable, il faut :
• L'argument variable doit être défini en dernière position et on ne peut définir qu'un seul argument variable par méthode.

class Toyota {
   
   public void rouler(int... values){}//ok
   
   public void rouler(int... values, int speed){}//erreur de compilation
   
   public void rouler(int... values, int... speed){}//erreur de compilation
}

• Une méthode à argument variable peut prendre zéro ou plusieurs arguments.
• Les arguments variables se comportent comme des tableaux. Pour accéder à une valeur ou au nombre d'éléments contenus dans l'argument, on procède de la même façon que dans le cas des tableaux.

• Les éléments qui peuvent être static : les méthodes, les variables, les classes encastrées définies en dehors des méthodes, les blocs d'initialisation.
• Les éléments qui ne peuvent pas être static : les constructeurs, les classes, les interfaces, les variables locales, les classes définies à l'intérieur d'une méthode, les éléments d'une classe encastrée non static.
• L'encapsulation est un mécanisme Java qui concoure à la maintenabilité, la flexibilité et l'extensibilité des applications. Pour la mettre en œuvre, il faut :
• L'accès et la modification des variables à travers des méthodes publiques, permettent la modification ultérieure d'une classe sans altérer les classes qui utilisent les services de la classe modifiée.

• Erreurs
  On ne peut définir qu'un seul argument variable par méthode. La méthode public static void addToFavorites(String… values, int… id) produira donc une erreur de compilation. Nous allons la commenter.
  L'argument variable concerne le type String et non les entiers. D'où la ligne addToFavorites(103,104,105); sera commentée.
• Solution
  Une fois les corrections faites, nous avons les résultats suivants :

id and values
 values
 id and values
 id and values

• Erreurs
  Si les deux classes sont mises dans le même fichier . java, il faut s'assurer que le nom du fichier est TestEnum, à cause de son modificateur d'accès qui est public.
  Le constructeur d'un type enum ne peut pas être public. D'où, il faut supprimer le modificateur d'accès placer juste avant le constructeur public Animals(String s).
  On ne peut pas directement accéder à une variable de classe dans une méthode static. Il faudra faire précéder la déclaration de la variable Animals b; du mot clé static.
• Solution
  Une fois les corrections faites, nous avons les résultats suivants :

chien poisson chat
 ordinals : 0

• Erreurs
  La variable this est de type final. De ce fait, on ne peut pas lui affecter une valeur après création. C'est pour cette raison que nous allons commenter la ligne : this = new ThisVar();.
  Le mot clé this permet de référencer l'objet courant. Or, les variables locales ne sont pas accessibles à l'extérieur de la méthode dans laquelle elles ont été déclarées. Ainsi, il est impossible d'indexer une variable locale à l'aide du mot clé this. D'où nous allons commenter la ligne : this.i = 4;.

• Erreurs
  La variable a n'est précédée d'aucun modificateur d'accès. Raison pour laquelle elle n'est pas accessible en dehors du package pkgB. Pour résoudre le problème, nous allons soit changer le modificateur d'accès, soit commenter la ligne.
  La variable b est précédée du modificateur protected. Ainsi, elle n'est pas accessible à l'extérieur du package pkgB à travers une instance de la classe Poisson. Même solution que la précédente.
  La variable d est private, alors elle n'est accessible qu'à l'intérieur de la classe Poisson.
• Solution
  Le résultat dépendra des corrections apportées.

• Erreurs
  Une méthode static ne peut accéder directement à une méthode ou une variable non static. C'est le cas avec la méthode marcher(int, int). Pour résoudre le problème, on va faire précéder la méthode marcher(int,int) du mot clé static.
• Solution
  Le résultat après correction de l'anomalie est : 13.

Conclusion

Dans le prochain chapitre, nous allons aborder les notions liées à la programmation orientée objet. Cependant, avant de clore cet article, je voudrais adresser mes remerciements à FirePrawnFirePrawnetMaxMax pour la relecture orthographique, à thierrylerthierryler pour ses propositions et Mickael Baronmickael-baron pour ses propositions, ses encouragements et le temps consacré pour les diverses relectures.

Pour réaliser cet article, j'ai fait usage de deux livres que je trouve complémentaires et que je n'hésite pas à vous conseiller. Il s'agit de :

- SCJP Sun Certied Programmer for Java 6 Study Guide de Kathy Sierra et Bert Bates

- À Programmer's Guide to Java™ SCJP Certification Third Edition de Khalid A. Mughal et Rolf W. Rasmussen

Suivez-moi sur twitter