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

Le but de cet article est de présenter les notions fondamentales du langage Java de façon concise. Globalement, nous parlerons des énumérations, des classes et des interfaces en prenant le soin de traiter chaque point dans les détails.

25 commentaires Donner une note à l'article (5)

Article lu   fois.

L'auteur

Site personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Introduction

Plusieurs parmi nous (je suis le premier) ont appris le langage Java en rassemblant des bouts de code dans le but de réaliser un logiciel (ce qu'on a coutume d'appeler formation sur le tas). Quoique cela a toujours fini par donner un résultat, on ne saurait cependant renier son inconvénient majeur : à la fin on ne sait jamais comment les choses fonctionnent au fond. Ce qui peut avoir pour conséquence : la mauvaise utilisation des types d'objets, la mauvaise utilisation de la mémoire et parfois occasionne des pertes en temps énormes suite à une mauvaise approche lors du débogage.

L'objectif de ce premier article de la suite le mémo du certifier Java SE 6 est de mettre à la disposition du développeur l'information succincte concernant les énumérations, des classes, des interfaces, les règles sur les identifiants et le standard JavaBean. A l'issu de cette présentation, cinq exercices corrigés sont mis à la disposition du lecteur pour des besoins d'évaluation personnelle. Je conseille vivement que ce test soit effectué avant et après la lecture de l'article.

II. Énumérations

C'est une structure de données introduite dans la version 5 de Java. Elle permet de construire avec beaucoup plus de simplicité une liste de constantes homogènes.

 
Sélectionnez
//Exemple de constantes dans une classe
public class Planetes{
  public static final int TERRE = 0;
  public static final int MARS = 1;
  public static final int MERCURE = 2;
  public static final int VENUS = 3;
  public static final int JUPITER = 4;
  public static final int SATURNE = 5;
  public static final int URANUS = 6;
  public static final int NEPTUNE = 7;
}
 
Sélectionnez
//Exemple d'énumération
public enum Planetes{
  TERRE, MARS, MERCURE, VENUS, JUPITER,
  SATURNE, URANUS, NEPTUNE
}

II-A. Les règles

II-A-1. La classe Enum

  • Une classe de type enum est implicitement final à moins qu'une des constantes ne contienne un corps de classe. C'est une erreur de compilation d'utiliser le modificateur d'accès "abstract" ou "final" pour la déclaration d'un enum.
  • D'après la première règle, on ne peut pas étendre les classes de type enum.
  • La généricité n'est pas applicable aux classes de type enum.
 
Sélectionnez
public enum Planetes <T> {//erreur de compilation
  TERRE, MARS, MERCURE,VENUS,JUPITER,
  SATURNE,URANUS,NEPTUNE;
  
  T value;
}
  • Lorsqu'on déclare un type enum à l'intérieur d'une classe, il est implicitement static.
  • D'après la règle précédente, un type enum ne peut pas être déclaré à l'intérieur d'une classe encastrée (nested class) non static.
 
Sélectionnez
public class Ecole {
  enum Titre {MONSIEUR, MADAME}//ok
  
  public class Classe {
     enum Titre {CHEF, SOUS_CHEF}// erreur de compilation
  }  
}
  • Tous les types enum sont comparables et sérialisables.
  • Une classe de type enum ne peut pas étendre une autre classe, mais peut implémenter plusieurs interfaces.
  • Tous les types enum étendent la classe java.lang.Enum raison pour laquelle ils ne peuvent pas en étendre une autre.
  • Les classes de type enum contiennent deux méthodes static : values() et valueOf().
 
Sélectionnez
static EnumTypeName[] values()
static EnumTypeName valueOf(String name)
  1. La méthode values() retourne un tableau des constantes d'énumération dans leur ordre de déclaration.
 
Sélectionnez
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
  1. La méthode valueOf(String name) convertit une chaîne de caractère en l'énumération correspondante et génère l'exception IllegalArgumentException si l'argument ne correspond à aucune.

II-A-2. Déclaration

  • Une constante d'énumération peut être n'importe quel identifiant Java conforme aux règles.
  • Une énumération peut être définie à l'intérieur d'une classe ou dans un fichier comme toutes classes Java.
 
Sélectionnez
//Enumé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+", ");
        }
 }
   }
 
Sélectionnez
//Enumération dans le fichier  Planetes.java
 public enum Planetes{
    TERRE, MARS, MERCURE, VENUS,  JUPITER, SATURNE, URANUS, NEPTUNE
}
  • Une énumération ne peut pas être définie à l'intérieur d'une méthode.
  • public et default sont les seuls modificateurs d'accès applicable aux énumérations définies dans un fichier Java (pas à l'intérieur d'une classe).
  • L'ordre dans lequel les constantes d'énumérations sont définies compte. Et cet ordre est utilisé dans la comparaison entre deux constantes à l'aide de la méthode compare.
  • Il est possible d'ajouter des constructeurs, des variables ou des méthodes dans une classe de type enum.
 
Sélectionnez
public enum Planetes{
    TERRE(30), MARS(40), MERCURE(50);
        
        private double rayon;
        
        Planetes(double rayon){
           this.rayon = rayon;
        }       
        
        public double getRayon(){
           return rayon;
        }
}
  • Si une classe de type enum comporte un constructeur, une méthode ou un attribut, les constantes d'énumération doivent être déclarées en premier lieu. Dans le cas contraire une erreur de compilation va se produire.
 
Sélectionnez
public enum Planetes{           
        private double rayon;
    
   TERRE, MARS, MERCURE;//erreur de compilation les constantes doivent venir en premier
}
  • Les énumérations sont des constantes (variables final static) de type enum, de ce fait, elles sont initialisées après le chargement de la classe en mémoire.
 
Sélectionnez
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();
   }
  • Il n'est pas obligatoire de mettre un point-virgule à la fin d'une déclaration des énumérations.
  • Il est possible de déclarer une méthode abstraite dans une classe de type enum, dans ce cas, chaque énumération devrait fournir une implémentation de la méthode sinon une erreur va se produire à la compilation.
 
Sélectionnez
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();
}
  • Si l'on déclare un attribut, une méthode ou un constructeur dans une classe de type enum, la liste des énumérations doit se terminer par un point-virgule.
 
Sélectionnez
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

  • Il n'est pas possible de faire directement appel au constructeur d'une énumération.
 
Sélectionnez
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
  }
}
  • Le constructeur d'une énumération peut avoir comme modificateur d'accès : private ou default, dans le cas contraire une erreur va se produire à la compilation.
  • On peut passer plusieurs paramètres au constructeur d'une classe de type enum
 
Sélectionnez
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;
    }
}

II-B. Quelques méthodes importantes de la classe Enum

 
Sélectionnez
package java.lang;

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable {
                
        //Sole constructor.  Programmers cannot invoke this constructor.        
        protected Enum(String name, int ordinal)
        
        //The name of this enum constant, as declared in the enum declaration   
        private final String name;
        
        //il retourne la position d'un constant. Le premier élément est en zéro
        private final int ordinal
        
        //Returns the name of this enum constant, exactly as declared in its  enum declaration
        public final String name(){}
        
        //Returns the ordinal of this enumeration constant
        public final int ordinal()
        
        //Returns the enum constant of the specified enum type with the  specified name
        public static <T extends Enum<T>> T valueOf(Class<T> enumType,String name)
        
        public String toString()        
}

III. Règles sur les identifiants Java

  • Un identifiant Java peut être composé à base des caractères Unicodes, des nombres, des symboles de devise ou du caractère underscore (_).
 
Sélectionnez
Identifiants corrects : number, Number, sum_$, bingo, $$_100, 
                   mål, grüß,$1, &#162;d, ¥2, £_
Identifiants incorrects : 48chevy, all@hands, grand-sum
  • Un identifiant Java peut débuter par une lettre, un symbole de devise, le caractère underscore, mais jamais par un nombre.
  • Après le premier caractère, un identifiant Java peut contenir n'importe quelle combinaison de lettres, de symbole de devis, d'underscores et de nombres.
  • Le nombre de caractères qui compose un identifiant n'est pas limité.
  • Il n'est pas possible d'utiliser un mot clé Java comme identifiant.
 
Sélectionnez
public class Planetes{                    
  
  public int default = 0;// Erreur de compilation car default est un mot clé Java 
}
  • Les identifiants Java respectent la casse.
 
Sélectionnez
public class Planetes{                    
  //age et Age sont deux identifants Java différents
  public int age;
  public int Age;
}
  • Tous les mots clés Java sont en minuscule.
  • On crée les constantes en Java en faisant précéder une variable des mots clés final et static. De plus, la variable doit être de type primitif et sa valeur doit pouvoir être évaluée par le compilateur.
 
Sélectionnez
//Exemple de constante
    public static final int consommation = 18;
    public static final String nom = "Rav4";
    
    //Ces variables ne sont pas des constantes
    public static final String nom = new String("Rav4");
    public static final char A = Character.valueOf('A');

IV. Le standard JavaBean

  • Les composants JavaBean sont des classes Java qui respectent certaines règles par rapport à la construction et au nommage des méthodes.
  • Comme exemple de règles de construction :

IV-A. Règles sur les getters et les setters

  • 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 :
 
Sélectionnez
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;}      
}

IV-B. Règles sur les méthodes d'écoutes (les listeners)

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 :
 
Sélectionnez
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);}
}

V. La déclaration des classes

La notion de classe constitue le fondement de la programmation objet. C'est une structure de données qui permet de définir le type, le comportement et les attributs d'un objet. En Java, on crée une classe à l'aide du mot clé class suivi du nom de la classe et des accolades.

 
Sélectionnez
class MaClasseJava {                      
  // le corps de la classe
}

V-A. Règles à propos de la déclaration des classes

  • 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.
 
Sélectionnez
//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.
 
Sélectionnez
//Le nom du fichier peut être quelconque exemple : Marques.java
class Voiture {}

class Toyota  extends Voiture{}

class Peugeot extends Voiture{}

V-B. Les modificateurs d'accès pour les classes

  • 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.
 
Sélectionnez
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.
 
Sélectionnez
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 :
 
Sélectionnez
static abstract void DoSomething();
strictfp abstract void DoSomething();
native abstract void DoSomething();
synchronized abstract void DoSomething();
private abstract  void DoSomething();

VI. Règles à propos des interfaces

VI-A. Déclaration des interfaces

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

VI-B. Les variables

  • 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.
 
Sélectionnez
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
}

VI-C. Méthodes

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

VII. Les modificateurs d'accès

  • Default : On obtient le modificateur d'accès par défaut lorsqu'on ne précise aucun modificateur à la déclaration d'un attribut, d'une méthode ou d'une classe. Un élément précédé du modificateur d'accès par défaut n'est accessible qu'au sein du même package.
 
Sélectionnez
package com.voiture;
class Toyota {

   int nbreRoues;
   public int nbrePortes;
   
   int vitesse(){return 17;}
}

/****************************************/

package com.main;
public class Main {

   public static void main(String[] args){
     Toyota t = new Toyota();//Erreur à la compilation. la classe Toyota n'est pas visible hors du package
          t.nbreRoues = 4;//erreur de compilation
          t.nbrePortes = 2;//erreur de compilation
          int i = t.vitesse();//Erreur de compilation
   }
}
  • Public : un attribut ou une méthode public est accessible par toutes les autres classes qu'elles soient du même package ou pas.
  • Private : un attribut ou une méthode private n'est accessible qu'au sein de sa classe. Une classe fille ne peut pas hériter des attributs ou des méthodes private.
  • Protected : il est presque identique au modificateur par défaut. Cependant, en plus des classes du même package, les classes dérivées peuvent accéder aux elements protected d'une classe.
  • En général, les modificateurs d'accès ne sont pas applicables aux variables locales à l'exception de final et abstract.
 
Sélectionnez
class Toyota {

   private int nbreRoues;   
   
   public void vitesse(){
      final int v = 0;//ok
          abstract class Roue {}//ok
          
          protected String siege = null;//erreur de compilation
   }
}
Visibilité Public Protected Default Private
Au sein de la même classe oui oui oui oui
Au sein du même package oui oui oui non
Au sein d'une sous-classe dans le même package oui oui oui non
Au sein d'une sous-classe dans un package différent oui par héritage non non
Au sein de n'importe quelle classe de n'importe quel package oui non non non

VIII. Les éléments d'une classe

VIII-A. Déclaration des variables

  • 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.
 
Sélectionnez
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.
 
Sélectionnez
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.
 
Sélectionnez
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
   }      
}

VIII-B. Les méthodes à arguments variables

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 :

 
Sélectionnez
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.
 
Sélectionnez
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.

VIII-C. Les éléments static d'une classe

  • Les éléments qui peuvent être static : les méthodes, les variables, les classes encastrées définis 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, permet la modification ultérieure d'une classe sans altérer les classes qui utilisent les services de la classe modifiée.

IX. Compatibilité entre les modificateurs d'accès

IX-A. Class modifier

  public abstract final strictfp
public   oui oui oui
abstract oui   non oui
final oui non   oui
strictfp oui oui oui  

IX-B. Properties (attributes) modifier

  public protected private transient volatile static abstract final
transient oui oui oui   oui oui non oui
volatile oui oui oui oui   oui non non
static oui oui oui oui oui   oui oui
abstract oui oui oui oui non oui   non
final oui oui oui oui non oui non  

IX-C. Method modifier

  public protected private static abstract final synchronized strictfp
native oui oui oui oui non oui oui non
static oui oui oui   non oui oui oui
abstract oui oui non non   non non non
final oui oui oui oui non   oui oui
synchronized oui oui oui oui non oui   oui
strictfp oui oui oui oui non oui oui  

X. Exercices

X-A. Corrigez les erreurs et trouvez le résultat

  java   0 1  
class Browser {
public static void addToFavorites(int id, String... values){
System.out.println("id and values");}
public static void addToFavorites(String... values, int... id){
System.out.println("values and id"); }
public static void addToFavorites(String... values){
System.out.println("values"); }
public static void main(String... args){
addToFavorites(101);
addToFavorites();
addToFavorites(102,"a");
addToFavorites(103,104,105);
new Browser().addToFavorites(106,"x","y","z");
}
}

X-B. Corrigez les erreurs et trouvez le résultat

  java   0 1  
enum Animals {
DOG("chien"), CAT("chat"), FISH("poisson");
String nom;
public Animals(String s) {nom = s;}
}
public class TestEnum {
static Animals a;
Animals b;
public static void main(String[] args){
System.out.println(a.DOG.nom + " " +a.FISH.nom+ " " +b.CAT.nom);
System.out.println("ordinals : "+a.DOG.ordinal());
}
}

X-C. Corrigez les erreurs

  java   0 1  
public class ThisVar {
int planets;
static int suns;
public void gaze() {
int i;
i = this.planets;
i = this.suns;
this = new ThisVar();
this.i = 4;
this.suns = planets; } }

X-D. Corrigez les erreurs et trouvez le résultat

  java   0 1  
package pkgA;
public class Poisson {
int a = 5;
protected int b = 6;
public int c = 7;
private int d = 2;
}
package pkgB;
import pkgA.*;
public class Pecheur {
public static void main(String[] args) {
Poisson p = new Poisson();
System.out.print(" " + p.a);
System.out.print(" " + p.b);
System.out.println(" " + p.c);
System.out.println(" " + p.d);
}
}

X-E. Corrigez les erreurs et trouvez le résultat

  java   0 1  
public class Chat extends Animale {
public static void main(String... args) {
Short _x = 7;
System.out.println(marcher(_x, 6));
}
}
class Animale {
int marcher(int x, int y) { return x + y; }
}

XI. Correction des exercices

XI-A. Exercice 1

  • 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 :
  text   0 1  
id and values
values
id and values
id and values

XI-B. Exercice 2

  • 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 :
  text   0 1  
chien poisson chat
ordinals : 0

XI-C. Exercice 3

  • 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;.

XI-D. Exercice 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.

XI-E. Exercice 5

  • 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émentaire et que je n'exite pas à vous conseiller. Il s'agit de :

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

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

Suivez moi sur twitter

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © . Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.