Bonsoir a tous ! j'ai un problème avec mon tp ! Bon pour les premiers méthodes c'est pas trop compliquer mais a partir d'où y a les fichiers ça se corse !
Est ce que quelqu'un peut m'aider a faire se tp ! merci

L'organisation d'un concert de musique comprend le choix des œuvres musicales à présenter, puis la sélection des musiciens ayant les compétences requises.

Chaque modèle d'instrument de musique est désigné par un nom particulier : violon, violoncelle, contrebasse, piano, flûte, clarinette, hautbois, trompette, cor, basson, trombone, cymbales, batterie, …

Il appartient également a une certaine classe d'instruments : instruments à cordes, à anche, à membrane, à percussion, …

Nous définirons donc tout d'abord une classe d'objets "Instrument" , dont les éléments correspondent aux différents modèles d'instruments, et sont caractérisés par le nom et le type de l'instrument .

La liste des instruments nécessaires à l'exécution d'une œuvre musicale est composée de lots d'instruments d'un même modèle : 8 violons, 2 flûtes, 2 hautbois 2 clarinettes, 2 violoncelles, … Nous définirons donc également une classe "LotInstruments", dont les objets seront composés d'un "instrument" (modèle d'instrument) , accompagné d'un nombre d'instruments.. L'ensemble des instruments nécessaires à l'exécution d'une œuvre apparaîtra alors comme une collection d'objets de type "LotInstruments".

Du point de vue de l'organisation de concerts, les œuvres musicales seront des objets identifiés par un nom, et caractérisés par la liste des lots d'instruments nécessaires à l'exécution de l'œuvre, telle que nous venons de la définir.

Par ailleurs, chaque musicien est caractérisé par son nom et par ses compétences musicales, c'est à dire par la liste des modèles d'instruments dont il sait jouer. Nous définirons donc une classe d'objets "Musicien", dont les éléments sont composés de l'identification du musicien, accompagnée de la liste des modèles d'instruments qu'il pratique (collection d'instruments).

Selon leur spécialité, les musiciens sont regroupés au sein d'orchestres de diverses catégories : orchestre de chambre, orchestre symphonique, orchestre de jazz., … ayant chacun leur spécificité. C'est pourquoi nous définirons tout d'abord une classe abstraite MusicienSet correspondant à une collection de musiciens, comportant des méthodes applicables à tout type d'orchestre. Les orchestres des divers types seront ensuite dérivés de cette classe abstraite.

I – MODELISATION OBJET

1 – Classes Instrument , LotInstruments et Musicien :

a) Chaque modèle d'instrument de musique est caractérisé par son nom, ainsi que par son type. Les objets de la classe Instrument devront donc comporter les champs suivants :


nom (String)

type (String)


Les méthodes à implémenter au niveau de cette classe seront :

* Instrument (String nom , String type)
: constructeur initialisant les champs indiqués avec les valeurs fournies.

* public boolean equals (Object o)
: test d'égalité entre deux objets "Instrument" , basé sur l'identité des champs correspondants de chacun des deux objets.

- String toString ( ) : méthode fournissant une version affichable des données de l'objet actuel.

b) Par ailleurs, dans un orchestre, il faut en général disposer de plusieurs instruments du même modèle, et l'on va donc définir aussi une classe LotInstruments , dérivée de la classe Instrument, permettant de mémoriser le nombre d'instruments d'un modèle donné figurant dans un orchestre. Les objets de la classe LotInstruments devront donc comporter en plus le champ de type int nbrInstr .

Les méthodes implémentées au niveau de cette classe seront :

- LotInstruments (Instrument instr , int nbrInstr) : constructeur initialisant les champs de l'objet à l'aide des valeurs fournies en paramètres.

- String toString ( ) : méthode fournissant un version affichable des données de l'objet actuel.

c) Un musicien d'orchestre est caractérisé par son nom et son prénom, ainsi que par la liste des modèles d'instruments qu'il pratique. Les objets de la classe Musicien devront donc comporter les champs suivants :


nom (String)

prenom (String)

lstInstr (collection d'instruments, du type ArrayList)

Les méthodes à implémenter au niveau de cette classe seront :

* Musicien (String nom , String prenom , ArrayList lstInstr)
: constructeur initialisant les champs indiqués avec les valeurs fournies.

* boolean
joueTilDe (Instrument instr) : méthode fournissant la valeur booléenne "vrai" si le musicien pratique l'instrument indiqué, et la valeur "faux" sinon.

* void addInstr (Instrument instrum)
: méthode permettant l'ajout d'un nouvel instrument à la liste des instruments pratiqués par le musicien, s'il n'y figure pas déjà.

* void rmInstr (Instrument instrum)
: méthode permettant la suppression d'un instrument de la liste des instruments pratiqués par le musicien, à condition qu'il y figure.

* String
toString ( ) : méthode fournissant un version affichable des données de l'objet actuel, avec liste des instruments pratiqués disposée en colonne.

2 – Classes InstrumentSet et OeuvreMusicale :

a) L'ensemble des instruments nécessaires à l'exécution d'une œuvre musicale sera introduit au moyen de la classe InstrumentSet , dont les objets seront des collections de "lots d'instruments" : Cette classe sera dérivée de la classe HashSet ; elle ne comportera aucun champ supplémentaire, mais seulement plusieurs méthodes spécifiques :

* lot
Instruments searchInstr (String nom) : recherche si, parmi les lots d'instruments faisant partie de la collection, il y en a un pour lequel le nom est la chaîne de caractères indiquée en paramètre ; si la recherche aboutit, la fonction retourne le lot d'instruments trouvé ; sinon, elle retourne la valeur "null".

* void addInstr (LotInstruments newLotInstr)
: méthode permettant l'ajout à la collection d'un nouveau lot d'instruments (donnée figurant en paramètre).

* void rmInstr (String nomInstr)
: méthode permettant la suppression d'un lot d'instruments dans la collection, lot désigné par le nom d'instrument figurant en paramètre.

* void modifInstr (LotInstruments lotInstrum)
: méthode permettant la modification du nombre d'instruments d'un lot (le nouveau nombre est indiqué par le paramètre).

* String toString ()
: méthode fournissant un version affichable des lots d'instruments de la collection., avec liste des instruments disposée en colonne.

b) Les œuvres musicales sont des objets identifiés par un nom, et caractérisés par la liste des instruments nécessaires à l'interprétation de l'œuvre. Les objets de la classe OeuvreMusicale devront donc comporter les champs suivants :


nomOeuvre (String)

instrSet (InstrumentSet)


En vue de faciliter les tests de mise au point, on mettra en place dans cette classe deux méthodes pour permettre la sauvegarde dans un fichier-texte des données relatives à une œuvre musicale, puis la re-création en mémoire d'un objet "OeuvreMusicale", à partir des données du fichier-texte.

Les méthodes à implémenter au niveau de cette classe seront donc les suivantes :

* OeuvreMusicale (
) : constructeur par défaut créant un objet dont le nom est la chaîne de caractères vide, et dont le champ instrSet est un InstrumentSet vide.

* OeuvreMusicale (String nomOeuvre
, InstrumentSet instrSet) : constructeur créant un objet dont les champs sont initialisés avec les valeurs indiqués en paramètres,.

* String
toString ( ) : méthode fournissant un version affichable des données de l'objet actuel, avec liste des lots d'instruments disposée en colonne.

* void writeToTextFile (String nomFichier)
: sauvegarde des données de l'objet actuel dans un fichier de type texte, dont le nom sera celui indiqué en paramètre. Dans le fichier crée, chaque donnée sera disposée sur une ligne séparée, et la fin de la liste des lots d'instruments sera indiqué par le mot "**" à la place du nom d'instrument. Pour faciliter l'écriture de cette méthode, on pourra au préalable rajouter à chacune des classes impliquées dans la construction d'une "OeuvreMusicale", une méthode "forTextFile ( )", analogue à la méthode toString ( )", et qui génère une chaîne de caractères comportant toutes les données de l'objet, séparées par des sauts de ligne.

* OeuvreMusicale (String nomFichier)
: constructeur initialisant l'objet crée à l'aide des données contenues dans le fichier-texte dont le nom est indiqué en paramètre; ce fichier-texte doit être conforme aux spécifications décrites pour la méthode "writeToTextFile" précédente.

3 – Classe abstraite MusicienSet , et classes OrchestreSympho , OrchestreJazz , OrchestreCh :

La classe abstraite MusicienSet correspond à une collection de musiciens pouvant constituer un orchestre. Les objets de la classe Musicien comporteront les champs suivants :


nomMusicienSet (String)

musiciens (HashSet)


Comme pour la classe OeuvreMusicale, et en vue de faciliter les tests de mise au point, on mettra aussi en place dans la classe MusicienSet deux méthodes pour permettre la sauvegarde dans un fichier-texte des données correspondant à un orchestre, puis la re-création en mémoire d'un objet "MusicienSet ", à partir des données du fichier-texte.

Les méthodes à implémenter au niveau de cette classe seront les suivantes :

* MusicienSet ()
: constructeur par défaut sans paramètres,

* MusicienSet (String nom , HashSet musiciens)
: constructeur à deux paramètres, (nom de l'ensemble, et HashSet de l'ensemble des musiciens). Cette méthode devra être redéfinie dans chacune des classes dérivées de MusicienSet , en fonction des règles relatives à chaque type d'orchestre.

* MusicienSet (MusicienSet orchestre)
: constructeur de copie (clonage), créant une copie complète de l'objet figurant en paramètre.

* Musicien rechercheMusicien (String nom , String prenom )
: recherche d'un musicien par son nom et son prénom

* Musicien musicienQuiJoueDe (Instrument instrum)
: recherche d'un musicien qui pratique un instrument donné.

* LinkedList instrOrchestre (HashSet musiciens)
: établissement de la liste de tous les instruments différents pratiqués par les musiciens du MusicienSet (méthode de classe); la liste sera crée sous la forme d'une LinkedList.

- void toString ( ) : version affichable des données d'un MusicienSet, avec pour chaque musicien, la liste des instruments pratiqués.

* void
writeToTextFile (String nomFichier) : méthode créant un fichier-texte portant le nom indiqué en paramètre, contenant toutes les données de l'objet actuel, et permettant de le reconstruire ultérieurement en utilisant le constructeur ci-après. Dans le fichier crée, chaque donnée sera disposée sur une ligne séparée; la fin de la liste des instruments pratiqués par un musicien donné sera indiqué par le mot "**" à la place du nom d'instrument; la fin de la liste des musiciens sera également indiqué par le mot "**" à la place du nom de musicien.

* MusicienSet (String nomFichier)
: méthode créant un objet de type MusicienSet à partir de données contenues dans le fichier-texte portant le nom indiqué en paramètre, (fichier créé précédemment par la méthode "writeToTextFile" ) .

b) Les classes OrchestreSympho , OrchestreCh , OrchestreJazz , … seront des classes dérivées de la classe MusicienSet , elles ne comportent aucun champ supplémentaire, mais seulement des constructeurs spécifiques, tenant compte de règles particulières à chacune des classes :

- un OrchestreSympho comporte plus de 50 musiciens, (parmi lesquels figurent au moins 8 instruments à cordes, 2 flûtes, 2 hautbois, 2 bassons, 2 clarinettes, 2 cors, 2 trombones, 2 trompettes).

- un OrchestreCh comporte au plus 49 musiciens,

- un OrchestreJazz comporte nécessairement au moins un trompettiste, un saxophoniste, un trombone, et une batterie.

(Tous les constructeurs doivent être redéfinis, mais les contraintes relatives à la composition de chaque type d'orchestre ne seront prises en compte que par les constructeurs à deux paramètres, qui devront "lever une exception" si les données fournies ne respectent pas les règles relatives au type d'orchestre considéré.)

4 – Classe Concert :

Pour simplifier la programmation, on supposera qu'une seule œuvre musicale est présentée au cours du concert. Les objets de la classe Concert sont alors définis par :

* l'intitulé "titre" du concert, (chaîne de caractères)

* l'œuvre musicale "oeuvre" à interpréter pendant le concert, (objet du type ŒuvreMusicale ).

* l'orchestre "orchestre" chargé de l'interprétation de cette œuvre. (objet du type Orchestre ).

* la collection "musiciensOeuvre" des musiciens de l'orchestre qui interviendront au moment de l'interprétation : cette collection sera générée par le constructeur de l'objet, chargé de vérifier l'adéquation de l'orchestre à l'œuvre musicale à présenter.

Les méthodes à prévoir pour les objets de cette classe sont le constructeur Concert , les différents accesseurs aux membres de l'objet, ainsi qu'une méthode toString ( ) permettant d'obtenir une version affichable des différentes données de l'objet, avec une présentation correcte.

Le constructeur :

Concert (String titre, OeuvreMusicale oeuvre, Orchestre orchestre, HashSet musiciensOeuvre )

est avant tout chargé de vérifier la cohérence des données fournies, c'est à dire si l'orchestre indiqué est capable d'interpréter l'œuvre musicale indiquée. Dans ce cas, il initialisera les champs titre, oeuvre et orchestre de l'objet à l'aide des données fournies ; il initialisera également le champ musiciensOeuvre avec une sélection de musiciens, choisis au sein de l'orchestre pour l'interprétation de l'œuvre. Dans le cas contraire, le constructeur devra se borner à "lever une exception".

On pourra définir au préalable une méthode de classe :

HashSet selectMusiciens (OeuvreMusicale oeuvre , Orchestre orchestre)

effectuant une sélection, parmi les musiciens de l'orchestre, des ceux qui sont nécessaires pour jouer l'œuvre musicale indiquée, et qui construit la collection (HashSet) des musiciens sélectionnés. Si la construction de cette collection est impossible, la méthode devra retourner le pointeur null .



II – PROGRAMMATION DEMANDEE :

1 – a) Définir les classes Instrument , LotInstruments et Musicien , et vérifier le bon fonctionnement des différentes méthodes écrites pour ces classes..

b) Définir les classes InstrumentSet et OeuvreMusicale , et vérifier le bon fonctionnement des différentes méthodes écrites pour ces classes. Le programme de test devra en particulier vérifier la sauvegarde dans un fichier-texte des données relatives à une œuvre musicale, ainsi que le rechargement en mémoire de ces données, permettant de recréer l'objet.

2 – a) Définir la classe abstraite MusicienSet ainsi que la classe dérivée OrchestreCh.

b) Vérifier le bon fonctionnement des différentes méthodes écrites pour ces classes en écrivant un programme qui définit, à partir de données entrées au clavier, un orchestre de chambre composé de 6 musiciens pratiquant chacun plusieurs instruments différents. Le programme affichera ensuite la composition complète de cet orchestre, ainsi que la liste de tous les instruments différents pratiqués par les musiciens. Il effectuera également la sauvegarde dans un fichier-texte de l'ensemble des données relatives à l'orchestre.

3 – a) Définir la classe Concert.

b) Ecrire un programme qui permet d'introduire au clavier les données relatives à une œuvre musicale, prévue pour être mise au programme d'un concert. Le programme effectuera également la sauvegarde dans un fichier-texte des données relatives à cette œuvre musicale.

c) Ecrire un programme qui permet, à partir des données introduites précédemment dans les questions 2 et 3 , de construire un objet de type Concert , si les données disponibles s'avèrent compatibles, et affiche alors, avec une mise en page correcte, l'ensemble des données correspondantes.

Collé dans un document Word, en Times New Roman taille 12, ton sujet (sans ton introduction) fait 7 pages A4.
Tu ne crois pas que c'est un peu beaucoup ?

j'ai donné le sujet de mon tp tout simplement

Salut !
Nous ne sommes pas là pour faire tes devoirs, merci de réfléchir un minimum sur le sujet et de présenter ton code ainsi que des explication simples et concises sur la chose qui te bloque.