Développons en Java

13/07/2003

• Le concept de classe : Cette section présente le concept et la syntaxe de la déclaration d'une classe
• Les objets : Cette section présente la création d'un objet, sa durée de vie, le clonage d'objets, les références et la comparaison d'objets, l'objet null, les variables de classes, la variable this et l'opérateur instanceof.
• Les modificateurs d'accès : Cette section présente les modificateurs d'accès des entités classes, méthodes et attributs ainsi que les mots clés qui permettent de qualifier ces entités
• Les propriétés ou attributs : Cette section présente les données d'une classe : les propriétés ou attributs
• Les méthodes : Cette section présente la déclaration d'une méthode, la transmissions de paramètres, l'emmission de messages, la surcharge, la signature d'une méthode et le polymorphisme et des méthodes particulières : les constructeurs, le destructeur et les accesseurs
• L'héritage : Cette section présente l'héritage : son principe, sa mise en oeuvre, ces conséquences. Il présente aussi la redéfinition d'une méthode héritée et les interfaces
• Les packages : Cette section présente la définition et l'utilisation des packages
• Les classes internes : Cette section présente une extension du langage java qui permet de definir une classe dans une autre.
• La gestion dynamique des objets : Cette section présente rapidement la gestion dynamique des objets grace à l'introspection

exemple
ClassModifiers class ClassName [extends SuperClass] [implemenents Interfaces]
{
   // insérer ici les champs et les méthodes
}

exemple
MaClasse m;

exemple
m = new MaClasse();

exemple
MaClasse m = new MaClasse();

exemple
String chaine = « bonjour » 
et String chaine = new String(« bonjour »)

• la déclaration de l'objet et l'instanciation grace à l'opérateur new

exemple
nom_de_classe nom_d_objet = new nom_de_classe( ... );

• l'utilisation de l'objet en appelant ces méthodes
• la suppression de l'objet : elle est automatique en java grace à la machine virtuelle. La restitution de la mémoire inutilisée est prise en charge par le récupérateur de mémoire (garbage collector). Il n'existe pas d'instruction delete comme en C++.

exemple
MaClasse m1 = new MaClasse();
MaClasse m2 = m1;

exemple
MaClasse m1 = new MaClasse();
MaClasse m2 = m1.clone();

exemple
Rectangle r1 = new Rectangle(100,50);
Rectangle r2 = new Rectangle(100,50);
if (r1 == r1) { ... } // vrai
if (r1 == r2) { ... } // faux

exemple
(obj1.getClass().equals(obj2.getClass())

exemple
public class MaClasse() { 
    static int compteur = 0;
}

exemple
MaClasse m = new MaClasse();
int c1 = m.compteur;
int c2 = MaClasse.compteur;
            c1 et c2 possèdent la même valeur.

exemple
private int nombre;
public maclasse(int nombre) {
   nombre = nombre; // variable de classe = variable en paramètre du constructeur
}

exemple
this.nombre = nombre;

exemple
class MaClasse() {
  String chaine = « test » ;
  Public String getChaine() { return chaine) ; 
  // est équivalent à public String getChaine (this.chaine);
}

exemple
void testClasse(Object o) {
   if (o instanceof MaClasse )
      System.out.println(« o est une instance de la classe MaClasse »);
   else System.out.println(« o n'est pas un objet de la classe MaClasse »);
}

exemple
void afficheChaine(Object o) {
    if (o instanceof MaClasse)
        System.out.println(o.getChaine());
        // erreur à la compil car la méthode getChaine()
        //n'est pas définie dans la classe Object
}

exemple
void afficheChaine(Object o) {
   if (o instanceof MaClasse)
   {
      MaClasse m = (MaClasse) o;
      System.out.println(m.getChaine());
      // OU System.out.println( ((MaClasse) o).getChaine() );
   }
}

exemple
public class Cercle {
    static float pi = 3.1416f; 
    float rayon;
    public Cercle(float rayon) { this.rayon = rayon; }
    public float surface() { return rayon * rayon * pi;}
}

exemple
public static final float PI = 3.141f;

exemple
abstract class ClasseAbstraite {
    ClasseBastraite() { ... //code du constructeur }
    void méthode() { ... // code partagé par tous les descendants}
    abstract void méthodeAbstraite();
}

class ClasseComplete extends ClasseAbstraite {
    ClasseComplete() { super(); ... }
    void méthodeAbstraite() { ... // code de la méthode }
    // void méthode est héritée
}

exemple
public class MaClasse {
   public int valeur1 ;
   int valeur2 ;
   protected int valeur3 ;
   private int valeur4 ;
}

code java 1.1
public class MaClasse {
   static int compteur ;
}

code java 1.1
public class MaClasse {
   final double pi=3.14 ;
}

exemple
modificateurs type_retourné nom_méthode ( arg1, ... ) {... }
    // définition des variables locales et du bloc d'instructions
}

exemple
int add(int a, int b) {
   return a + b; 
}

exemple
public static void main (String args[]) { ... }

exemple
int[] valeurs() { ... }
int valeurs()[] { ... }

• si v est une variable primitive alors elle est passée par valeur : il est impossible de la modifier dans m pour que v en retour contiennent cette nouvelle valeur.
• si v est un objet alors m pourra modifier l'objet en utilisant une méthode de l'objet passé en paramètre.

exemple
System.out.Println("bonjour");

exemple
class affiche{
    public void afficheValeur(int i) {
        System.out.pintln(« nombre entier = » + i);
    }
    
    public void afficheValeur(float f) {
        System.out.println(« nombre flottant = » + f);
    }
}

exemple
class Affiche{

    public float convert(int i){
         return((float) i);
    }
    
    public double convert(int i){
        return((double) i);
    }
}

resultat à la compilation
C:\>javac Affiche.java
Affiche.java:5: Methods can't be redefined with a different return type: double
convert(int) was float convert(int)
public double convert(int i){
       ^
1 error

• le constructeur simple : ce type de constructeur ne nécessite pas de définition explicite : son existence découle automatiquement de la définition de la classe.

exemple
public MaClasse() {}

• le constructeur avec initialisation fixe : il permet de créer un constructeur par défaut

exemple
public MaClasse() {
    nombre = 5;
}

• le constructeur avec initialisation des variables : pour spécifier les valeurs de données à initialiser on peut les passer en paramètres au constructeur

exemple
public MaClasse(int valeur) {
     nombre = valeur;
}

private int valeur = 13;
public int getValeur(){
    return(valeur);
}
public void setValeur(int val) {    
    valeur = val;
}

class Fille extends Mere { ... }

la classe Employe hérite de la classe
Personne p = new Personne («Dupond», «Jean»);
    Employe e = new Employe(«Durand», «Julink», 10000);
    p = e ; // ok : Employe est une sous classe de Personne
    Objet obj;
    obj = e ; // ok : Employe herite de Personne qui elle même hérite de Object

Personne[] tab = new Personne[10];
    tab[0]:= new Personne( «Dupond»,«Jean»);
    tab[1]:= new Employe(«Durand», «Julink», 10000);

Déclaration d'une interface
[public] interface nomInterface [extends nomInterface1, nomInterface2 ... ] {
    // insérer ici des méthodes ou des champs static
}

Implémentation d'une interface
Modificateurs class nomClasse [extends superClasse] 
   [implements nomInterface1, nomInterface 2, ...] {
    //insérer ici des méthodes et des champs
}

interface AfficheType {
    void AfficheType();
}
class Personne implements AfficheType {
    public void afficheType() {
        System.out.println(« Je suis une personne »);
    }
}
class Voiture implements AfficheType {
    public void afficheType() {
        System.out.println(« Je suis une voiture »);
    }
}

déclaration d'un interface à laquelle doit se conformer tout individu
interface Individu {
    String getNom();
    String getPrenom();
    Date getDateNaiss();
}

• la définition des accès aux variables d'instances, très souvent privées, doit être réfléchie entre protected et private
• pour empecher la redéfinition d'une méthode (surcharge) il faut la déclarer avec le modificateur final

• la méthode héritée convient à la classe fille : on ne doit pas la redéfinir
• la méthode héritée convient mais partiellement du fait de la spécialisation apportée par la classe fille : il faut la redéfinir voir la surcharger. La plupart du temps une redéfinition commencera par appeler la méthode héritée (via super) pour garantir l 'évolution du code
• la méthode héritée ne convient pas : il faut redéfinir ou surcharger la méthode sans appeler la méthode héritée lors de la redéfinition.

package nomPackage;

import nomPackage.*;

Exemple sous Windows
CLASSPATH = .;C:\Java\JDK\Lib\classes.zip;
C:\rea_java\package

public class ClassePrincipale1 {
  class ClasseInterne {
  }
}

• permettre de définir une classe à l'endroit ou une seule autre en a besoin
• définir des classes de type adapter (essentiellement à partir du JDK 1.1 pour traiter des évenements émis par les interfaces graphiques)
• définir des méthodes de type callback d'une façon générale

public class ClassePrincipale6 {
  class ClasseInterne1 {
    class ClasseInterne2 {
      class ClasseInterne3 {
      }
    }
  }
}

public class ClassePrincipale8 {
  public class ClasseInterne {
  }
  public static void main(String[] args) {
    ClassePrincipale8 cp = new ClassePrincipale8();
    ClassePrincipale8.ClasseInterne ci = cp. new ClasseInterne() ;
    System.out.println(ci.getClass().getName());        
  }
}

java ClassePrincipale8
ClassePrincipale8$ClasseInterne

public class ClassePrincipale7 {
    private class ClasseInterne {
    }
}

public class ClassePrincipale10 {
    public class ClasseInterne {
        static int var = 3;
    }
}

javac ClassePrincipale10.java
ClassePrincipale10.java:3: Variable var can't be static in inner class ClassePri
ncipale10. ClasseInterne.  Only members of interfaces and top-level classes can
be static.
                static int var = 3;
                               ^
1 error

• les classes internes non statiques : elles sont membres à part entière de la classe qui les englogent et peuvent accéder à tous les membres de cette dernière
• les classes internes locales : elles sont définies dans un block de code. Elles peuvent être static ou non.
• les classes internes anonymes : elles sont définies et instanciées à la volée sans posséder de nom
• les classe internes statiques : elles sont membres à part entière de la classe qui les englogent et peuvent accéder uniquement aux membres statiques de cette dernière

public class ClassePrincipale20 {
    private int valeur = 1;
    class ClasseInterne {
        public void afficherValeur() {
            System.out.println("valeur = "+valeur); 
        }
    }
    public static void main(String[] args) {
        ClassePrincipale20 cp = new ClassePrincipale20();
        ClasseInterne ci = cp. new ClasseInterne();
        ci.afficherValeur();
        }   
}

C:\testinterne>javac ClassePrincipale20.java
C:\testinterne>java ClassePrincipale20
valeur = 1

public class ClassePrincipale16 {
    class ClasseInterne {
        int var = 3;
        public void affiche() {
            System.out.println("var      = "+var);  
            System.out.println("+this.var); 
        }
    }
    ClasseInterne ci = this. new ClasseInterne();
    public static void main(String[] args) {
        ClassePrincipale16 cp = new ClassePrincipale16();
        ClasseInterne ci = cp. new ClasseInterne();     
        ci.affiche();
        }
}

C:\>java ClassePrincipale16
var      = 3
this.var = 3

public class ClassePrincipale17 {
    int valeur = 5;
    class ClasseInterne {
        int var = 3;
        public void affiche() {
            System.out.println("var      = "+var);  
            System.out.println("+this.var); 
            System.out.println("valeur   = "+valeur);   
        }
    }
    ClasseInterne ci = this. new ClasseInterne();
    public static void main(String[] args) {
        ClassePrincipale17 cp = new ClassePrincipale17();
        ClasseInterne ci = cp. new ClasseInterne(); 
        ci.affiche();
        }
}

C:\testinterne>java ClassePrincipale17
var      = 3
this.var = 3
valeur   = 5

public class ClassePrincipale18 {
    int var = 5;
    class ClasseInterne {
        int var = 3;
        public void affiche() {
            System.out.println("var                          = "+var);  
            System.out.println("+this.var); 
            System.out.println("ClassePrincipale18.
              +ClassePrincipale18.this.var);    
        }
    }
    ClasseInterne ci = this. new ClasseInterne();
    public static void main(String[] args) {
        ClassePrincipale18 cp = new ClassePrincipale18();
        ClasseInterne ci = cp. new ClasseInterne(); 
        ci.affiche();
        }
}

C:\>java ClassePrincipale18
var                          = 3
this.var                     = 3
ClassePrincipale18.this.var  = 5

• ajouter une variable privée finale du type de la classe principale nommée this$0
• ajouter un paramètre supplémentaire dans le constructeur qui sera la classe principale et qui va initialiser la variable this$0
• utiliser cette variable pour préfixer les attributs de la classe principale utilisés dans la classe interne.

• ajouter une méthode static pour chaque champ de la classe principale qui attend en paramètre un objet de la classe principale. Cette méthode renvoie simplement la valeur du champ. Le nom de cette méthode est de la forme access$0
• modifier le code d'instanciation de la classe interne pour appeler le constructeur modifié

• l'instance de la classe interne elle même
• éventuellement les instances des classes internes dans laquelle la classe interne est imbriquée
• l'instance de sa classe principale

public class ClassePrincipale14 {
    class ClasseInterne {
    }
    ClasseInterne ci = this. new ClasseInterne();
}

public class ClassePrincipale15 {
    class ClasseInterne {
    }
    ClasseInterne ci = this. new ClasseInterne();
    static void maMethode() {
        ClassePrincipale15 cp = new ClassePrincipale15();
        ClasseInterne ci = cp. new ClasseInterne();
        }
}

public class ClassePrincipale19 {
    class ClasseInterne {
    }
    static void maMethode() {   
        ClasseInterne ci = new ClassePrincipale19(). new ClasseInterne();
        }
}

public class ClassePrincipale9 {
    public class ClasseInterne {
    }
    class ClasseFille extends ClassePrincipale9.ClasseInterne {
        ClasseFille(ClassePrincipale9 cp) {
            cp. super();
        }
    }
}

public class ClassePrincipale21 {
   int varInstance = 1;
   public static void main(String args[]) {
     ClassePrincipale21 cp = new ClassePrincipale21();
     cp.maMethode();
   }
   public void maMethode() {
     class ClasseInterne {
       public void affiche() {
         System.out.println("varInstance = " + varInstance);
       }
     }
     ClasseInterne ci = new ClasseInterne();
     ci.affiche();
   }
 }

C:\testinterne>javac ClassePrincipale21.java
C:\testinterne>java ClassePrincipale21
varInstance = 1

public class ClassePrincipale12 {
   public static void main(String args[]) {
     ClassePrincipale12 cp = new ClassePrincipale12();
     cp.maMethode();
   }
   public void maMethode() {
    int varLocale = 3;
     class ClasseInterne {
       public void affiche() {
         System.out.println("varLocale = " + varLocale);
       }
     }
     ClasseInterne ci = new ClasseInterne();
     ci.affiche();
   }
 }

javac ClassePrincipale12.java
ClassePrincipale12.java:14: Attempt to use a non-final variable varLocale from a
 different method. From enclosing blocks, only final local variables are availab
le.
         System.out.println("varLocale = " + varLocale);
                                             ^
1 error

public class ClassePrincipale13 {
   public static void main(String args[]) {
     ClassePrincipale13 cp = new ClassePrincipale13();
     cp.maMethode();
   }
   public void maMethode() {
    final int varLocale = 3;
     class ClasseInterne {
       public void affiche(final int varParam) {
         System.out.println("varLocale = " + varLocale);
         System.out.println("varParam  = " + varParam);
       }
     }
     ClasseInterne ci = new ClasseInterne();
     ci.affiche(5);
   }
 }

C:\>javac ClassePrincipale13.java
C:\>java ClassePrincipale13
varLocale = 3
varParam  = 5

public class ClassePrincipale11 {
    public void maMethode() {
        public class ClasseInterne {
        }
    }
}

javac ClassePrincipale11.java
ClassePrincipale11.java:2: '}' expected.
        public void maMethode() {
                                 ^
ClassePrincipale11.java:3: Statement expected.
                public class ClasseInterne {
                ^
ClassePrincipale11.java:7: Class or interface declaration expected.
}
^
3 errors

public void init() {
   boutonQuitter.addActionListener(
     new ActionListener() {
       public void actionPerformed(ActionEvent e) {
         System.exit(0);
       }
     }
   );
 }

public class ClassePrincipale4 {
    class ClasseInterne {
        public void afficher() {
            System.out.println("bonjour");  
        }
    }
    public static void main(String[] args) {    
        new ClasseInterne().afficher();
    }
}

javac ClassePrincipale4.java
ClassePrincipale4.java:10: No enclosing instance of class ClassePrincipale4 is i
n scope; an explicit one must be provided when creating inner class ClassePrinci
pale4. ClasseInterne, as in "outer. new Inner()" or "outer. super()".
                new ClasseInterne().afficher();
                ^
1 error

public class ClassePrincipale4 {
    static class ClasseInterne {
        public void afficher() {
            System.out.println("bonjour");  
        }
    }
    public static void main(String[] args) {    
        new ClasseInterne().afficher();
    }
}

javac ClassePrincipale4.java
java ClassePrincipale4
bonjour

• de décrire une classe ou une interface : obtenir son nom, sa classe mère, la liste de ces méthodes, de ses variables de classe, de ses constructeurs et de ses variables d'instances
• d'agir sur une classe en envoyant, à un objet Class des message comme à tout autre objet. Par exemple, créer dynamiquement à partir d'un objet Class une nouvelle instance de la classe représentée