Latest Updates: héritage RSS

  • Classes abstraites: modificateur abstract class + méthodes

    admin 19 h 02 min on 14 octobre 2009 | 0 Permalink | Reply
    Tags: , , héritage, ,

    Class abstract : classe abstraite + méthode abstraite : modificateur de classe
    Introduction aux modificateurs de class de type abstract
    • Une classe abstraite ne peut instancier un objet. Souvent ce sont les sous classes qui ont la possibilité d’instancier un objet, à partir d’information héritée de la super classe abstraite.
    • Au moins une méthode est abstraite, la classe devient d’office abstraite même si le mot clef « abstract », n’est pas mentionné dans la déclaration de la classe
    • Une classe abstraite doit servir de super classe aux sous-classes qu’elle contient
    • Si une sous classe contient une classe abstraite, elle devient elle-même une classe abstraite (que l’on peut imaginer comme une sous classe abstraite).
    • Une sous classe dérivée d’une classe abstraite ne doit pas forcement définir toute les méthodes héritées de sa classe abstraite parente. Une classe dérivée d’une classe parent abstraite peut elle-même être abstraite.
    • Pour qu’une sous classe héritant d’une classe abstraite puisse être instanciée, cette sous classe doit redéfinir le corps de toute les méthodes abstraites de sa classe parent. Il s’agit d’une implémentation propre à chacune des méthodes.
    • Une classe déclarée static, ou private ne peut être logiquement déclarée abstraite, étant donnée qu’elle ne peuvent être redéfinie par une éventuelle sous classe.

    Les classes abstraite servent en gros à classer les classes et les méthodes contenues dans ces sous classes.
    Exemple classique de classe abstraite qui permet de mieux comprendre le concept java de classe abstraites.
    Imaginons que nous ayons besoin de créer un programme qui effectue des traitements différents selon qu’il reçoit en paramètre des objets soit de type « homme », soit de type « femme ». On pourrait alors créer une superclasse abstraite nommée « humain ». A partir de cette super classe abstraite de type « humain », on va définir deux sous-classes : la première nommé classe « homme », la deuxième sous classe nommée « femme ». A partir de ces sous classes, il devient intéressant de créer des objets de type homme ou femme, afin de donner ces objets instanciés en paramètre du programme. On peut aisément comprendre que l’on peut certes instancier de type « homme », ou de type femme, mais pas un humain. Il manquerait des informations telles que le genre sexuel de l’objet, le prénom (doit-il être un prénom féminin ou masculin ?) et une infinité d’autres informations manquantes qui nous empêche de créer un objet pratique utilisable. Déclarer la classe humain « abstract » est un choix du programmeur java qui le fait dans le but de mieux concevoir son programme, mieux ranger et ordonner les multiples classes qui composent sont programme. Ainsi, il devient évident dans notre exemple, que le programme ne peut pas (car cela ne lui est d’aucune utilité pratique) instancier des objets de type « humain ».

    Autre exemple expliqué de l’utilisation d’une classe abstraite. On peut créer une classe drapeau qui, par default, n’est ni levé ni baissé. Les méthodes introduites dans la classe abstraite pourraient définir les cals dans lesquels le drapeau serait levé ou baissé. Des sous classes utilisant le mot extends (pour hériter des caractéristiques de la super classe) pourrait elle par la suite instancier un objet de type drapeau en définissant les caractéristiques propres à chaque objets instanciés de type drapeau.
    Une classe peut être déclarée abstraite même si elle n’est pas composée par des méthodes abstraites. Son rôle est de servir de super classe et les sous classes qui hériteront de cette classe abstraite se chargeront d’implémenter l’héritage de cette classe.

     

  • Créer un tableau d'objets

    admin 15 h 12 min on 17 septembre 2009 | 1 Permalink | Reply
    Tags: , héritage

    Comment mettre des objets de classe dans un tableau

    On va créer un tableau de qui va stocker des objets de type Chien.  L’utilisateur devra entrer comme argument un nombre de chien à mettre dans le tableau, et ensuite donner un prénom pour chaque chien.

    Ensuite le programme affiche les prénoms des chiens reçus dans le tableau.

    
     import java.util.Scanner;

public class TableauxK {
	public static void main (String[] args) {
		System.out.println("Nombre de chien ?");
		Scanner monScanner = new Scanner(System.in);
		final int NOMBRE_CHIENS = monScanner.nextInt();

		System.out.println("Veuillez entrer "
				+ NOMBRE_CHIENS //ici on se sert de la variable Nombre_Chiens pour scanner ce que l'utilisateur entre comme donner avec son clavier
				+ " prénoms de chien "
				+ "(appuyez sur enter après avoir écrit le nom d'un chien");

		Chien[] tableauDeChiens = new Chien[NOMBRE_CHIENS]; //on créer un tableau de Chien qui prend en argument la variable "Nombre_Chiens"

		for(int i = 0 ; i < tableauDeChiens.length; i++){
			tableauDeChiens[i] = new Chien (monScanner.next()); //A chaque tour de boucle, on place 1nom de chien donnée par l'utilisateur à l'indice (i)dans le tableau
		}

		for(int i = 0 ; i <tableauDeChiens.length; i++){//A chaque tour de boucle, on lit ce qu'il y a dans le tableau à l'indice(i)dans le tableau
			System.out.println(tableauDeChiens[i].nom);
		}
	}
}

    Deuxième exemple de création d’un tableau de chien

    
import java.util.Scanner;

public class Tableaux {
	public static void main (String[] Args) {
		System.out.println("Veuillez entrer 5 prénom de chien, appuyez sur enter après avoir écris le nom d'un chien");
		Scanner monScanner = new Scanner(System.in);
		monScanner.useDelimiter("\n");
		String result1 = monScanner.next(); //On place la première entrée dans le tableau n°1
		String result2 = monScanner.next();
		String result3 = monScanner.next();
		String result4 = monScanner.next();
		String result5 = monScanner.next();
		String[] tableauString = new String [5]; //création d'un tableau de String à 5 indices
		tableauString[0]= result1;
		tableauString[1]= result2;
		tableauString[2]= result3;
		tableauString[3]= result4;
		tableauString[4]= result5;
		Chien[] tableauDeChiens = new Chien[5];//création d'un tableau de type Chien avec 5 indices

		for (int i=0; i<=4; i++){//on utilise une boucle pour lister les élements du tableau
			String tmp = tableauString[i];
			Chien ctmp = new Chien (tmp);// ou : tableauDeChiens[i] = new Chien (tableauString[i]);
			tableauDeChiens[i]= ctmp;

			// ou : tableauDeChiens[i] = new Chien (tableauString[i]);
		}
		for (int i=0; i<=4; i++){
			System.out.println (tableauDeChiens[i].nom);//affiche le noms des objets chiens présent dans le tableau
		}
	}
}
     

  • Héritage classe parents/enfants (4)

    admin 14 h 47 min on 17 septembre 2009 | 0 Permalink | Reply
    Tags: , , héritage

    Création d’une classe Main dans laquelle on va appeler la méthode main. La méthode main est comme la porte d’entrée du programme. Lorsque le code sera exécuté, Java commence par aller voir ce qui se trouve dans la méthode main.

    </code>
public class Main {
public static void main(String[] args) {
Chien chien = new Chien(); // appel du constructeur via le mot-clef "new"
Chien pomme = new Chien("pluto");
Chien poire = new Chien("rex", 5); // poire est une variable de type Chien qui représente un chien appelé rex de 5 ans
Chien medor = new Chien(10);
System.out.println(chien.nom); // affichera "par default"
System.out.println(pomme.nom); // affichera "pluto"
System.out.println(poire.nom); // affichera "rex"
System.out.println(medor.nom); // affichera "par default"
System.out.println(pomme.âge); // affichera O
System.out.println(poire.âge); // affichera 5
System.out.println(medor.âge); // affichera 10
System.out.println(pomme.equals(poire)); // affichera fasle suite au test de la méthode equals
Pinguin p1 = new Pinguin();   // instanciation d'un objet de type Pingouin
Pinguin p2 = new Pinguin();   // instanciation d'un second objet de type Pingouin
System.out.println(p1.equals(p2)); // test si ces deux objets Pinguoin sont les mêmes, affichera "true"
Chat Victor = new Chat(); // instanciation d'un objet de type Chat
Chat Gustave = new Chat("gustave"); // instanciation d'un objet de type Chat, on lui donne le nom Gustave via son         constructeur
System.out.println (Victor.nom); // affichera Victor
System.out.println (Victor.SaitGrimperAuxArbres); //affichera "true"
System.out.println (Gustave.nom + " " +  Gustave.pays); // affichera "Gustave Belgique"
System.out.println ( Gustave.SaitGrimperAuxArbres); //affichera "false"
System.out.println (Victor.pays);//affichera "france"
//nouvelle technique pour constuire un objet, mnt on crée l'objet sans déclarer de variable
System.out.println(new Chien("WOUFFFFFFFFFFFFFFFFF").dire("wouuuufffff"));//affichera "bonne nuit à demain !,    wouf wouf !!, ok!! ok!! wouuufff"
Chien[] tableauDeChiens = new Chien[10];//création d'un tableau contenant 10 objet chiens dans ses cellules  d'indices
tableauDeChiens[0] = pomme; // mnt dans le tableau nommé tableauDeChiens il se trouve un chien représenté par la   variable pomme, à l'indice 0
}
}

<code>

     

  • Héritage classe parents/enfants (3)

    admin 14 h 32 min on 17 septembre 2009 | 2 Permalink | Reply
    Tags: , , héritage 

    public class Chat extends AnimalFamilier {
boolean SaitGrimperAuxArbres;
String pays;
Chat () {
// variables d'initiatilisation
âge = 20;
poids = 7;
SaitGrimperAuxArbres = true;
nom = "Victor"; // on donne un nom au chat via les variables d'initialisation
pays="france";
}

Chat (String Gustave){  // On donne un nom au chat dans le constructeur
SaitGrimperAuxArbres = false;
âge= 10;
pays = belgique;
nom = Gustave;
}
}

    Création de la classe enfant Chat qui hérite des caractéristiques de la classe parente. Pour faire hériter les caractéristiques de la classe parente, on utilise le mot clef extends lors de la déclaration de la classe Chat.

    Et maintenant on va créer une classe enfant nommée Pingouin.

    </code>
public class Pinguin extends AnimalFamilier {
Pinguin() {
type = "pinguin";
}
public static void sauterDansEau() {
System.out.println("plouf plouf !");
}
}
     

  • Héritage classe parents/enfants (2)

    admin 16 h 03 min on 14 septembre 2009 | 0 Permalink | Reply
    Tags: , , héritage 

    </code>
<code> public class Chien extends AnimalFamilier {
public static final String couleur = "noir";
Chien() { // constructeur par défaut de chien
type = "chien";
} // si on ne fait aucune action, il ne sert à rien (il est là automatiquement)
// constructeur personnalisé qui définit le nom du chien à sa création
Chien(String aaa) {
type = "chien";
nom = aaa;
}
Chien(String aaa, float t) {
type = "chien";
nom = aaa;
taille = t;
}
Chien(String nomChoisi, int ageChoisi) {
type = "chien";
nom = nomChoisi;
âge = ageChoisi;
}
Chien(int a) {
//nom = Integer.toString(a);
âge = a;
type = "chien";
}
public void dormir() {
super.dormir();
System.out.println("Wouf wouf !!");
}
public void wouf () {
System.out.println ("wouf");
}
}</code>

    Explication du code

    On créer une classe Chien à partir de la classe parente AnimalFamilier. La classe Chien est donc une classe enfant vis-à-vis de la classe AnimalFamilier. Pour pouvoir reprendre les caractéristiques de la classe AnimalFamilier dans la classe Chien, il faut utiliser le mot clef « extends » dans la déclaration de la classe. Une fois les mots clefs extends déclaré, la classe Chien dispose exactement des mêmes caractéristiques que sa classe parente, c'est-à-dire qu’elle en hérite les variables d’initialisation, et les méthodes.

    On instancie ensuite, un objet de type Chien avec son constructeur vide par défaut.  On déclare la valeur de la variable « type », initialisée dans la classe parente.

    On crée un deuxième objet de type Chien, avec un constructeur qui définit le nom du Chien. Il s’agit d’un constructeur personnalisé.

    Le troisième objet de type Chien possède lui aussi un constructeur personnalisé. Ce constructeur définit un nom pour l’objet Chien, et une taille lors de son instanciation.

    Le constructeur du 4eme objet de type chien définit un âge et un nom lors de la construction de l’objet.

    Le cinquième constructeur effectue une conversion de type de variable. La variable nom qui possède à la base un type String, se converti en type int.

    Une fois les objets de type Chien instancié, on redéfinit la méthode dormir grâce au mot clefs super. Le mot clef « super » permet d’appeler une méthode d’une superclasse (en l’occurrence la super classe ici est AnimalFamilier), et de modifier les propriétés de la méthode. La méthode dormir consistait à appeler la méthode System.out.println et faire afficher la chaine de caractères suivante « bonne nuit à demain ».  Dans la classe Chien, la méthode dormir est modifiée. Le résultat de cette modification est que la méthode dormir affichera dorénavant la chaine de caractère suivante « waouf waouf » lorsqu’elle sera appelée sur l’objet de type Chien.

    On créer ensuite une méthode nommée waouf, qui affiche la chaine de caractère « wouf ».

     

  • Héritage classe parents/enfants (1)

    admin 17 h 30 min on 13 septembre 2009 | 0 Permalink | Reply
    Tags: , héritage

    L’héritage de caractéristiques d’une classe parente partie 1

    </code>

public class AnimalFamilier {
int âge = 0;
float poids;
float taille;
String nom = "par défaut";
String couleur = "par défaut";
String type = "par défaut";
public void dormir() {
System.out.println("Bonne nuit, à demain !");
}
public String manger() {
System.out.println("J’ai si faim… Donne-moi un biscuit !");
return "";
}
public String quelleCouleur() {
return couleur;
}
public void definirCouleur(String s) {
couleur = s;
}
public String dire(String s) {
String réponseAnimal = "OK !! OK !! " + s;
dormir();
return réponseAnimal;
}
public boolean equals(AnimalFamilier af) {
boolean resultat = false; // par défaut, on suppose qu'ils sont différents
if(this.type.equals(af.type) &amp;&amp; this.nom.equals(af.nom)) {
resultat = true;
}
return resultat;
}

}

    Déscription du code

    Création de la classe parente nommée AnimalFamilier caractérisée par son âge, sa taille, son poids, son nom,  sa couleur, son type (type dans le sens race animal). Cette classe parente dispose de plusieurs méthodes :

    Une méthode nommée dormir() qui affiche la chaine de caractère « bonne nuit à demain »

    Une méthode nommée quellecouleur() qui retourne la couleur de l’animal.

    Une méthode nommée définirCouleur qui prend une variable de type String en argument.

    Une méthode nommée dire() qui prend en argument une variable de type String, qui affiche dans une variable la chaine de caractère « ok ok » + le contenu de la variable utilisée comme argument de méthode. La méthode dire() appel la méthode dormir()  qui retourne la valeur d’une variable nommée « reponseAnimal ».

    Une méthode equals qui test si les objets sont du même type que le type AnimalFamilier( le type de AnimalFamilier est « par default »). Ensuite le programme retourne le resultat de ce test de comparaison par la méthode equals.

     

  • Héritage de classes parentes

    admin 22 h 53 min on 26 août 2009 | 0 Permalink | Reply
    Tags: , héritage

    Exercices simple sur l’héritage en Java
    L’héritage en java : définition de la notion d’héritage dans les langages orientés objets. Qu’est ce que l’héritage ?

    En résumé simplifié, l’héritage en Java ce sont les caractéristiques et les méthodes qu’une classe peut hériter d’une classe parente. Par exemple on crée une classe nommée papa, et à partir de cette classe on crée une sous classe qui s’appellerait par exemple « fils ». Par default, la classe fils posséderait donc les caractéristiques de la classe papa.

    Donc si dans la classe parente nommée papa, on dit que papa possède un âge, une taille, un poids, et que l’on décrit les actions que papa peut faire, alors la classe nommée « fils » possédera les mêmes caractéristiques.

    Enoncé de l’exercice :
    Créer une classe Chien qui possède un attribut (son âge) et une méthode abboyer (). A partir de cette classe, créer une classe Enfant nommée chiot qui possède uniquement les attributs et les méthodes de la classe parente Chien. La méthode abboyer() consiste à faire afficher la chaine de caractère « wouf wouf » à l’écran.

    Ps : ne pas oublier de créer une méthode main à partir de laquelle on appelle les méthodes des classes Chiens et Chiots. Placer la méthode main dans une classe Main.

    Solution de l’exercice :

    Code source pour créer la classe parente Chien :

    public class chien {
      int age;
      public static void abboyer (){
      System.out.println ("wouf wouf");
     }
  }

    Code source pour créer la classe Chiot :

    public class chiot extends chien {

}

    Code source pour créer la classe Main :

      public class Main {
       public static void main (String[] Args) {
          chien.abboyer();
          chiot.abboyer();
      }
}

    Si on l’exécute, ce programme affiche « wouf wouf » deux fois (l’un en dessous de l’autre). Ceci étant donné qu’on appel deux fois la méthode abboyer() dans la méthode main: une fois sur la classe chien et une fois sur la classe chiot.

     

c
compose new post
j
next post/next comment
k
previous post/previous comment
r
reply
e
edit
o
show/hide comments
t
go to top
esc
cancel