mydate.java

OOP方面的JAVA实例,适合用于面向对象的学习!用JAVA开发的!

package student;

import java.util.StringTokenizer;
import java.util.Calendar;

/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2004</p>
 * <p>Company: </p>
 * @author not attributablex
 * @version 1.0
 */

public class Mydate implements Cloneable,Formatable
{

  private static final int MONTH_LENGTH[]
      = {
      31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; // based
  private static final int LEAP_MONTH_LENGTH[]
      = {
      31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; // based
  private static final int YEAR = 0;    //  field
  private static final int MONTH = 1;   //  field
  private static final int DAY = 2;     //  field

  private int year;
  private int month=1;
  private int day=1;

  private char formater= '.';

  //constructor
  public Mydate() {
  }
  public Mydate(Mydate mydate)
  {
    year  = mydate.year ;
    month = mydate.month ;
    day   = mydate.day;
  }
  public Mydate (int year,int month,int day)
  {
        set(YEAR, year);
        set(MONTH, month);
        set(DAY, day);
  }

  /**
       * Constructs a Mydate with the given String
       * and if the given string is over field(e.g. "1982.6.25.25.6"),
       * it cause the ErrorMydateformatException and set date for the default date.
       * if the given string contains char (e.g. "1982.asdf6.25"),
       * it cause the NumberFormatException and set date for the default date.
       */

  public Mydate (String str) {
     StringTokenizer dateToken = new StringTokenizer(str, String.valueOf(formater));
     int field = 0;
     try {
        while (dateToken.hasMoreTokens()) {
             if (field > 2)
               {
                 throw (new ErrorMydateFormatException ("Input the error Mydate value!",str));
               }
             set(field, Integer.parseInt(dateToken.nextToken()));
             field++;
         }
      }catch (NumberFormatException e)
         {
             System.out.println("Input the error Mydate value !");
             setDefault();
         }
      catch(ErrorMydateFormatException  e)
         {
            e.printStackTrace();
            System.out.println("Error date :"+e.getErrorDate());
            setDefault();
         }//end try

   }

  public void  setDefault()
  {
    this.year =1;
    this.month =1;
    this.day =1;
  }

  public  Object clone() {
    try
    {
      return super.clone();
    }catch(CloneNotSupportedException e)
    {
      System.out.println(e);
      return null;
    }
  }
  /**
       * Determines if the given year is a leap year. Returns true if the
       * given year is a leap year.
       * @param year the given year.
       * @return true if the given year is a leap year; false otherwise.
       */

  public boolean isLeapYear(int year) {
    return (year % 4 == 0) && ( (year % 100 != 0) || (year % 400 == 0));
  }

  private final int monthLength(int month, int year) {
    return isLeapYear(year) ? LEAP_MONTH_LENGTH[month] : MONTH_LENGTH[month];
  }
  /**
       * After adjustments such as set(MONTH), set(YEAR), we don't want the
       * month to jump around.  E.g., we don't want Jan 31 + 1 month to go to Mar
       * 3, we want it to go to Feb 28.  Adjustments which might run into this
       * problem call this method to retain the proper month.
       */

  private final void pinDayOfMonth(int month, int year, int day) {
      int monthLen = monthLength(month, year);
      if (day <=0)
      {
        set(DAY,1);
      }

      if (day > monthLen)
      {
        set(DAY, monthLen);
      }
  }

  private final void pinMonthOfYear(int month)
  {
    if (month > 12 || month <= 0)
      {
        set(MONTH, 12);
      }//end if

  }

  public void set(int field, int amount) {

      switch (field) {
        case YEAR:
          year = amount;
          break;
        case MONTH:
          month = amount;
          pinMonthOfYear(month);
          break;
        case DAY:
          day = amount;
          pinDayOfMonth(month - 1, year, day);
          break;
      } //end switch

  }

  public int get(int field)
  {
    switch (field)
    {
      case YEAR:
         return year;

      case MONTH:
         return month;

      case DAY:
         return day;

      default:
            return -1;
    }//end switch
  }

  public void setFormater(char formater)
  {
    this.formater = formater;
  }

  public char getFormater()
  {
    return formater;
  }

  /**
       * Value of the <code>year</code> field < 0 indicating
       * the period before the common era (before Christ), also known as BCE.
       * The sequence of years at the transition from <code>BC</code> to <code>AD</code> is
       * ..., 2 BC, 1 BC, 1 AD, 2 AD,...
       **/

public String toString ()
  {
    if (year>0)
     {
        return Integer.toString(year)
                        + formater
                        + Integer.toString(month)
                        + formater
                        + Integer.toString(day);
     }else{
             return "BC"+Integer.toString(-year+1)
                         + formater
                         + Integer.toString(month)
                         + formater
                         +Integer.toString(day);
          }//end if
  }

  public int  daysIn2Date(Mydate date)
  {
    int startYear ;
    int startMonth ;
    int startDay ;
    int endYear ;
    int endMonth ;
    int endDay ;
    int howManyDays = 0;

    //set startDate < endDate
    if (     (date.get(YEAR)> year)
          || ( date.get(YEAR)== year && date.get(MONTH)  > month )
          || ( date.get(YEAR)== year && date.get(MONTH) == month && date.get(DAY)>day )  )
       {
            startYear = year;
            startMonth = month;
            startDay = day;

            endYear = date.get(YEAR);
            endMonth = date.get(MONTH);
            endDay = date.get(DAY);
       }
        else
        {
            startYear = date.get(YEAR);
            startMonth =date.get(MONTH);
            startDay = date.get(DAY);

            endYear = year;
            endMonth = month;
            endDay = day;

      }

    /* 1: in same year and same month, howManyDays = endDay - startDay
     *  2: in same year and not same month,
     *   3: not in same year and not in same month,
     */
    if ( endYear == startYear && endMonth == startMonth )
     {
        howManyDays += endDay - startDay;
     }
     else
       {

              howManyDays += monthLength(startMonth - 1, startYear) - startDay;
              howManyDays += endDay;

              if  ( endYear == startYear )
          {
              for (int iMonth = startMonth; iMonth < endMonth - 1; iMonth++)
              {
                howManyDays += monthLength(iMonth, startYear);
              }
          }

          else
           {
             for (int iYear = startYear + 1; iYear < endYear; iYear++)
               {
                  if (isLeapYear(iYear))
                      howManyDays += 366;
                   else
                      howManyDays += 365;
               }

             for (int iMonth = startMonth; iMonth < 12; iMonth++)
               {
                  howManyDays += monthLength(iMonth, startYear);
               }

             for (int iEndMonth = 1; iEndMonth < endMonth; iEndMonth++)
               {
                  howManyDays += monthLength(iEndMonth - 1, endYear);
               }
           } //end if

        }// end if

    return howManyDays;
  }

  public int  daysIn2Date()
  {
    //get now date:
    Calendar calendar = Calendar.getInstance();

    int nowYear = calendar.get(calendar.YEAR);
    int nowMonth = calendar.get(calendar.MONTH)+1;
    int nowDay = calendar.get(calendar.DAY_OF_MONTH);

    Mydate date = new Mydate (nowYear,nowMonth,nowDay);
    int howManyDays = daysIn2Date(date);

    return howManyDays;
  }
}