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

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

abdelouafiJan 23, 2017

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      267
      Likes Received:
      8
      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.
      Code:
       /**
           * Check given year is leap year
           * @param year
           * @return true if year is leap year
           */
          public static boolean isLeap(int year) {
              // using system library to do this, avoid re-invent the wheel
              Calendar cal = Calendar.getInstance();
              cal.set(Calendar.YEAR, year);
              return cal.getActualMaximum(Calendar.DAY_OF_YEAR) > 365;     
          }
      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.
      Code:
      /**
           * Check given year is leap year
           * @param year
           * @return true if year is leap year
           */
          public static boolean isLeap(int year) {
                  if (year % 4 != 0) {
                    return false;
                  } else if (year % 400 == 0) {
                    return true;
                  } else if (year % 100 == 0) {
                    return false;
                  } else {
                    return true;
                  }       
          }
      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é.
      Code:
      /**
           * Constructor that takes year/month/day
           * @param year
           * @param month
           * @param day
           * @throws IllegalArgumentException if invalid
           */
          public Date(int year, int month, int day) throws IllegalArgumentException{
              if (!isValid(year, month, day)) throw new IllegalArgumentException();
              this.year = year;
              this.month = month;
              this.day = day;     
          }
         
          /**
           * Constructor that takes a ISO8601 date string
           * @param dateISO8601
           * @throws IllegalArgumentException if invalid
           */
          public Date(String dateISO8601) throws IllegalArgumentException {
              String[] s = dateISO8601.split("-");
              if (s.length != 3) throw new IllegalArgumentException();
              int yy = Integer.parseInt(s[0]);
              int mm = Integer.parseInt(s[1]);
              int dd = Integer.parseInt(s[2]);
              if (!isValid(yy, mm, dd)) throw new IllegalArgumentException();
              this.year = yy;
              this.month = mm;
              this.day = dd;
          }
      Ou, si aucun paramètre n'est donné, la date d'aujourd'hui sera utilisée.
      Code:
      /**
           * default constructor that uses today's Date()
           */
          public Date() {
              Calendar currentDate = Calendar.getInstance(); //Get the current date
              java.util.Date x = currentDate.getTime();
              SimpleDateFormat formatyear = new SimpleDateFormat("yyyy");
              this.year = Integer.parseInt(formatyear.format(x));
              SimpleDateFormat formatmonth = new SimpleDateFormat("MM");
              this.month = Integer.parseInt(formatmonth.format(x));     
              SimpleDateFormat formatdd = new SimpleDateFormat("dd");
              this.day = Integer.parseInt(formatdd.format(x));       
          }
      Nous devons importer java.text.SimpleDateFormat; Pour les utilitaires de gestion du format de date correspondants.

      Pour tester les fonctions ci-dessus, nous pouvons créer une autre classe de test qui a une méthode principale statique servant d'entrée d'application Java. Utilisez la commande java Test pour démarrer le test après javac Test.java.
      Code:
      public class Test {
          /**
           * @param args the command line arguments
           */
          public static void main(String[] args) {
             
              // get today
              Date today = new Date();
              System.out.println(today.toString());
             
              // tomorrow
              Date tomorrow = new Date("2014-05-09");
              System.out.println(today.compareTo(tomorrow)); // today is earlier than tomorrow
             
              // yesterday
              Date yesterday = new Date(2014, 5, 7);
              System.out.println(today.compareTo(yesterday)); // today is NOT earlier than tomorrow
             
              // 2013 is not leap year
              System.out.println(Date.isLeap(2013) ? "2013 is leap": "2013 is not leap");
             
              // 2013-1-31 is a valid date
              System.out.println(Date.isValid(2013, 1, 31));
             
              // 2014 - 2 - 29 is not valid and will throw IllegalArgumentException
              Date invalid = new Date(2014, 2, 29); // throws exception
              System.out.println(invalid.toString());
          }
         
      }
       
      Loading...

Share This Page

Share