1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      267
      Likes Received:
      8
      Trophy Points:
      18
      Joined
      Sep 13, 2016
      Exercice 1 : classe Livre
      Considérons le source de la classe Livre suivant :

      public class Livre {
      // Variables
      private String titre, auteur;
      private int nbPages
      // Constructeur
      public Livre(String unAuteur, String unTitre) {
      auteur = unAuteur;
      titre = unTitre;
      }
      // Accesseur
      public String getAuteur() {
      return auteur;
      }
      // Modificateur
      void setNbPages(int n) {
      nbPages = nb;
      }
      Corrigez quelques petites erreurs et ajoutez une méthode main() pour

      · Créer 2 livres,

      · Faire afficher les auteurs de ces 2 livres.

      Exercice 2 : accesseurs et modificateurs
      Modifiez la classe Livre :

      • Ajoutez un accesseur pour la variable titre et la variable nbPages.
      • Ajouter un modificateur pour les variables auteur et titre.
      • Changez le modificateur de nbPages : il ne devra changer le nombre de pages que si on lui passe en paramètre un nombre positif, et ne rien faire sinon, en affichant un message d'erreur. On remarquera l'intérêt des variables private : on peut contrôler leur modification dans les éventuelles méthodes qui permettent de les modifier.
      • Dans la méthode main(),
        • indiquez le nombre de pages de chacun des 2 livres,
        • faites afficher ces nombres de pages,
        • calculez le nombre de pages total de ces 2 livres et affichez-le.
      Exercice 3 : méthode toString()
      1. Dans la classe Livre, ajoutez une méthode afficheToi() qui affiche une description du livre (auteur, titre et nombre de pages). Utilisez afficheToi() dans la méthode main() de TestLivre.
      2. Ajoutez l'instruction System.out.println(livre) où livre désigne un des livres que vous avez créés. Vous essaierez de comprendre ce qui est affiché après avoir fait les 2 questions suivantes.
      3. Ajoutez une méthode toString() qui renvoie une chaîne de caractères qui décrit le livre. Donnez à la méthode toString() le même profil que la méthode de même nom de la classe java.lang.Object (cherchez dans les API du JDK). Exécutez à nouveau la classe TestLivre. Voyez ce qui est affiché maintenant par l'instruction System.out.println(livre). Miracle ! println() utilise automatiquement la méthode toString() de la classe de l'objet qu'il a à imprimer. Essayez de trouver une explication rationnelle en faisant la question suivante.
      4. Il faut savoir chercher dans la documentation de l'API (javadoc). En partant de la classe java.lang.System et en cliquant sur les liens, retrouvez dans la documentation que System.out.println(objet) affiche ce que retourne la méthode toString de la classe de objet.
      5. Modifiez la méthode afficheToi() pour utiliser toString().

      Exercice 4 : les constructeurs

      1. Enlevez (provisoirement) le seul constructeur de la classe Livre. Sans ajouter de nouveau constructeur, peut-on quand même créer un nouveau livre dans la méthode main ? Si c'est possible, créez un livre écrit par Victor Hugo et faites afficher son titre et son auteur.

      2. Remettez le constructeur que vous avez enlevé. Est-ce que le code de la méthode main de la question précédente fonctionne toujours (testez) ?

      3. Ajoutez 2 constructeurs pour avoir 3 constructeurs dans la classe :

      • un constructeur qui n'a pas de paramètre,
      • un qui prend en paramètre l'auteur et le titre du livre,
      • et l'autre qui prend en plus le nombre de pages.
      Utilisez les 3 constructeurs (et éventuellement d'autres méthodes) pour créer 3 livres de 300 pages dans la méthode main de TestLivre.


      Exercice 5 : contrôle des variables private par les modificateurs

      1. Ajoutez un prix aux livres (nombre qui peut avoir 2 décimales de type Java double) avec 2 méthodes getPrix et setPrix pour obtenir le prix et le modifier. Ajoutez au moins un constructeur qui prend le prix en paramètre. Testez.
        Si le prix d'un livre n'a pas été donné, la description du livre (toString()) devra indiquer "Prix pas encore donné". Attention, un livre peut être gratuit (0 est une valeur possible pour un prix) ; la valeur -1 indiquera que le prix n'a pas encore été donné.
      2. On bloque complètement les prix : un prix ne peut être donné qu'une seule fois et ne peut être modifié ensuite (une tentative pour changer le prix ne fait qu'afficher un message d'erreur).
        Récrivez la méthode setPrix (et autre chose si besoin est). Vous ajouterez une variable booléenne prixFixe (pour "prix fixé") qui indiquera que le prix ne peut plus être modifié.
        Faut-il écrire une méthode "setPrixFixe" pour modifier la variable booléenne ?
        Ajoutez une méthode "isPrixFixe" qui renvoie vrai si le prix a déjà été fixé.
      3. Juste pour voir : déclarez le prix comme une variable public et (dans TestLivre) faites afficher un prix sans passer par une méthode. Testez. Rétablissez le prix comme une variable private. Ne recompilez que Livre. Vous devriez voir un message d'erreur si vous essayez à nouveau d'accéder directement à la variable depuis la méthode main de TestLivre. Le voyez-vous ?
        Relancez l'exécution avec l'option -verify de java. Vous voyez une différence ?
      Exercice 6 : comparaison de 2 livres en utilisant une méthode d'instance
      Dans la classe Livre écrivez une méthode d'instance compare pour comparer 2 livres sur leur nombre de pages.
      compare prend un livre en paramètre et elle renvoie 0 si le livre a le même nombre de pages que l'instance qui reçoit le message, 1 si l'instance courante ("this") a plus de pages que le parametre et -1 sinon.

      Exercice 7 : Articles à vendre
      Une société vend des articles de papeterie. Vous vous limiterez aux articles suivants :

      • stylos décrits par une référence, un nom ou descriptif (par exemple "stylo noir B2"), une marque, un prix unitaire et une couleur,
      • ramettes de papier décrites par une référence, un nom, une marque, un prix unitaire et le grammage du papier (par exemple, 80 g/m²).
      De plus cette société peut vendre ces articles par lots. Vous supposerez que les lots sont composés d'un certain nombre d'un même type d'articles, par exemple un lot de 10 stylos noirs B2 de la marque WaterTruc. Un lot a une référence et une marque (celle de l'article). Le nom du lot est déterminé par le nombre d'articles dont il est composé ; par exemple "Lot de 10 stylo noir B2" (vous êtes dispensé de mettre les noms au pluriel !). Le prix du lot est déterminé par le prix unitaire de l'article multiplié par le nombre d'articles, auquel est enlevé un certain pourcentage qui dépend du lot. Par exemple, si un lot de 10 stylos à 100 F a un pourcentage de réduction de 20 %, le prix du lot sera de 10 x 100 x (100 - 20) / 100 = 800 F. Le prix d'un lot sera calculé au moment où on demandera le prix du lot ; il n'est pas fixé une fois pour toute et il change si le prix de l'article qui compose le lot est modifié.

      Ecrivez des classes dans un paquetage "ma.ensa.article" pour représenter les différents articles.

      On ne s'intéresse qu'aux différents types d'articles. Ainsi, on aura une seule instance qui représentera le type "stylo noir B2" et pas 250 instances si la société possède 250 "stylo noir B2". Si vous voulez démarrer une gestion de stock, vous pouvez ajouter le nombre d'articles en stock pour chaque type, mais ça n'est pas demandé.

      Vos classes devront permettre de faire du polymorphisme avec la méthode qui donnera le prix d'un article.



      Exercice 8 : Du polymorphisme dans une facture

      La société établit des factures numérotées (en partant de 1) et datées, comprenant le nom du client, le prix total de la commande et, pour chaque article commandé, sa référence, son prix unitaire, le nombre d'articles commandés et le prix total pour cet article.
      Pour simplifier, un client ne sera qu'un simple nom dans la facture (pas de classe Client).

      Ajoutez les classes pour représenter ces factures, dans un paquetage " ma.ensa.facture".

      Vous écrirez une classe test qui affiche 1 facture pour

      • 10 stylos (choisissez ses caractéristiques)
      • 15 ramettes de papier
      • 2 lots de 5 stylos (différents des 10 stylos)
      et une autre facture pour

      • 3 stylos
      • 2 ramettes
      pour 2 clients différents.
      Le programme créera tous les objets nécessaires à l'affichage des 2 factures.
      Une facture s'affichera sur le modèle suivant (on ne demande pas d'affiner davantage le format d'affichage mais si vous pouvez faire mieux, n'hésitez pas !) :
      ---------------------------------------------------------------------
      Facture 125 Client: richard Date: 10 novembre 1999

      Quant. Ref. Nom Marque PU PT
      10 s1 Stylo Jade Watertruc 500.0 5000.0
      15 r1 Ramette haute qualité Clairefont 95.0 1425.0
      2 l1 Lot de 5 Stylo or Marker 4500.0 9000.0

      Prix total facture : 15425.0 F
      ---------------------------------------------------------------------

      Exercice 9 : Classes d'objets géométriques
      On souhaite disposer d'un ensemble de classes permettant de manipuler des objets géométriques en 2 et 3 dimensions (on ne s'occupe pas de leur représentation graphique).

      3.1 Architecture des classes
      Ecrivez les classes reflétant la structure suivante :

      • Shape (*)
        • Shape2D (*)
          • Rectangle
            • Square
          • Ellipse
            • Circle
        • Shape3D (*)
          • Sphere
          • Cylinder
      (*) classe abstraite (non instanciable)

      Ces classes doivent permettre de :

      1. identifier les objets lors de leur creation (e.g. : Circle c = new Circle("mon cercle", 2.5))
      2. calculer la surface des objets (methode area())
      3. calculer le perimètre des objets dérivant de Shape2D (methode perimeter())
      4. calculer le volume des objets dérivant de Shape3D (methode volume())
      3.2 Mise en oeuvre
      Ecrivez un petit programme Java mettant en oeuvre ces classes.

      3.3 Deploiement dans des packages
      Deployez ces classes dans les packages :

      • shape
      • shape.shape2D
      • shape.shape3D
      3.4 Comptabilisation des instances
      Ajoutez des variables de classes (count) comptabilisant le nombre d'instances des classes Shape, Shape2D et Shape3D .

      Exercice 10 : Compte Bancaire

      1 "Cahier des charges"

      Il s'agit de définir une classe JAVA permettant de modéliser des comptes bancaires. Cette classe (Compte) doit permettre à une application de créer et utiliser autant de comptes bancaires que nécessaires, chaque compte étant un objet, instance (ou exemplaire) de la classe Compte.

      Un compte bancaire est identifié par un numéro de compte. Ce numéro de compte est un entier positif permettant de désigner et distinguer sans ambiguïté possible chaque compte géré par l'établissement bancaire. Chaque compte possède donc un numéro unique. Ce numéro est attribué par la banque à l'ouverture du compte et ne peut être modifié par la suite. Dans un souci de simplicité (qui ne traduit pas la réalité) on adoptera la politique suivante pour l'attribution des numéros de compte : les comptes sont numérotés de 1 à n, n étant le nombre de comptes qui ont été créés. Lorsque un nouveau compte est créé, le numéro qui lui est attribué est n+1.

      Un compte est associé à une personne (civile ou morale) titulaire du compte, cette personne étant décrite par son nom. Une fois le compte créé, le titulaire du compte ne peut plus être modifié.

      La somme d'argent disponible sur un compte est exprimée en Euros. Cette somme est désignée sous le terme de solde du compte. Ce solde est un nombre décimal qui peut être positif, nul ou négatif.

      Le solde d'un compte peut être éventuellement (et temporairement) être négatif. Dans ce cas, on dit que le compte est à découvert. Le decouvert d'un compte est nul si le solde du compte est positif ou nul, il est égal à la valeur absolue du solde si ce dernier est négatif.

      En aucun cas le solde d'un compte ne peut être inférieur à une valeur fixée pour ce compte. Cette valeur est définie comme étant - (moins) le découvert maximal autorisé pour ce compte. Par exemple pour un compte dont le découvert maximal autorisé est 2000 €, le solde ne pourra pas être inférieur à -2000 €. Le découvert maximal autorisé peut varier d'un compte à un autre, il est fixé arbitrairement par la banque à la création du compte et peut être ensuite révisé selon les modifcations des revenus du titulaire du compte.

      Créditer un compte consiste à ajouter un montant positif au solde du compte.

      Débiter un compte consiste à retirer un montant positif au solde du compte. Le solde résultant ne doit en aucun cas être inférieur au découvert maximal autorisé pour ce compte.

      Lors d'une opération de retrait, un compte ne peut être débité d'un montant supérieur à une valeur désignée sous le terme de débit maximal autorisé. Comme le découvert maximal autorisé, le débit maximal autorisé peut varier d'un compte à un autre et est fixé arbitrairement par la banque à la création du compte. Il peut être ensuite révisé selon les modifications des revenus du titulaire du compte.

      Effectuer un virement consiste à débiter un compte au profit d'un autre compte qui sera crédité du montant du débit.

      Lors de la création d'un compte seul le nom du titulaire du compte est indispensable. En l'absence de dépot initial le solde est fixé à 0. Les valeurs par défaut pour le découvert maximal autorisé et le débit maximal autorisé sont respectivement de 800 € et 1000 €. Il est éventuellement possible d'attribuer d'autres valeurs à ces caractéristiques du compte lors de sa création.

      Toutes les informations concernant un compte peuvent être consultées : numéro du compte, nom du titulaire, montant du découvert maximal autorisé, montant du débit maximal autorisé, situation du compte (est-il à découvert ?), montant du débit autorisé (fonction du solde courant et du débit maximal autorisé).

      2. Travail demandé

      1. A partir du "cahier des charges" précédent élaborer une spécification d'une classe Java modélisant un compte bancaire.
        Il s'agira en analysant le texte ci-dessus de :
        - définir les attributs (variables d'instance, variables de classe) de la classe Compte,
        - d'identifier les méthodes publiques proposées par la classe Compte. Pour chaque méthode on prendra soin, outre la définition de sa signature, de spécifier son comportement sous la forme d'un commentaire documentant.
        - de proposer un ou plusieurs constructeurs pour la classe Compte. Là aussi on complétera la donnée de la signature de chaque constructeur avec un commentaire documentant détaillant son utilisation.
      2. Réaliser une implémentation en langage Java de la classe précédemment spécifiée.
      3. Ecrire un programme de test permettant de :
      • Créer un compte c1, au nom de J. DUPONT avec un solde initial de 1 000 €
      • Créer un compte c2, au nom de C. DURANT avec un solde inital de 50 000 €, un debit maximal autorisé de 6000 € et un découvert maximal autorisé de 5000 €.
      • D'afficher les caractéristiques des comptes c1 et c2 (c'est à dire les informations suivantes : numéro du compte, nom du titulaire, découvert maximal autorisé, débit maximal autorisé, solde du compte et si le compte est à découvert un message le signalant explicitement).
      • Retirer 300 € du compte c1.
      • Retirer 600 € du compte c2.
      • Déposer 500 € sur le compte c1.
      • D'afficher les caractéristiques des comptes c1 et c2.
      • Virer 1000 € du compte c2 vers le compte c1.
      • D'afficher les caractéristiques des comptes c1 et c2.
       
      Loading...

Share This Page

Share