Classe abstraite et interface

Version imprimable

15/06/2007, 02h13
ender91

Classe abstraite et interface

Bonjour a tous
Une petite question surement bete :mouarf:
Je me demande a quoi servent les classes abstraites et les interfaces.
J'ai beau lire des tutos je ne comprend pas bien le concepte.
A quoi servent elle, dans quelle circonstance.
Voila si quelqu'un peut eclairer ma lenterne :lol:
Merci d'avance
15/06/2007, 08h41
OButterlin

En bien, pour faire simple :
1) Classe abstraite :
- ne peut pas être instanciée
- sert à définir des méthodes commune pour les classes dérivée
- peut être utilisé pour traiter des objets différents (enfants) par leur socle commun

2) Interface
- sert à définir des méthodes, constantes (un comportement), un peu comme un prototype de méthode (pas d'implémentation)
- un objet peut implémenter plusieurs interfaces (contrairement à l'héritage : on ne peut hériter que d'un seul objet) et doit implémenter les méthodes de l'interface (ou des interfaces)
- peut être utiliser pour "voir" un objet au travers de l'interface

En gros, pour les grandes lignes... Je ne sais pas si ça t'aidera...
Tu peux toujours voir un tuto pour plus de détail...

A+

Pour les interfaces nous allons prendre un exemple pour illustrer la première réponse de OButterlin

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
class Etudiant implements Comparable<Etudiant>
{
 
    int note ;
 
    public int getNote(){
        return note ;
    }
 
    public int compareTo(Etudiant o)
    {
        if( note == o.getNote() )
            return 0 ;
        else if( note  > o.getNote() )
            return 1 ;
        else
                return -1;
    }
 
}
 
class Employe implements Comparable<Employe>
{
 
    int salaire ;
 
    public int getSalaire(){
        return salaire ;
    }
 
    public int compareTo(Employe o)
    {
        if( salaire == o.getSalaire() )
            return 0 ;
        else if( salaire  > o.getSalaire() )
            return 1 ;
        else
                return -1;
    }
 
}

L'interface Comparable contient une méthode qui retourne un int en vue de trier un tableau.
Mais Java ne sait pas comparer deux objets ( de ton imagination )
Donc grâce a l'interface Comparable fournie par Java. Quand tu l'implémente dans une de tes classes, tu vas apprendre Java à trier un tableau ( qui contient des objets de ton imagination ).

Maintenant, nous voilà un exemple pour les classes abstraite :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
abstract class Personne
{
    String nom;
 
    String prenom;
 
    public String getNom()
    {
        return nom;
    }
 
    public String getPrenom()
    {
        return prenom;
    }
 
    public abstract String getDescription();
 
}
 
class Employe extends Personne
{
    int salaire;
 
    public String getDescription()
    {
        return getNom() + " " + getPrenom() + " à pour salaire " + salaire;
    }
 
}
 
class Etudiant extends Personne
{
    int note;
 
    public String getDescription()
    {
        return getNom() + " " + getPrenom() + " à pour salaire " + note;
    }
 
}

15/06/2007, 09h29
Rayndell

Si cela peut éclairer ta lanterne, les interfaces servent à modéliser l'héritage mlultiple qui n'existe pas en Java.
15/06/2007, 10h08
ender91

Merci pour toutes ces réponses.
Je pense avoir saisie le concept
Merci
15/06/2007, 10h09
Pill_S

Citation:

Envoyé par Rayndell

Si cela peut éclairer ta lanterne, les interfaces servent à modéliser l'héritage mlultiple qui n'existe pas en Java.

Oui mais pas seulement...

Ca permet aussi de se détacher complètement de l'implémentation pour référencer les objets: on référence un type dont on ne sait absolument rien de sa manière de fonctionner.... et du coup cette manière est laissée libre aux classes qui implémentent l'interface......

Très puissant en tout cas ;)
15/06/2007, 11h46
OButterlin

Citation:

Envoyé par Pill_S

Très puissant en tout cas ;)

Bien d'accord avec toi... C'est comme si on pouvait voir une instance d'objet d'un point de vue ou d'un autre en fonction de ce qu'on veut gérer et sans se soucier de la classe de l'instance...

Over sympa !!!