jdk-sandbox: comparison jdk/src/share/classes/java/time/LocalDate.java

equal deleted inserted replaced

-:91f5e4399160
+:da9a41004459
 *
 * @param year  the year to represent, from MIN_YEAR to MAX_YEAR
 * @param dayOfYear  the day-of-year to represent, from 1 to 366
 * @return the local date, not null
 * @throws DateTimeException if the value of any field is out of range,
-*  or if the day-of-year is invalid for the month-year
+*  or if the day-of-year is invalid for the year
 */
 public static LocalDate ofYearDay(int year, int dayOfYear) {
 YEAR.checkValidValue(year);
 DAY_OF_YEAR.checkValidValue(dayOfYear);
 boolean leap = IsoChronology.INSTANCE.isLeapYear(year);
 * The {@link ChronoField#EPOCH_DAY EPOCH_DAY} is a simple incrementing count
 * of days where day 0 is 1970-01-01. Negative numbers represent earlier days.
 *
 * @param epochDay  the Epoch Day to convert, based on the epoch 1970-01-01
 * @return the local date, not null
-* @throws DateTimeException if the epoch days exceeds the supported date range
+* @throws DateTimeException if the epoch day exceeds the supported date range
 */
 public static LocalDate ofEpochDay(long epochDay) {
 long zeroDay = epochDay + DAYS_0000_TO_1970;
 // find the march-based year
 zeroDay -= 60;  // adjust to 0000-03-01 so leap day is at end of four year cycle
 }
 /**
 * Checks if the specified unit is supported.
 * <p>
-* This checks if the specified unit can be added to, or subtracted from, this date-time.
+* This checks if the specified unit can be added to, or subtracted from, this date.
 * If false, then calling the {@link #plus(long, TemporalUnit)} and
 * {@link #minus(long, TemporalUnit) minus} methods will throw an exception.
 * <p>
 * If the unit is a {@link ChronoUnit} then the query is implemented here.
 * The supported units are:
 }
 /**
 * Gets the value of the specified field from this date as an {@code int}.
 * <p>
-* This queries this date for the value for the specified field.
+* This queries this date for the value of the specified field.
 * The returned value will always be within the valid range of values for the field.
 * If it is not possible to return the value, because the field is not supported
 * or for some other reason, an exception is thrown.
 * <p>
 * If the field is a {@link ChronoField} then the query is implemented here.
 * The {@link #isSupported(TemporalField) supported fields} will return valid
 * values based on this date, except {@code EPOCH_DAY} and {@code PROLEPTIC_MONTH}
-* which are too large to fit in an {@code int} and throw a {@code DateTimeException}.
+* which are too large to fit in an {@code int} and throw an {@code UnsupportedTemporalTypeException}.
 * All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
 * <p>
 * If the field is not a {@code ChronoField}, then the result of this method
 * is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}
 * passing {@code this} as the argument. Whether the value can be obtained,
 }
 /**
 * Gets the value of the specified field from this date as a {@code long}.
 * <p>
-* This queries this date for the value for the specified field.
+* This queries this date for the value of the specified field.
 * If it is not possible to return the value, because the field is not supported
 * or for some other reason, an exception is thrown.
 * <p>
 * If the field is a {@link ChronoField} then the query is implemented here.
 * The {@link #isSupported(TemporalField) supported fields} will return valid
 * The adjustment takes place using the specified adjuster strategy object.
 * Read the documentation of the adjuster to understand what adjustment will be made.
 * <p>
 * A simple adjuster might simply set the one of the fields, such as the year field.
 * A more complex adjuster might set the date to the last day of the month.
-* A selection of common adjustments is provided in {@link TemporalAdjuster}.
+* <p>
+* A selection of common adjustments is provided in
+* {@link java.time.temporal.TemporalAdjusters TemporalAdjusters}.
 * These include finding the "last day of the month" and "next Wednesday".
 * Key date-time classes also implement the {@code TemporalAdjuster} interface,
 * such as {@link Month} and {@link java.time.MonthDay MonthDay}.
 * The adjuster is responsible for handling special cases, such as the varying
 * lengths of month and leap years.
 * <p>
 * For example this code returns a date on the last day of July:
 * <pre>
 *  import static java.time.Month.*;
-*  import static java.time.temporal.Adjusters.*;
+*  import static java.time.temporal.TemporalAdjusters.*;
 *
 *  result = localDate.with(JULY).with(lastDayOfMonth());
 * </pre>
 * <p>
 * The result of this method is obtained by invoking the
 return field.adjustInto(this, newValue);
 }
 //-----------------------------------------------------------------------
 /**
-* Returns a copy of this date with the year altered.
+* Returns a copy of this {@code LocalDate} with the year altered.
+* <p>
 * If the day-of-month is invalid for the year, it will be changed to the last valid day of the month.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param year  the year to set in the result, from MIN_YEAR to MAX_YEAR
 YEAR.checkValidValue(year);
 return resolvePreviousValid(year, month, day);
 }
 /**
-* Returns a copy of this date with the month-of-year altered.
+* Returns a copy of this {@code LocalDate} with the month-of-year altered.
+* <p>
 * If the day-of-month is invalid for the year, it will be changed to the last valid day of the month.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param month  the month-of-year to set in the result, from 1 (January) to 12 (December)
 MONTH_OF_YEAR.checkValidValue(month);
 return resolvePreviousValid(year, month, day);
 }
 /**
-* Returns a copy of this date with the day-of-month altered.
+* Returns a copy of this {@code LocalDate} with the day-of-month altered.
+* <p>
 * If the resulting date is invalid, an exception is thrown.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param dayOfMonth  the day-of-month to set in the result, from 1 to 28-31
 }
 return of(year, month, dayOfMonth);
 }
 /**
-* Returns a copy of this date with the day-of-year altered.
+* Returns a copy of this {@code LocalDate} with the day-of-year altered.
+* <p>
 * If the resulting date is invalid, an exception is thrown.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param dayOfYear  the day-of-year to set in the result, from 1 to 365-366
 return unit.addTo(this, amountToAdd);
 }
 //-----------------------------------------------------------------------
 /**
-* Returns a copy of this {@code LocalDate} with the specified period in years added.
+* Returns a copy of this {@code LocalDate} with the specified number of years added.
 * <p>
 * This method adds the specified amount to the years field in three steps:
 * <ol>
 * <li>Add the input years to the year field</li>
 * <li>Check if the resulting date would be invalid</li>
 int newYear = YEAR.checkValidIntValue(year + yearsToAdd);  // safe overflow
 return resolvePreviousValid(newYear, month, day);
 }
 /**
-* Returns a copy of this {@code LocalDate} with the specified period in months added.
+* Returns a copy of this {@code LocalDate} with the specified number of months added.
 * <p>
 * This method adds the specified amount to the months field in three steps:
 * <ol>
 * <li>Add the input months to the month-of-year field</li>
 * <li>Check if the resulting date would be invalid</li>
 int newMonth = (int)Math.floorMod(calcMonths, 12) + 1;
 return resolvePreviousValid(newYear, newMonth, day);
 }
 /**
-* Returns a copy of this {@code LocalDate} with the specified period in weeks added.
+* Returns a copy of this {@code LocalDate} with the specified number of weeks added.
 * <p>
 * This method adds the specified amount in weeks to the days field incrementing
 * the month and year fields as necessary to ensure the result remains valid.
 * The result is only invalid if the maximum/minimum year is exceeded.
 * <p>
 return (amountToSubtract == Long.MIN_VALUE ? plus(Long.MAX_VALUE, unit).plus(1, unit) : plus(-amountToSubtract, unit));
 }
 //-----------------------------------------------------------------------
 /**
-* Returns a copy of this {@code LocalDate} with the specified period in years subtracted.
+* Returns a copy of this {@code LocalDate} with the specified number of years subtracted.
 * <p>
 * This method subtracts the specified amount from the years field in three steps:
 * <ol>
-* <li>Subtract the input years to the year field</li>
+* <li>Subtract the input years from the year field</li>
 * <li>Check if the resulting date would be invalid</li>
 * <li>Adjust the day-of-month to the last valid day if necessary</li>
 * </ol>
 * <p>
 * For example, 2008-02-29 (leap year) minus one year would result in the
 public LocalDate minusYears(long yearsToSubtract) {
 return (yearsToSubtract == Long.MIN_VALUE ? plusYears(Long.MAX_VALUE).plusYears(1) : plusYears(-yearsToSubtract));
 }
 /**
-* Returns a copy of this {@code LocalDate} with the specified period in months subtracted.
+* Returns a copy of this {@code LocalDate} with the specified number of months subtracted.
 * <p>
 * This method subtracts the specified amount from the months field in three steps:
 * <ol>
-* <li>Subtract the input months to the month-of-year field</li>
+* <li>Subtract the input months from the month-of-year field</li>
 * <li>Check if the resulting date would be invalid</li>
 * <li>Adjust the day-of-month to the last valid day if necessary</li>
 * </ol>
 * <p>
 * For example, 2007-03-31 minus one month would result in the invalid date
 public LocalDate minusMonths(long monthsToSubtract) {
 return (monthsToSubtract == Long.MIN_VALUE ? plusMonths(Long.MAX_VALUE).plusMonths(1) : plusMonths(-monthsToSubtract));
 }
 /**
-* Returns a copy of this {@code LocalDate} with the specified period in weeks subtracted.
+* Returns a copy of this {@code LocalDate} with the specified number of weeks subtracted.
 * <p>
 * This method subtracts the specified amount in weeks from the days field decrementing
 * the month and year fields as necessary to ensure the result remains valid.
 * The result is only invalid if the maximum/minimum year is exceeded.
 * <p>

changeset 24256	da9a41004459
parent 22566	4ebe53dd7814