Chapitre 4 : La programmation orientée objet

13/10/2002

Par Jean-Michel Doudoux (autres articles)
 

• 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

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 »); 

sont équivalents.

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

}

Exemple (code java 1.1):
public class MaClasse {

   static int compteur ;

}

Exemple (code java 1.1):
public class MaClasse {

   final double pi=3.14 ;

}

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; 

}

Déclaration d'une méthode main() : 
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);

    }

}

Résultat à 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

1. 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() {}

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

Exemple : 
public MaClasse() {

    nombre = 5;

}

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

}

Exemple : 
private int valeur = 13;



public int getValeur(){

    return(valeur);

}



public void setValeur(int val) {    

    valeur = val;

}

Exemple : 
class Fille extends Mere { ... }

Exemple : la classe Employe hérite de la classe Personne
Personne p = new Personne («Dupond», «Jean»);

    Employe e = new Employe(«Durand», «Julien», 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

Exemple : la classe Employe hérite de la classe Personne
Personne[] tab = new Personne[10];

    tab[0]:= new Personne( «Dupond»,«Jean»);

    tab[1]:= new Employe(«Durand», «Julien», 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

}

Implémentation d'une interface : 
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 »);

    }

}

Exemple : déclaration d'un interface à laquelle doit se conformer tout individus
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.

Exemple très simple :
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

Exemple :
public class ClassePrincipale6 {

  class ClasseInterne1 {

    class ClasseInterne2 {

      class ClasseInterne3 {

      }

    }

  }

}

Exemple :
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());		

  }

}

Resultat :
java ClassePrincipale8

ClassePrincipale8$ClasseInterne

Exemple :
public class ClassePrincipale7 {

	private class ClasseInterne {

	}

}

Exemple :
public class ClassePrincipale10 {

	public class ClasseInterne {

		static int var = 3;

	}

}

Resultat :
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

Exemple :
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();

        }	

}

Resultat :
C:\testinterne>javac ClassePrincipale20.java



C:\testinterne>java ClassePrincipale20

valeur = 1

Exemple :
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();

        }

}

Resultat :
C:\>java ClassePrincipale16

var      = 3

this.var = 3

Exemple :
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();

        }

}

Resultat :
C:\testinterne>java ClassePrincipale17

var      = 3

this.var = 3

valeur   = 5

Exemple :
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();

        }

}

Resultat :
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

Exemple :
public class ClassePrincipale14 {

	class ClasseInterne {

	}



	ClasseInterne ci = this. new ClasseInterne();

}

Exemple :
public class ClassePrincipale15 {

	class ClasseInterne {

	}



	ClasseInterne ci = this. new ClasseInterne();

	

	static void maMethode() {

		ClassePrincipale15 cp = new ClassePrincipale15();

		ClasseInterne ci = cp. new ClasseInterne();

        }

}

Exemple :
public class ClassePrincipale19 {

	class ClasseInterne {

	}



	static void maMethode() {	

		ClasseInterne ci = new ClassePrincipale19(). new ClasseInterne();

        }

}

Exemple :
public class ClassePrincipale9 {

	public class ClasseInterne {

	}



	class ClasseFille extends ClassePrincipale9.ClasseInterne {

		ClasseFille(ClassePrincipale9 cp) {

			cp. super();

		}

	}

}

Exemple :
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();

   }

 }

Resultat :
C:\testinterne>javac ClassePrincipale21.java



C:\testinterne>java ClassePrincipale21

varInstance = 1

Exemple :
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();

   }

 }

Resultat :
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

Exemple :
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);

   }

 }

Resultat :
C:\>javac ClassePrincipale13.java



C:\>java ClassePrincipale13

varLocale = 3

varParam  = 5

Exemple :
public class ClassePrincipale11 {

	public void maMethode() {

		public class ClasseInterne {

		}

	}

}

Resultat :
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

new classe_ou_interface () {

// définition des attributs et des méthodes de la classe interne 

}

Exemple :
public void init() {

   boutonQuitter.addActionListener(

     new ActionListener() {

       public void actionPerformed(ActionEvent e) {

         System.exit(0);

       }

     }

   );

 }

Exemple :
public class ClassePrincipale4 {



	class ClasseInterne {

		public void afficher() {

			System.out.println("bonjour");	

		}

	}



	public static void main(String[] args) { 	

		new ClasseInterne().afficher();

	}

}

Resultat :
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.  or "outer. .

                new ClasseInterne().afficher();

                ^

1 error

Exemple :
public class ClassePrincipale4 {



	static class ClasseInterne {

		public void afficher() {

			System.out.println("bonjour");	

		}

	}



	public static void main(String[] args) { 	

		new ClasseInterne().afficher();

	}

}

Resultat :
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