Latest Updates: Mots cles RSS

  • Classes abstraites: modificateur abstract class + méthodes

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

    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.

     

  • This: Le mot clef "this" pour déclarer des variables dans un constructeur

    admin 19 h 18 min on 29 septembre 2009 | 0 Permalink | Reply
    Tags: , , Mots cles

    A quoi sert le mot clef « this » en Java ?
    Le mot clef this permet de faire référence à une variable de classe. Souvent, lorsque l’on utilise un constructeur personnalisé pour instancié un objet, il est pratique de reprendre comme nom de variable dans le constructeur, le même nom qu’une variable de classe. Or étant donnée que la variable de classe et la variable déclarée dans le constructeur sont deux variables différente en mémoire, il faut préciser à Java de à quelle variable est ce qu’on l’on fait référence lorsque l’on déclare des variables dans un constructeur.

    Exemple par le code :

    
public class MaTortue {
String couleur="vert";
String type="tortue";
int age = 2;

public MaTortue (String couleur, int age){
	this.couleur = couleur; //on récupére la variable couleur de la classe MaTortue et on l'assigne au constructeur que l'on est en train de créer
	this.age= age; // idem pour la variable age

}

	public static void main (String[] args){
		MaTortue turtle = new MaTortue("brune",3);
		System.out.println("cette nouvelle tortue est de couleur " + turtle.couleur + " et est âgée de " + turtle.age + " ans"); // l'objet de type "MaTortue" contenu dans la variable "turtle" possède maintenant une couleur brune et est agée de 2ans
	} 

}



    Explication du code :
    On commence par créer la classe MaTortue et on lui assigne des variables par défaut (notamment une couleur verte, et un âge de 2ans). Ensuite on va déclarer un constructeur personnalisé à partir de la classe MaTortue. Ce constructeur personnalisé va réassigner des valeurs aux variables issues de la classe MaTortue à l’aide du mot clef « this ». Le mot clef « this » permet de distinguer les variables « couleur» et « âge », présente dans la déclaration du constructeur, vis-à-vis des variables initialisées dans la déclaration de la classe MaTortue.
    Ainsi, les objets de type MaTortue qui seront crées dans la méthode main, pourront utiliser ce nouveau constructeur pour « construire » (instancier) des nouveaux objets de types MaTortue possédant des autres couleurs, des autres âges.

     

  • Différence entre mot clef void et return dans une signature de méthode

    admin 16 h 58 min on 29 septembre 2009 | 0 Permalink | Reply
    Tags: , , Mots cles

    Quelle est la différence entre une méthode possédant le mot clef « void » dans sa signature, et une méthode qui retourne un type de donnée ?

    Une méthode avec le mot clef void ne retourne rien. Le traitement de l’instruction effectué par la méthode ne nécessite pas que l’on place le résultat de cette méthode dans une variable typée.

    Le mot clef return dans la signature d’une méthode annonce que le traitement effectué par la méthode retournera une donnée.

    Exemple avec un code concret :

    Dans l’exemple ci-dessous on imagine 2 méthodes : une méthode void et une méthode qui renvoie un type de donnée booléenne en retour.

    La méthode statique main appel les deux méthodes, et que constate t’on ?

    1. La première méthode nommé « meth1 ()» peut être appelé tel quel, sans être appelé sur une instance d’objet. La méthode est appelée et elle ne renvoie rien, elle effectue son traitement comme elle le doit (pour l’exemple, cette méthode servirait à vérifier si de nouveaux e-mails sont arrivés dans une boite mail).
    2. La deuxième méthode nommée « meth2 » (qui dans notre exemple servirait à contrôler si le lancement d’une fusée s’est bien déroulé)  renvoie un donnée booléenne en retour (true si le lancement c’est bien passé, false dans le cas contraire). Notons la présence d’une classe Exception utilisée qui affichera un message d’erreur si la méthode booléenne pris comme exemple ici, renvoi « false ».

    Note : Selon le besoin du programme, on utilise tantôt des méthodes void, tantôt des méthodes avec retour. Certaine méthode renvoie forcement une donnée en retour, c’est le cas notamment d’une méthode qui utilise en argument une donnée de type booléenne. La méthode renverra forcement, après traitement, true ou false.

    
public class P2 {

	public static void meth1() {
		// VERIFIER SI NOUVEAU MAIL ARRIVE
		//...
		//...
	}

	public static boolean meth2() {
		// LANCER UNE FUSEE
		//...
		//...
		//...

		return true;
	}

	public static void main(String[] args) throws Exception {
		meth1();
		boolean b = meth2();
		if(!b) {
			throw new Exception("Fusée non lancée !!");
		}
	}
}


     

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