1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation

Tutoriel: Comment écrire une classe Java Date (Basic OOP Concept)

abdelouafiJan 23, 2017

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      402
      Likes Received:
      9
      Trophy Points:
      18
      Joined
      Sep 13, 2016
      Le concept de base de l'OOP (Object Oriented Programming) n'est pas difficile à comprendre et tous les étudiants en Informatique doivent être en mesure de démontrer l'OOP en utilisant Java, qui est considéré comme le langage de programmation le plus élégant qui a plein de concepts OOP.

      Ce qui suit vous guidera sur la façon d'écrire une classe Date de base en Java avec certaines méthodes utiles, constructeurs surchargés, attributs privés etc. Une classe peut être considérée comme l'encapsulation d'un tas de méthodes et d'attributs.

      Ainsi, nous nommerons la classe Date et nous devrions stocker le code source Java comme nom de fichier exactement comme le nom de la classe qui est Date.java. Il ne peut y avoir qu'une seule classe publique dans un fichier source Java, mais peut être plusieurs autres classes (non marquées comme publiques). Utilisez la commande javac Date.java pour compiler en bytecode, qui est Date.class et si elle est une classe exécutable (qui a une méthode principale statique comme point d'entrée du programme), vous pouvez utiliser la commande java Date pour exécuter l'application Java .
      Code:
      public class Date {
          /**
           * private attribute for holding day
           */
          private int day;
      
          /**
           * private attribute for holding month
           */
          private int month;
      
          /**
           * private attribute for holding year
           */
          private int year;
      }
      Nous déclarons trois attributs privés qui stockent l'année, le mois et le jour en trois entiers. Les attributs sont recommandés pour être privé mais en même temps nous devrions fournir des getters publics pour accéder à ces champs.
      Code:
      /**
           * Getter for day
           * @return day
           */
          public int getDay() {
              return this.day;
          }
      
          /**
           * Getter for month
           * @return month
           */
          public int getMonth() {
              return this.month;
          }
      
          /**
           * Getter for year
           * @return year
           */
          public int getYear() {
              return this.year;
          }  
      Avec ces getters, nous pouvons avoir une méthode compareTo qui compare cela à une autre classe Date.
      Code:
       /**
           * Compare two dates
           * @param d Date
           * @return true if it is earlier than d
           */
          public boolean compareTo(Date d) {
              int day1 = d.getDay();
              int month1 = d.getMonth();
              int year1 = d.getYear();
              return (this.year <= year1) && (this.month <= month1) && (this.day <= day1);
          }
      Veuillez noter que les champs privés peuvent être accédés directement à l'intérieur du même objet (par exemple, instance de classe) sans utiliser les méthodes public getter. Le suivant renvoie la date comme une chaîne de format de date ISO 8601.
      Code:
      /**
           * return a string representation
           * convert to ISO 8601 Date Format
           * http://en.wikipedia.org/wiki/ISO_8601
           * @return
           */
          public String toString() {
              StringBuilder s = new StringBuilder();
              s.append(String.valueOf(this.year));
              s.append("-");
              if (this.month < 10) s.append("0");
              s.append(String.valueOf(this.month));
              s.append("-");
              if (this.day < 10) s.append("0");
              s.append(String.valueOf(this.day));
              return s.toString();
          }
      Nous devons être en mesure de vérifier l'entrée de date donnée est valide ou non, donc la méthode suivante, marquée comme statique, fait cela.
      Code:
      /**
           * Check if given year/month/day is valid
           * @param year
           * @param month
           * @param day
           * @return true if it is valid date
           */
          public static boolean isValid(int year, int month, int day) {
              if (year < 0) return false;
              if ((month < 1) || (month > 12)) return false;
              if ((day < 1) || (day > 31)) return false;
              switch (month) {
                  case 1: return true;
                  case 2: return (isLeap(year) ? day <= 29 : day <= 28);
                  case 3: return true;
                  case 4: return day < 31;
                  case 5: return true;
                  case 6: return day < 31;
                  case 7: return true;
                  case 8: return true;
                  case 9: return day < 31;
                  case 10: return true;
                  case 11: return day < 31;
                  default: return true;
              }
          }
      
      Sur les années bissextiles, le mois de février est de 29 jours et 28 jours sinon. Par conséquent, nous devons être en mesure de vérifier si l'année est saut ou non.



      classe java date.png
      Veuillez noter que nous devons importer java.util.Calendar; Au début du fichier source Java. Si le nombre de jours de cette année est de 366 jours, il s'agit d'une année bissextile. Nous pouvons naturellement faire quelque chose de semblable mais moins direct.

      classe java date 2.png


      Les méthodes statiques sont partagées entre toutes les instances de la même classe et par conséquent il ne peut y avoir aucune référence à ses attributs non statiques dans les méthodes statiques. De même, les attributs statiques sont partagés entre toutes les instances de la même classe, c'est-à-dire quelque chose comme une variable globale pour tous les objets de la même classe (seulement 1 copie en mémoire).

      Avec cette méthode de validation, nous pouvons créer des constructeurs surchargés qui prennent la date d'entrée dans différents formats. Si les données données ne sont pas un format de date valide, alors IllegalArgumentException sera rejeté.


      Comment écrire une classe Java Date.png
       
      Last edited: May 7, 2017
      Loading...

Share This Page

Share