Classe Abstraite & Interface
Résolu
stela86
Messages postés
16
Date d'inscription
samedi 5 mars 2005
Statut
Membre
Dernière intervention
21 avril 2006
-
20 nov. 2005 à 10:19
jcodeunpeu Messages postés 365 Date d'inscription mercredi 9 novembre 2005 Statut Membre Dernière intervention 2 décembre 2006 - 20 nov. 2005 à 15:29
jcodeunpeu Messages postés 365 Date d'inscription mercredi 9 novembre 2005 Statut Membre Dernière intervention 2 décembre 2006 - 20 nov. 2005 à 15:29
2 réponses
cs_neodante
Messages postés
2835
Date d'inscription
lundi 11 août 2003
Statut
Modérateur
Dernière intervention
16 décembre 2006
11
20 nov. 2005 à 15:10
20 nov. 2005 à 15:10
Arf très dur à explqiuer en quelques lignes ..
Une classe abstraite est une classe qui ne peut pas être instensier
mais qui définit le comportement (méthode) et l'état (propriétés ou
données membre) d'une classe. Tu peux y implémenter des méthodes
également et donc assurer la mécanique de ta classe dérivée.
Une interface est quelque chose de beaucoup plus abtrait puisque tu ne
peux que définir les signatures de méthodes que devront implémenter les
classes dérivant (implémentant est plus juste) cette interface.
Une interface est en gros un contrat de la part de la classe qui assure
au développeur que toutes les méthodes de l'interface seront présentes
dans la classe l'implémentant ...
Par exemple pour créer des programmes avec des plugin ecla est très intéressant ...
Le concept d'interface n'est pas toujours évident à comprendre du premier coup mais c'est vraiment très utile par la suite ...
;-)
++
Une classe abstraite est une classe qui ne peut pas être instensier
mais qui définit le comportement (méthode) et l'état (propriétés ou
données membre) d'une classe. Tu peux y implémenter des méthodes
également et donc assurer la mécanique de ta classe dérivée.
Une interface est quelque chose de beaucoup plus abtrait puisque tu ne
peux que définir les signatures de méthodes que devront implémenter les
classes dérivant (implémentant est plus juste) cette interface.
Une interface est en gros un contrat de la part de la classe qui assure
au développeur que toutes les méthodes de l'interface seront présentes
dans la classe l'implémentant ...
Par exemple pour créer des programmes avec des plugin ecla est très intéressant ...
Le concept d'interface n'est pas toujours évident à comprendre du premier coup mais c'est vraiment très utile par la suite ...
;-)
++
jcodeunpeu
Messages postés
365
Date d'inscription
mercredi 9 novembre 2005
Statut
Membre
Dernière intervention
2 décembre 2006
2
20 nov. 2005 à 15:29
20 nov. 2005 à 15:29
Bonjour stela86,
vaste sujet !! si tu débute c'est peut-être pas par le bon bout.
enfin que serait un développeur sans la Curiosité, je tente donc une réponse sommaire sous forme d'exemple :
//********** une classe abstraite des personnes ********
public abstract class desPersonnes{
private String nom;
public desPersonnes(String nom){
this.nom= nom;
}
// une méthode abstract, pas de corps ***
public abstract String getPersonne();
// une méthode concrète est possible aussi ***
public String toString(){
return this.nom;
}
}
// partons du principe qu'une personne ne devient une personne qu'à partir du moment où on connait son numéro de tel :
public class testPersonnes extends desPersonnes{// *************
// Cette classse étend desPersonnes, elle possède donc le champ nom, mais ajoute un champ tel.
private String tel;
public testPersonnes(String nom, String num){
super(nom);
this.tel = num;
}
// la classe concrète qui étend la classe abstraite doit implémenter les méthodes de cette classe.
public String getPersonne(){
return this.nom + " : " + this.tel
}
public String toString(){
return "je me nomme " + this.getPersonne();
/* ou tu pourrai trés bien faire :
return "je suis " + this.super.toString() + " : " + this.tel;*/
}
}// fin de classe testPersonnes ***************************
// comme un ami est aussi une personne mais avec un prénom et sans tel parce qu'on le connait par coeur :
public class testAmis extends desPersonnes{
private String prenom;
public testAmis(String nom, String prenom,){
super(nom);
this.prenom = prenom;
public String getPersonne(){
return this.nom + " " + this.prenom;
}
public String toString(){
return "je suis " + this.getPersonne();
}
}
}
public class Test {
public static void main(String [] args){
testAmis gege= new testAmis("tonPote","gege");
// va donner :
// "je suis tonPote gege";
System.out.println(gege); // appelera getPersonne de testAmis au travers de sa méthode toString();
testPersonnes untel= new testPersonnes("quiquecé", " 0000000000);
// va donner :
// "je me nomme quiquecé : 0000000000";
System.out.println(untel); // appelera getPersonne de testPersonnes au travers de sa méthode toString();
// tout dépend de ce que tu mets dans le corps de la fonction abstract que tu implémente dans la classe concrète.
}
}
Ainsi la méthode abstract getPersonne() est dupliquée dans les classes concrètes en renvoyant chaque fois une spécificité de la classe concrète.
testAmis toto = new testAmis("tartempion", "toto"); // est une instance de test Amis et de dePersonnes; mais tu ne pourra pas construire d'instance dePersonnes comme ceci:
dePersonnes x = new dePersonnes("tartempion"); même si le constructeur est défini, on dit que c'est une classe abstraite;
Observe bien ces exemples déjà, les interfaces c'est un peu plus chaud.
A+
vaste sujet !! si tu débute c'est peut-être pas par le bon bout.
enfin que serait un développeur sans la Curiosité, je tente donc une réponse sommaire sous forme d'exemple :
//********** une classe abstraite des personnes ********
public abstract class desPersonnes{
private String nom;
public desPersonnes(String nom){
this.nom= nom;
}
// une méthode abstract, pas de corps ***
public abstract String getPersonne();
// une méthode concrète est possible aussi ***
public String toString(){
return this.nom;
}
}
// partons du principe qu'une personne ne devient une personne qu'à partir du moment où on connait son numéro de tel :
public class testPersonnes extends desPersonnes{// *************
// Cette classse étend desPersonnes, elle possède donc le champ nom, mais ajoute un champ tel.
private String tel;
public testPersonnes(String nom, String num){
super(nom);
this.tel = num;
}
// la classe concrète qui étend la classe abstraite doit implémenter les méthodes de cette classe.
public String getPersonne(){
return this.nom + " : " + this.tel
}
public String toString(){
return "je me nomme " + this.getPersonne();
/* ou tu pourrai trés bien faire :
return "je suis " + this.super.toString() + " : " + this.tel;*/
}
}// fin de classe testPersonnes ***************************
// comme un ami est aussi une personne mais avec un prénom et sans tel parce qu'on le connait par coeur :
public class testAmis extends desPersonnes{
private String prenom;
public testAmis(String nom, String prenom,){
super(nom);
this.prenom = prenom;
public String getPersonne(){
return this.nom + " " + this.prenom;
}
public String toString(){
return "je suis " + this.getPersonne();
}
}
}
public class Test {
public static void main(String [] args){
testAmis gege= new testAmis("tonPote","gege");
// va donner :
// "je suis tonPote gege";
System.out.println(gege); // appelera getPersonne de testAmis au travers de sa méthode toString();
testPersonnes untel= new testPersonnes("quiquecé", " 0000000000);
// va donner :
// "je me nomme quiquecé : 0000000000";
System.out.println(untel); // appelera getPersonne de testPersonnes au travers de sa méthode toString();
// tout dépend de ce que tu mets dans le corps de la fonction abstract que tu implémente dans la classe concrète.
}
}
Ainsi la méthode abstract getPersonne() est dupliquée dans les classes concrètes en renvoyant chaque fois une spécificité de la classe concrète.
testAmis toto = new testAmis("tartempion", "toto"); // est une instance de test Amis et de dePersonnes; mais tu ne pourra pas construire d'instance dePersonnes comme ceci:
dePersonnes x = new dePersonnes("tartempion"); même si le constructeur est défini, on dit que c'est une classe abstraite;
Observe bien ces exemples déjà, les interfaces c'est un peu plus chaud.
A+