I made a new Date object

Question

See, here's the thing with dates in java, the way i see it. We used to have Date, but Date wasn't international so we got Calendar. But some things, like SimpleDateFormat, still expect java.util.Date. java.sql.Date is out there somewhere, too. None of them have direct support for date differences (i.e. dateA - dateB = 8 days, or whatever). Now you're probably reading this thinking "Java supports all of this" and you're right. Calendar has a getTime method that returns a Date, and i can just pass THAT to SimpleDateFormat. With a little math, getTimeInMillis can be used to find the difference in two Calendars. But i got to thinking, "There should only be one Date object i need to think about," and since i don't ever have enough to do at work i put one together. I don't know if any of you are going to care enough to use it, mostly i'm just looking for advice on features i should add to it, inefficiencies in the design, stuff that's hard to understand, or whatever.
This is it:
*This catastrophe brought to you by SrA Meyerin.
*Proximo Satis pro administatio.
package awesomedate;
//The following are imported for the toFormattedString(), toUtilDate(), toSQLDate, and toCalendar() methods, respectively.
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.GregorianCalendar;
import java.sql.*;
import java.util.TimeZone;
*This class is designed to be the ultimate date object. It stores dates accurate to the millisecond, has the ability to do date
*arithmetic (adding/subtracting days/months/whatever), date comparison, and date formatting. Also it can, at will, be used as any
*of the other date objects in the standard java API.
public class AwesomeDate
     *Milliseconds from the epoch. This field is where everything starts.
    private long millis;
     * The current year. This is the only aspect of the current date that is stored in addition to the milliseconds. Everything else
     * is calculated as needed.
    private int year;
    //The following six variables are fairly self explanatory. I'll explain them anyway.
     *Milliseconds in one non-leap year. This can be passed to the "adjustDate()" method
     * but mostly it is used to make my code more readable.
    public final static long MILLIS_IN_YEAR = 31536000000L;
     *Milliseconds in one leap year. This can be passed to the "adjustDate()" method
     * but mostly it is used to make my code more readable.
    public static final long MILLIS_IN_LEAP_YEAR = 31622400000L;
     *Milliseconds in one day. This can be passed to the "adjustDate()" method
     * but mostly it is used to make my code more readable.
    public static final long MILLIS_IN_DAY = 86400000;
     *Milliseconds in one hour. This can be passed to the "adjustDate()" method
     * but mostly it is used to make my code more readable.
    public static final long MILLIS_IN_HOUR = 3600000;
     *Milliseconds in one minute. This can be passed to the "adjustDate()" method
     * but mostly it is used to make my code more readable.
    public static final long MILLIS_IN_MINUTE = 60000;
     *Milliseconds in one second. This can be passed to the "adjustDate()" method
     * but mostly it is used to make my code more readable.
    public static final long MILLIS_IN_SECOND = 1000;
     *The number of days in each month.
    private int[] daysInMonth = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
     *The timezone offset. GMT is 0, and the default, however, CST (where i live), is -6.
    private int timeZoneOffset = -6;
     *As the name would indicate, this is the number of milliseconds beyond 00:00 of jan 1 of the current year.
    private long millisAfterYear;
     *Basic constructor. Defaults to the current date and time. Works on Greenwich Mean Time, so it may seem off. To avoid this, multiply
     *add your time zone offset * MILLIS_IN_HOUR to the time in milliseconds.
    public AwesomeDate()
        setTimeInMillis(System.currentTimeMillis());
     *Fairly simple constructor. Sets time to the the number of milliseconds passed past the epoch.
    public AwesomeDate(long millis)
        setTimeInMillis(millis);
     *This constructor sets the date to the year/month/day passed.
    public AwesomeDate(int year, int month, int day)
        setDate(year, month, day);
     *This constructor sets the date time to the year/month/day/minute/hour/second passed.
    public AwesomeDate(int year, int month, int day, int hour, int minute, int second)
        setDate(year, month, day, hour, minute, second);
     *When you have the number of milliseconds, the first thing you must calculate is year. Because the number of milliseconds in a
     *year may vary, this is also the most difficult to calculate. This is the method that does it, though.
    private void setYearAfter1970()
        //I don't want to alter the actual number of milliseconds, so i make this variable and perform calculations on it.
        long theseMillis = this.millis;
        //Start at 1970 (the epoch) and work from there.
        year = 1970;
        long nextYear = MILLIS_IN_YEAR;
        //In this loop i subtract the number of millis in whatever year. The condition is if i have enough millis to make it through
            //another year.
        while (theseMillis >= nextYear)
            if (isLeapYear(year))
                theseMillis = theseMillis - MILLIS_IN_LEAP_YEAR;
                nextYear = MILLIS_IN_YEAR;
            else
                theseMillis = theseMillis - MILLIS_IN_YEAR;
                if (isLeapYear(year + 1))
                    nextYear = MILLIS_IN_LEAP_YEAR;
            year++;
        millisAfterYear = theseMillis;
        this.year = year;
     *Calculating the year from before 1970 must be done differently. It's pretty much just inverted.
    private void setYearBefore1970()
        long theseMillis = this.millis;
        year = 1970;
        long nextYear = MILLIS_IN_YEAR;
        while (theseMillis <= 0)
            if (isLeapYear(year))
                theseMillis = theseMillis + MILLIS_IN_LEAP_YEAR;
                nextYear = MILLIS_IN_YEAR;
            else
                theseMillis = theseMillis + MILLIS_IN_YEAR;
                if (isLeapYear(year - 1))
                    nextYear = MILLIS_IN_LEAP_YEAR;
            year--;
        millisAfterYear = theseMillis * -1;
        this.year = year;
     *Just what it sounds like. Pass it the number of milliseconds past the epoch and it will calculate the date based on that.
    public void setTimeInMillis(long millis)
        this.millis = millis;
        if (millis >= 0)
            setYearAfter1970();
        else
            setYearBefore1970();
     *Returns the number of milliseconds from the epoch.
    public long getTimeInMillis()
        return this.millis;
     *Returns the current year.
    public int getYear()
        return this.year;
     *Sets the date to 00:00 of Jan 1 of the passed year.
    public void setYear(int year)
        this.year = year;
        long theseMillis = 0;
        if (year > 1970)
            //Kind of like setYearAfter1970 method, except it's adding instead of subtracting. So actually it's the opposite.
            for (int cntr = 1970; cntr < this.year; cntr++)
                if (isLeapYear(cntr))
                    theseMillis = theseMillis + MILLIS_IN_LEAP_YEAR;
                else
                    theseMillis = theseMillis + MILLIS_IN_YEAR;
        else
            for (int cntr = 1970; cntr > this.year; cntr--)
                if (isLeapYear(cntr))
                    theseMillis = theseMillis - MILLIS_IN_LEAP_YEAR;
                else
                    theseMillis = theseMillis - MILLIS_IN_YEAR;
        //On a leap year there are 29 days in February. If not, there's 28.
        if (isLeapYear(year))
            daysInMonth[1] = 29;
        else
            daysInMonth[1] = 28;
        //This variable helps me calculate denominations of time that are below year.
        millisAfterYear = 0;
        setTimeInMillis(theseMillis);
     *Sets the month to the one that you passed, 0 being January and 11 being December.
    public void setMonth(int month)
        if (month < 0 || month > 11)
            throw new ArrayIndexOutOfBoundsException(month);
        long theseMillis = getTimeInMillis();
        int days = 0;
        setYear(this.year);
        if (getTimeInMillis() > 0)
            theseMillis = theseMillis - getTimeInMillis();
        else
            theseMillis = theseMillis + getTimeInMillis();
        for (int cntr = 0; cntr < month; cntr++)
            days = days + daysInMonth[cntr];
        millisAfterYear = days * MILLIS_IN_DAY + 1;
        setTimeInMillis(getTimeInMillis() + millisAfterYear);
     *Returns the month stored in this object. With this object 0 represents January and 11 represents December.
    public int getMonth()
        long theseMillis = millisAfterYear;
        int cntr = 0;
        while (theseMillis > (MILLIS_IN_DAY * daysInMonth[cntr]))
            theseMillis = theseMillis - MILLIS_IN_DAY * daysInMonth[cntr];
            cntr++;
        return cntr;
     *Set the day of month to the one passed.
    public void setDayOfMonth(int day)
        if (day < 1 || day > daysInMonth[getMonth()])
            throw new ArrayIndexOutOfBoundsException(day);
        setMonth(getMonth());
        //Internally, this actually works starting at zero, however to anyone using this class it appears to start at 1. Therefore
            //i must subtract one here.
        long addMillis = MILLIS_IN_DAY * (day - 1);
        millisAfterYear = millisAfterYear + addMillis;
        setTimeInMillis(getTimeInMillis() + addMillis + 1);
     *Returns the day of month.
    public int getDayOfMonth()
        int days = (int)(millisAfterYear / MILLIS_IN_DAY);
        int cntr = 0;
        while (days >= daysInMonth[cntr])
            days = days - daysInMonth[cntr];
            cntr++;
        //Internally this class stores dates starting at zero, but i want it to look like it starts at 1.
        return days + 1;
     *Sets the time to the currently selected day at the passed hour on the hour. uses 24 hour clock.
    public void setHour(int hour)
        if (hour < 0 || hour > 23)
            throw new ArrayIndexOutOfBoundsException(hour);
        setDayOfMonth(getDayOfMonth());
        long addMillis = MILLIS_IN_HOUR * hour;
        millisAfterYear = millisAfterYear + addMillis;
        setTimeInMillis(getTimeInMillis() + addMillis);
     *Returns the hour (but not how many minutes past the hour).
    public int getHour()
        long millisAfterDay = millisAfterYear % MILLIS_IN_DAY;
        return (int)(millisAfterDay / MILLIS_IN_HOUR);
     *Set the minutes past the hour. Works 0-59.
    public void setMinute(int minute)
        if (minute < 0 || minute > 59)
            throw new ArrayIndexOutOfBoundsException(minute);
        setHour(getHour());
        long addMillis = MILLIS_IN_MINUTE * minute;
        millisAfterYear = millisAfterYear + addMillis;
        setTimeInMillis(getTimeInMillis() + addMillis);
     *Returns the minutes past the hour, 0-59.
    public int getMinute()
        long millisAfterHour = millisAfterYear % MILLIS_IN_HOUR;
        return (int)(millisAfterHour / MILLIS_IN_MINUTE);
     *Sets the seconds past the minute, 0-59.
    public void setSecond(int second)
        if (second < 0 || second > 59)
            throw new ArrayIndexOutOfBoundsException(second);
        setMinute(getMinute());
        long addMillis = MILLIS_IN_SECOND * second;
        millisAfterYear = millisAfterYear + addMillis;
        setTimeInMillis(getTimeInMillis() + addMillis);
     *Returns the seconds past the minute, 0-59.
    public int getSecond()
        long millisAfterMinute = millisAfterYear % MILLIS_IN_MINUTE;
        return (int)(millisAfterMinute / MILLIS_IN_SECOND);
     *The more commonly seen set method of other date objects. Sets the date/time to 00:00 of the year/month/day passed. Convenience method
     *for setDate(int year, int month, int day, int hour, int minute, int second).
    public void setDate(int year, int month, int day)
        setDate(year, month, day, 0 , 0 , 0);
     *Sets every date/time field.
    public void setDate(int year, int month, int day, int hour, int minute, int second)
        setYear(year);
        setMonth(month);
        setDayOfMonth(day);
        setHour(hour);
        setMinute(minute);
        setSecond(second);
     *Returns yes if the stored date is a leap year. A leap year is every year that is divisible by four unless it is divisible by 100
     *unless it is also divisible by 400.
    public boolean isLeapYear()
        return isLeapYear(this.year);
     *For internal use. Returns if the passed year meets the criteria for a leap year.
    private boolean isLeapYear(int year)
        boolean leapYear = false;
        if (year % 4 == 0)
            if (year % 100 != 0)
                leapYear = true;
            else if (year % 400 == 0)
                leapYear = true;
        return leapYear;
     *Returns the difference in milliseconds between the time stored in this object and the millis passed to this method.
    public long getDifferenceInMillis(long millis)
        return getTimeInMillis() - millis;
     *Returns the difference in milliseconds between this date and the date passed to this method.
    public long getDifferenceInMillis(AwesomeDate otherDate)
        return getDifferenceInMillis(otherDate.getTimeInMillis());
     *Designed to be a wrapper method for the getDifferenceInMillis method. This method changes millis into years/days/whatever. Pass
     *the number of milliseconds you have to convert in the first parameter. The second parameter should be the type of denomination you
     *want (year, day, whatever). Use the MILLIS_IN_* fields associated with this object. Also bear in mind when workin with years that
     *some years are leap years, so in extreme cases of differences of 365+ years you may gain/lose a year.
    public static int toGreaterDenom(long millis, long denom)
        return (int)(millis / denom);
     * The first argument is how many of whatever (days, months, years, etc.) to add (use negative numbers to subtract). For the second
     * argument pass one of the MILLIS_IN_* fields. Thus, to add two hours would be
     * <code>
     *      AwesomeDate.adjustDate(2, AwesomeDate.MILLIS_IN_HOUR);
     * </code>
    public void adjustDate(int amount, long typeMillis)
        setTimeInMillis(this.millis + amount * typeMillis);
     *Returns an object of type java.util.Date set to the date/time stored here.
    public java.util.Date toUtilDate()
        long offset = TimeZone.getDefault().getRawOffset();
        return new java.util.Date(getTimeInMillis() +  -1 * offset);
//        return new java.util.Date(getTimeInMillis());
     *Returns an object of type GregorianCalendar set to the date/time stored here.
    public GregorianCalendar toGregorianCalendar()
        long offset = TimeZone.getDefault().getRawOffset();
        GregorianCalendar cal = new GregorianCalendar();
        cal.setTimeInMillis(getTimeInMillis() - offset);
        return cal;
     *Returns an object of type java.sql.Date set to the date/time stored here.
    public java.sql.Date toSQLDate()
        long offset = TimeZone.getDefault().getRawOffset();
        return new java.sql.Date(getTimeInMillis() - offset);
    /** Format the date  using the string that you pass. Works just like the SimpleDateFormat object. Infact, it uses one! Heres
     *how it works:
     *Letter  Date or Time Component  Presentation  Examples  <br>
     *G  Era designator  Text  AD  <br>
     *y  Year  Year  1996; 96  <br>
     *M  Month in year  Month  July; Jul; 07<br> 
     *w  Week in year  Number  27  <br>
     *W  Week in month  Number  2  <br>
     *D  Day in year  Number  189  <br>
     *d  Day in month  Number  10  <br>
     *F  Day of week in month  Number  2<br> 
     *E  Day in week  Text  Tuesday; Tue  <br>
     *a  Am/pm marker  Text  PM  <br>
     *H  Hour in day (0-23)  Number  0<br> 
     *k  Hour in day (1-24)  Number  24  <br>
     *K  Hour in am/pm (0-11)  Number  0  <br>
     *h  Hour in am/pm (1-12)  Number  12  <br>
     *m  Minute in hour  Number  30  <br>
     *s  Second in minute  Number  55  <br>
     *S  Millisecond  Number  978  <br>
     *z  Time zone  General time zone  Pacific Standard Time; PST; GMT-08:00<br> 
     *Z  Time zone  RFC 822 time zone  -0800  <br>
    public String toFormattedString(String format)
        SimpleDateFormat formattage = new SimpleDateFormat(format);
        return formattage.format(toUtilDate());
     *I overrode the toString method. Now it tells everyone how awesome my AwesomeDate is.
    public String toString()
        String output = "John's Awesome Date!";
        output = output + " Millis: " + getTimeInMillis();
        output = output + " Year: " + getYear();
        output = output + " Month: " + getMonth();
        output = output + " Date: " + getDayOfMonth();
        output = output + " Time: ";
        if (getHour() < 10)
            output = output + "0" + getHour();
        else
            output = output + getHour();
        if (getMinute() < 10)
            output = output + "0" + getMinute();
        else
            output = output + getMinute();
        output = output + " Seconds: " + getSecond();
        return output;
    public static void main(String[] psvm)
        AwesomeDate blah = new AwesomeDate();
        GregorianCalendar blah1 = new GregorianCalendar();
        GregorianCalendar blah2 = new GregorianCalendar();
}

Answer 1

The reason Callendar is so complicated is that it is trying to solve a very complicated problem.
You don't appear to support leap seconds (of which there can be upto 2 in any time interval)
http://www.timeanddate.com/time/leapseconds.html
Some of your code will not work for large dates very well (seems to iterate over the years). Try using your date class for astronomical or geological calculations. them big numbers will make your code slow at the moment.
You don't seem to support timezones or transitory offsets (BST vs GMT). You most definately don't handle changes to timezone offsets that have occured in the past or historical daylight savings time offsets (they have not always been the same)
The difference between two calendars is a "duration" a duration means nothing unless it is applied to a caledar/date (although you may be able to get away with it if the duration is always stored in millis)