Tout d'abord, désolé pour le titre incomplet, manque de caractère !

J'ai un petit soucis d'héritage en utilisant Java. J'ai commencé par implémenter une classe Polygone.java qui offre un constructeurs, des accesseurs et des services pour cette classe (j'ai également implémenté une classe Point.java pour réaliser ceci).

Un polygone est entièrement défini par ses sommets (j'ai créé le constructeur à l'aide d'une ArrayList)

J'aimerais maintenant définir une classe parallélogramme, qui hérite de Polygone, tout en spécifiant qu'il doit posséder quatre sommets et des côtés égaux deux à deux.

Comment s'y prendre ? Je vous joins le constructeur de mon code qui fait l'héritage, mais sans spécifier les particularités du parallélogramme.

par avance

import java.util.ArrayList;
import java.awt.Color;

public class Parallelogramme extends Polygone{
public Parallelogramme(Polygone p){
super(p);
}

}

________________________
Chuck Norris peut battre Novalis au Jammin'

Ton Polygone il définit quoi?

PS: Pour moi c'est un cas de mauvaise utilisation de l'héritage.

Mon Polygone définit des points, qui correspondent aux sommets du polygone.

PS : je suis contraint de suivre les directives du TP

________________________
Chuck Norris peut battre Novalis au Jammin'

Donc c'est tout? Juste des points?
Pas de méthodes pour les définir, rien?

Je vais essayer d'être un peu plus précis ^^'

Donc j'ai commencé par créer ma classe Point qui créé un point à l'aide de deux entiers, à savoir ses coordonnées.

Ensuite, j'ai créé une ArrayList de Points pour faire le constructeur du Polygone. On créé donc, en pratique, un polygone, puis des points, et enfin on ajoute ces points dans l'ArrayList, ce qui permet de définir notre polygone.

C'est assez clair, ou il faut aussi des détails sur les services/accesseurs ?

________________________
Chuck Norris peut battre Novalis au Jammin'

Merci d'avoir détaillé la partie qu'on pouvait deviner sans problèmes.

Maintenant si tu parlais de l'interface publique? Parce que c'est là que tu vas avoir le gros des problèmes. en fait tu peux poster ton code sur le net

http://pastebin.com/

désolé

Je ferais ça un peu plus tard, je suis reparti en cours, mais je te remercie pour ton aide

J'espère que tu resteras dans les parages !

________________________
Chuck Norris peut battre Novalis au Jammin'

Comme on en parle ici, _skip, tu pourrais détailler ton PS sur l'héritage stp ? Merci ^^

Je pense que la bonne manière de voir ton probleme, si l'heritage est obligatoire, c'est par "contrainte".

Tu as ta classe Point.
Tu as ta classe Polygone.

I/ Polygone
-------------

Pour moi, un Polygone n'EST PAS un point. Un polygone CONTIENT DES POINTS.
Donc ta classe Polygone aura comme attributs une structure de donnée qui contiendra tes points. (de taille variable).
Tu peux envisager comme constructeur pour Polygone de prendre un entier décrivant le nombre de points qui vont définir ce polygone, et les-dits points en deuxième argument (dans la structure de donnée qui te convient).

II/ Quadrilatère
------------------

Tu peux alors maintenant créer une classe Quadrilatère, qui hériterait de Polygone.
Et là c'est correct, car un Quadrilatere EST un polygone.
Pour le constructeur de Quadrilatere, tu peux donc obliger de recevoir 4 couples couples décrivant tes points, et tu te contente d'appeler super(4, TonConteneur(couple1, couple2, couple3, couple4).

III/ Parrallélogramme
----------------------
Ensuite tu peux immaginer Parrallélogramme.
Un Parrallélogramme EST BIEN un Polygone, et c'est meme un Quadrilatere pour être plus précis.
Parrallélogramme va donc hériter de Quadrilatere.
Là, il va falloir fixer deux contraintes : les cotés opposés sont parallèles.
Comment obliger un Quadrilatère à être un Parrallélogramme, tout en garantissant qu'il n'y aura qu'UN Parrallélogramme représentable ?
Une idée serait de fournir trois points. Avec trois points, tu définis UN ET UN SEUL Parallélogramme. (fais des dessins pour le voir).
Le quatrième point peut donc etre calculé avec les trois premiers.
Tu peux donc créer un constructeur de Parrallélogramme qui :
- Prend trois couple (x,y) en entrée : couple1, couple2, couple3.
- Calcule le quatrieme couple : couple4, à partir des trois premiers.
- Appel super(couple1, couple2, couple3, couple4).
// Rappel : on hérite de Quadrilatere, qui attend 4 couples.

Et ainsi de suite tu pourrais rajouter différentes structures.
Attention pour l'heritage à toujours bien se demander si l'objet dérivé EST UN "nom_de_la_classe_supérieur", mais spécialisé.
Si il CONTIENT UN/DES machins, machins sera plutot un attribut.

J'espère avoir pu t'aider un peu.
Si tu as des questions, ou si j'ai dis des bétises, n'hesitez pas à me dire ce qui ne va pas.

Un parallélogramme n'enrichit pas le polygone, en vérité il n'apporte que des contraintes car il correspond à un état du polygone.

Suivant les fonctionnalités exposées par polygone, il se peut qu'il faille les appauvrir ou leur ajouter des effets de bords, c'est pour ça que je dis que c'est un mauvais cas d'héritage.

S'il faut appauvrir l'API publique du parent, c'est souvent signe que l'héritage est une solution risquée.

La spécialisation de module serait une meilleure idée, dans un langage comme Caml...

Je suis entièrement d'accord, c'est un mauvais cas d'héritage dans la réalité.
Il y a 99% de chance que les méthodes qu'il va écrire pour Polygone modifient un dit polygone, et que cela puisse transformer un parrallélogramme en un non-parrallélogramme.
Mais je pense qu'il s'agit d'un petit exercice "comme ça", juste pour découvrir l'héritage.

Ils ne vont pas se poser la question de savoir si le design est vraiment bon à ce niveau là, je pense.
Il ne faut pas y voir là plus qu'un petit exo écrit rapidement pas le prof dans un coin du tableau..

On nous a bien appris il y a très longtemps que pour faire des soustractions, on mettait le plus grand chiffre en premier, et le plus petit après le "moins".
On a maintenant tous admis que l'on peut faire l'inverse aussi...

Me revoila

saleGauss wi, je suis bien d'accord sur le principe, me soucis repose sur l'écriture du constructeur. Toute la partie mathématique, c'est pas bien compliqué, le problème est juste de le faire comprendre à la machine !

Je vous joins les différentes parties de mon code si vous avez le courage de parcourir ça

Tout d'abord, la classe point :
http://pastebin.com/m668298b9

L'interface ObjetGeometriques, dont la suite hérite :
http://pastebin.com/m627d9f04

L'interface ObjetGeometriquesPolygone qui hérite de celle ci-dessus :
http://pastebin.com/m391f144e

Ma classe Polygone, qui implémente tout ce bazard :
http://pastebin.com/m557ed6ad

Voila tout ce qui doit être nécessaire je pense. Après, je n'ai rien écrit encore pour le parallélogramme, je bloque au constructeur.

par avance si vous arrivez à m'aider

PS : c'est effectivement un exercice pour nous faire capter l'hérédité ^^

________________________
Chuck Norris peut battre Novalis au Jammin'

Après quelques réflexions, j'avais pensé à :

public class Parallelogramme extends Polygone{

public Parallelogramme(Polygone p){
if(p.getSommets().size()==4){
super(p);
}
}

}

getSommets() étant une méthode qui renvoie les sommets du polygone. Cependant, ca ne compile pas, le compilateur me dit que "super" doit être la première ligne du constructeur

Encore une impasse

________________________
Chuck Norris peut battre Novalis au Jammin'

Attend, pourquoi tu voudrais faire avaler un polygone a un constructeur par copie? Si on te passe un octogone tu fais quoi?

C est un parallélogramme que tu dois prendre en paramètre, et tu peux immédiatement faire un super(p).
Par ailleurs ils seraient bien que tu renvoies des copies des points dans getSommets(). Sinon moi je fais :

pGramme.getSommets().add(new Point(34, 13));
ou un
pGramme.getSommets().get(0).setX(34);

Et c'est plus un parallélogramme. T'as aucune encapsulation en laissant modifier ta figure à l extérieur de la classe. Au moins si tu retournes des copies, si on modifie les copies ca n'altère pas ta forme.

Tu es quand même mal barré avec ce genre d'héritage. Si tu hérites de polygone, tu dois essayer de masquer les méthodes qui posent problème.
Par exemple ton constructeur qui prend un polygone en entrée, ça peut pas aller, on va te passer n'importe quoi. Même si tu testes 4 points, c'est pas forcément un parallélogramme.