Quelques notions sur les objets

Dériver une classe pour créer une nouvelle classe

Une possibilité intéressante pour créer un nouveau modèle d'objet est d'enrichir une classe existante. Nous pouvons par exemple imaginer une nouvelle classe Boiteplacee telle que chaque instance serait localisée dans un espace à trois dimensions. En plus des champs profondeur, largeur, hauteur, une telle classe aurait besoin de trois nouveaux champs pour indiquer les coordonnées d'un des coins, par exemple le coin inférieur gauche arrière.

Au lieu de réécrire complètement la classe, la créer comme une sous-classe de la classe Boite, dont elle pourra reprendre un certain nombre de champs et de méthodes.

La définition de la classe Boiteplacee commence alors ainsi

class Boiteplacee extends Boite{
private int x,y,z;
...
}

les champs x,y et z désignant les coordonnées du coin qui permet de localiser la Boiteplacee

Une Boiteplacee étant aussi une Boite, elle hérite des champs et méthodes de Boite. On n'a donc pas besoin de redéfinir largeur, hauteur...

Les méthodes getLargeur(), setLargeur(), volume(), surface()... vont faire exactement la même chose pour une Boiteplacee et pour une Boite. On n'a donc pas besoin d'y toucher. ( D'ailleurs ces méthodes n'ont aucune raison de devoir être redéfinie par une sous-classe quelconque de Boite : on pourrait interdire cette redéfinition en les déclarant final dans le fichier Boite.java )

En revanche les constructeurs ont besoin d'être redéfinis pour intégrer l'initialisation des nouveaux champs. Mais il n'est pas nécessaire de réécrire le code complet car on peut appeler un constructeur de la classe Boite (la superclasse de Boiteplacee) pour qu'il effectue une partie du travail.
Exemples

class Boiteplacee extends Boite{
private int x,y,z;
// Ce constructeur construit une Boiteplacee dont le coin inférieur gauche arrière est en (0,0,0), de dimensions 10 x 10  x10 et pleine
 Boiteplacee(){
    super(); // appelle le constructeur sans parametres de la superclasse Boite qui construit une boite de dimensions 10 x 10 x 10 pleine
    x=0;
	y=0;
	z=0;	//initialise les champs spécifiques à Boiteplacee
   }
   
 // Ce constructeur construit une Boiteplacee dont le coin inférieur gauche arrière est en (a,o,ov), de dimensions p x l  x h et d'état de remplissage etat. 
 Boiteplacee(int a,int o, int ov, int p,int l,int h,boolean etat){
   super(p,l,h,etat); // appelle le constructeur de la superclasse Boite de dimensions p x l x h d'état etat.
   x=a;
   y=o;
   z=ov;   //initialise les champs spécifiques à Boiteplacee
   } 

 // Ce constructeur construit une Boiteplacee par copie d'une autre Boiteplacee.    
 Boiteplacee(Boiteplacee modele){
   super(modele); // appelle le constructeur de la superclasse Boite qui recopie la Boite modele (le paramètre modele étant une Boiteplacee, c'est aussi une Boite, il est donc accepté en paramètre de ce constructeur)
   x=modele.x;
   y=modele.y;
   z=modele.z; //initialise les champs spécifiques à Boiteplacee en copiant ceux de modele.
   } 
}

On peut également redéfinir la méthode proprietes() créée en exercice

String proprietes(){
   return ("origine:("+x+","+y+","+z+"); "+super.proprietes()); 
    }

Cette redéfinition appelle la méthode proprietes() de la superclasse Boite

Remarque : il est tout à fait possible de redéfinir une méthode ou un constructeur sans faire appel à son homologue de la superclasse