Discussion :

[ender91]

Bonjour a tous
Une petite question surement bete
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
Merci d'avance

[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+

[dams77]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
    }
 
}

[Rayndell]

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

[ender91]

Merci pour toutes ces réponses.
Je pense avoir saisie le concept
Merci

[Pill_S]

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

[OButterlin]

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 !!!