interface

Bonjour,
comment utiliser une interface qui contiendrait 1 méthode qui serait définie différement dans 2 classes distinctes ?
Appelle-t-on les méthodes de l'interface depuis la fonction main (ou une autre fonction) ? si oui quelle est la syntaxe ?

Par exemple : soient une classe A et une classe B
dans chacune des classes une méthode calculer() ;

dans la fonction principale on créé une instance de chaque classe
A monA = new A() ;
B monB = new B() ;

dans l'interface monInterface on a définie

interface monInterface{
public int calculer() ;
}
Je ne sais pas comment faire pour appeler la méthode calculer() contenue dans A depuis la fonction principale (par exemple).

Sil faut écrire monA.calculer() ; dans main, je ne comprends pas à quoi sert l'interface.

merci de vos lumières

Patrick

Bonjour patrockanite,

1 - tout d'abord, oui la syntaxe est bien : monA.calculer() ;

2 -

patrockanite a écrit:

je ne comprends pas à quoi sert l'interface.

Tu n'as pas mentionné les héritages ('extends') dans ton exemple.

je suppose que A et B héritent de 'monInterface'

Code:

Dans ce cas l'interface est utile si tu déclares dans ton main :
monInterface monA = new A() ;
monA.calculer() ;

Et plus loin dans ton programme tu pourras écrire :
monA = new B();
monA.calculer();

Pour cette propiété de l'objet, l'interface réagis exactement de la même façon qu'une classe.

Cordialement

Phildes

patrockanite a écrit:

Bonjour,
comment utiliser une interface qui contiendrait 1 méthode qui serait définie différement dans 2 classes distinctes ?
Appelle-t-on les méthodes de l'interface depuis la fonction main (ou une autre fonction) ? si oui quelle est la syntaxe ?

Par exemple : soient une classe A et une classe B
dans chacune des classes une méthode calculer() ;

dans la fonction principale on créé une instance de chaque classe
A monA = new A() ;
B monB = new B() ;

dans l'interface monInterface on a définie

interface monInterface{
public int calculer() ;
}
Je ne sais pas comment faire pour appeler la méthode calculer() contenue dans A depuis la fonction principale (par exemple).

Sil faut écrire monA.calculer() ; dans main, je ne comprends pas à quoi sert l'interface.

merci de vos lumières

Patrick

Bonjour Phildes;

Citation :

je suppose que A et B héritent de 'monInterface'

oui je pensais à

Code:

public class A implements monInterface{.....}

et idem pour B
Ceci posé je ne vois pas quelle est l'utilité.

merci

rebonjour,

Après avoir (et avant) d'avoir posé le post, je me suis documenté mais ce n'est pas simple. J'ai lu que le fait de déclarer des méthodes dans une interface obligeait toutesles classes implémentant cette interface à définir chaque méthode listée.

Si ceci est exact, j'imagine que ce n'est pas là la seule utilité de l'interface.

Phildes, je n'ai pas compris ton explication.

merci encore de m'éclairer comme d'hab.

Bonjour,

Ta question est en fait une question générique au sujet des objets.

Je pense que le mieux serait de nous appuyer sur une formation que tu trouveras à l'adresse :
http://hdd34.developpez.com/cours/artpoo/

Regarde le paragraphe "1.3.2 : Héritage"
Il y a une exemple avec des objets pris dans le domaine du bâtiment.
Cet exemple nous servira de base pour répondre précisément à ta question.

Recontacte moi après avoir lu ce paragraphe

@ bientôt

Phildes

patrockanite a écrit:

rebonjour,

Après avoir (et avant) d'avoir posé le post, je me suis documenté mais ce n'est pas simple. J'ai lu que le fait de déclarer des méthodes dans une interface obligeait toutesles classes implémentant cette interface à définir chaque méthode listée.

Si ceci est exact, j'imagine que ce n'est pas là la seule utilité de l'interface.

Phildes, je n'ai pas compris ton explication.

merci encore de m'éclairer comme d'hab.

Merci Phildes,

je vais lire le sujet.

patrockanite a écrit:

Merci Phildes,

je vais lire le sujet.

Ok, j'attends

rebjr Phildes

J'ai lu le sujet.
Pour moi c'est ok.
j'avais vu l'héritage avec extends, les constructeurs + surcharge, le polymorphisme les mots clé super pour appeler le constructeur de la classe mère et this pour appeler un constructeur [par exemple à 2 paramètres (largeur,Longueur) depuis un constructeur dont l'appel a 3 paramètres soit (largeur, Longueur, hauteur)]

C'est ce qui m'a amener après à la notion d'interface que je n'ai pas pigée (enfin pour l'instant j'espère).

Bonsoir,

Pour comprendre l'utilité de l'interface, il faut avoir compris 2 notions :

1 - un notion très élémentaire : une variable typée ne recevra que des données qui est de même type.
Exemple :
int prix = 123; sera accepté.
int prix = "il fait beau"; ne sera pas accepté.
(Jusqu'ici je pense que c'est assez simple)

2 - l'héritage : une variable typée acceptera une donnée de ce type, ou d'une fils héritier
Exemple : en reprenant le lien du tuto.
si : 'class Maison extends Batiment{...}'
Batiment b = new Maison(); sera accepté.

----------------------------------------------------
Tu as constaté que mes 2 exemples concernais l'affectation d'un valeur dans une variable.
Car c'est ici que réside le noeud du problème -> il faut que les variable acceptent les valeurs que nous lui présentons.
----------------------------------------------------

Revenons à nos interface

Imaginons maintenant que je suis un assureur et que je travaille sur les objets que j'assure, que je nomme des 'valeurs'. Mes clients peuvent posséder des voitures, des bijoux, des maisons...

Alors quand je fais mon programme, je vais créer un classe : 'Valeur'
Si je veux placer une Maison dans une variable qui reçoit une Valeur :
Valeur v = new Maison(); ! ! ! Aie Aie Aie !!! Maison et Valeur sont incompatibles

Comment faire pour que je puisse traiter une maison en tant que Valeur patrimonial d'un client ?

... As-tu la solution ?

@ bientôt

Phildes

Bonjour Phildes,

il faudrait que la classe Maison hérite de la classe Valeur.

Code:

public class Maison extends Valeur{....}

patrockanite a écrit:

Bonjour Phildes,

il faudrait que la classe Maison hérite de la classe Valeur.

Code:

public class Maison extends Valeur{....}

E.XA.CTE.MENT
( Je constate que tu as bien compris l'héritage )

Il faudrait que "Maison" hérite de 'Valeur"... Mais malheuresement, elle hérite déjà de "Batiment".

--------------------------------------------------------

MAUVAISE SOLUTION
On fait hériter Maison des 2 classes : Batiment et Valeur.
Des problèmes peuvent surgir si les 2 classes parents (Batiment et Valeur) possèdent des attributs ou des fonctions qui ont des noms identiques.
Alors certain langage interdisent les héritages-multiples.

--------------------------------------------------------

SOLUTION :
Nous allons créer une 'fausse' classe. Je veux dire une classe qui ne servira qu'à transformer une 'Maison' en 'Valeur'.
C'est ce type de classe se nomme : interface.

--------------------------------------------------------

Prenons déjà un exemple simple :
Tu veux simplement pouvoir placer les "Maison" dans les variables de type 'Valeur'.

En java tu crées une interface, que tu inscris dans une fichier 'Valeur.java' :
interface Valeur{}

Puis, dans la classe maison, tu ajoutes ce qui est souligné ci-dessous :
class Maison extends Batiment, implements Valeur{...}

-> maintenant, Maison pourra être placé dans les variables de type 'Batiment',
et aussi dans les variables de type Valeur

--------------------------------------------------------

Nous verrons dans un prochain message, pourquoi et comment on peut placer des fonctions 'vides' dans les interfaces

@ bientôt

Phildes

Bonjour Phildes,

Phildes a écrit:

2 - l'héritage : une variable typée acceptera une donnée de ce type, ou d'une fils héritier
Exemple : en reprenant le lien du tuto.
si : 'class Maison extends Batiment{...}'
Batiment b = new Maison(); sera accepté.

Dans ton code pour affecter b de type Batiment, tu fais appel au constructeur de la classe Maison si je suis bien.
Mais il va de soit que maison aura des attributs et méthodes spécifiques. (sinon aucun intérêt d'avoir 2 classes). comment ces spécificités sont-elles pris en compte ? avec cette syntaxe et dans le cadre d'une interface ?

Merci et excuse-moi de t'empêcher de dormir

patrockanite a écrit:

Bonjour Phildes,

Phildes a écrit:

2 - l'héritage : une variable typée acceptera une donnée de ce type, ou d'une fils héritier
Exemple : en reprenant le lien du tuto.
si : 'class Maison extends Batiment{...}'
Batiment b = new Maison(); sera accepté.

Dans ton code pour affecter b de type Batiment, tu fais appel au constructeur de la classe Maison si je suis bien.
Mais il va de soit que maison aura des attributs et méthodes spécifiques. (sinon aucun intérêt d'avoir 2 classes). comment ces spécificités sont-elles pris en compte ? avec cette syntaxe et dans le cadre d'une interface ?

Exactement ! Tu as mis le doigt sur le problème !

DANS 'Valeur', IL FAUT QUE L'ON PUISSE INDIQUER LES METHODES ATTENDUES

Donc, dans le script de Valeur.as nous allons indiquer les méthodes que le type Valeur reconnait.
Par exemple 'getPrix()' qui pourra être utiliser dans le programme ainsi :
Valeur v = new Maison(); v.getPrix();

Ecrivons le scriptde l'interface Valeur pas-à-pas :
1 - je déclare l'interface, nous l'avons déjà vu :
inteface Valeur{ // Ok on a déjà vue

2 - je déclare une méthode
function getPrix() // Ha ça commence comme une méthode de classe

3 - nous allons indiquer le script
{... NON ! NON ! NON ! On ne mets pas de script dans une interface ! ! ! :grosse_colere:

---------------------------------------------------------

Pourquoi ne peut-on pas mettre de script ?
Supposons la classe parent "Batiment" possède cette méthode.
-> que va-t-il se produire pour 'Maison m.getPrix()' ?
-> Dans quel ancêtre maison ira-t-elle rechercher getPrix() ? batiment.getPrix() ou Valeur.getPrix () ?

SOLUTION
Pour éviter ce problème, il est interdit d'indiquer des scripts dans une 'interface'.

Revenons à notre déclaration d'interface
---------------------------------------------------------
3 - nous clôturons la déclaration du la méthode (sans indiquer de script
;... Oui, nous retrouvons notre sacro-saint point-virgule.


Exemple complet :
inteface Valeur{
function getprix( parametres );
}

à l'usage :
Valeur v = new Maison();
v.getPrix();
-> si Maison ne comporte pas getPrix(), mais c'est Batiment qui possède cette méthode
=> v.getPrix() -> ira chercher la méthode dans la classe Batiment.

---------------------------------------------------------
Donc, tu as bien noté que la Classe Maison (ou un de ses ancêtres) doit obligatoirement
comporter la méthode 'getPrix()'
(ne t'inquiète pas, si tu l'oublies, le compilateur te le rappelle)
---------------------------------------------------------

En résumé, l'interface à 2 rôles :
1 - pouvoir ajouter un type à un objet. Exemple : Maison qui était un Batiment, devient aussi une Valeur
2 - elle permet d'accéder aux méthodes de la classe héritière Ex : v.getPrix()
Elle permet uniquement d'accéder à des méthodes. Elle ne fait rien d'autre.

Le prof d'histoire nous a écrit:

Pour conclure, un peu d'histoire :
Au début les langages Objet ne connaissaient pas 'l'interface', les objet pouvaient hériter de plusieurs classes.
Mais, constatant les problèmes causé, les auteurs de langages ont décidé d'imposer 1 SEUL PARENT, et d'y adjoindre des classes totalement 'abstraite' qui serait vide de tout script : les interfaces.

Est-ce plus claire ?

Phildes[quote]

Bonjour Phildes,

disons ça se clarifie. Il faut que j'assimile et que je fasse quelques essais pour que ce soit définitivement clair.

Ce qui veut dire que j'aurai assez vite d'autres questions sur le sujet.

J'espère que je vous embête pas trop avec mes questions à la noix mais bon comme il y a un espace Java j'en profite pour essayer d'avancer.

l'apprentissage de Java est vraiment pationnant, je pense que les habitués de Action Script devraient s'y intérresser, les langages sont assez proches et les habitués de l'AS ne devraient pas s'y perdre.

Pour ma part j'essaie d'apprendre les 2 parallèlement et ça me parait très jouable.

merci Phildes pour ton aide précieuse

Patrick