src/share/classes/java/time/chrono/JapaneseDate.java
Print this page
@@ -52,48 +52,63 @@
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-package java.time.calendar;
+package java.time.chrono;
import static java.time.temporal.ChronoField.DAY_OF_MONTH;
import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
import static java.time.temporal.ChronoField.YEAR;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
-import java.io.ObjectInputStream;
import java.io.Serializable;
+import java.time.Clock;
import java.time.DateTimeException;
import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.Period;
+import java.time.ZoneId;
import java.time.temporal.ChronoField;
-import java.time.temporal.ChronoLocalDate;
+import java.time.temporal.TemporalQuery;
+import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalAdjuster;
+import java.time.temporal.TemporalAmount;
import java.time.temporal.TemporalField;
+import java.time.temporal.TemporalUnit;
import java.time.temporal.ValueRange;
import java.util.Calendar;
import java.util.Objects;
import sun.util.calendar.LocalGregorianCalendar;
/**
* A date in the Japanese Imperial calendar system.
* <p>
- * This implements {@code ChronoLocalDate} for the
- * {@linkplain JapaneseChrono Japanese Imperial calendar}.
+ * This date operates using the {@linkplain JapaneseChronology Japanese Imperial calendar}.
+ * This calendar system is primarily used in Japan.
+ * <p>
+ * The Japanese Imperial calendar system is the same as the ISO calendar system
+ * apart from the era-based year numbering. The proleptic-year is defined to be
+ * equal to the ISO proleptic-year.
+ * <p>
+ * For example, the Japanese year "Heisei 24" corresponds to ISO year "2012".<br>
+ * Calling {@code japaneseDate.get(YEAR_OF_ERA)} will return 24.<br>
+ * Calling {@code japaneseDate.get(YEAR)} will return 2012.<br>
+ * Calling {@code japaneseDate.get(ERA)} will return 2, corresponding to
+ * {@code JapaneseChronology.ERA_HEISEI}.<br>
*
* <h3>Specification for implementors</h3>
* This class is immutable and thread-safe.
*
* @since 1.8
*/
-final class JapaneseDate
- extends ChronoDateImpl<JapaneseChrono>
- implements ChronoLocalDate<JapaneseChrono>, Serializable {
- // this class is package-scoped so that future conversion to public
- // would not change serialization
+public final class JapaneseDate
+ extends ChronoDateImpl<JapaneseDate>
+ implements ChronoLocalDate<JapaneseDate>, Serializable {
/**
* Serialization version.
*/
private static final long serialVersionUID = -305327627230580483L;
@@ -109,33 +124,163 @@
/**
* The Japanese imperial calendar year of this date.
*/
private transient int yearOfEra;
+ //-----------------------------------------------------------------------
+ /**
+ * Obtains the current {@code JapaneseDate} from the system clock in the default time-zone.
+ * <p>
+ * This will query the {@link Clock#systemDefaultZone() system clock} in the default
+ * time-zone to obtain the current date.
+ * <p>
+ * Using this method will prevent the ability to use an alternate clock for testing
+ * because the clock is hard-coded.
+ *
+ * @return the current date using the system clock and default time-zone, not null
+ */
+ public static JapaneseDate now() {
+ return now(Clock.systemDefaultZone());
+ }
+
+ /**
+ * Obtains the current {@code JapaneseDate} from the system clock in the specified time-zone.
+ * <p>
+ * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date.
+ * Specifying the time-zone avoids dependence on the default time-zone.
+ * <p>
+ * Using this method will prevent the ability to use an alternate clock for testing
+ * because the clock is hard-coded.
+ *
+ * @param zone the zone ID to use, not null
+ * @return the current date using the system clock, not null
+ */
+ public static JapaneseDate now(ZoneId zone) {
+ return now(Clock.system(zone));
+ }
+
/**
- * Obtains an instance of {@code JapaneseDate} from the era, year-of-era,
- * month-of-year and day-of-month.
+ * Obtains the current {@code JapaneseDate} from the specified clock.
+ * <p>
+ * This will query the specified clock to obtain the current date - today.
+ * Using this method allows the use of an alternate clock for testing.
+ * The alternate clock may be introduced using {@linkplain Clock dependency injection}.
*
- * @param era the era to represent, not null
- * @param yearOfEra the year-of-era to represent
- * @param month the month-of-year to represent
- * @param dayOfMonth the day-of-month to represent, from 1 to 31
- * @return the Japanese date, never null
- * @throws DateTimeException if the value of any field is out of range, or
- * if the day-of-month is invalid for the month-year
+ * @param clock the clock to use, not null
+ * @return the current date, not null
+ * @throws DateTimeException if the current date cannot be obtained
+ */
+ public static JapaneseDate now(Clock clock) {
+ return JapaneseChronology.INSTANCE.date(LocalDate.now(clock));
+ }
+
+ /**
+ * Obtains a {@code JapaneseDate} representing a date in the Japanese calendar
+ * system from the era, year-of-era, month-of-year and day-of-month fields.
+ * <p>
+ * This returns a {@code JapaneseDate} with the specified fields.
+ * The day must be valid for the year and month, otherwise an exception will be thrown.
+ *
+ * @param era the Japanese era, not null
+ * @param yearOfEra the Japanese year-of-era
+ * @param month the Japanese month-of-year, from 1 to 12
+ * @param dayOfMonth the Japanese day-of-month, from 1 to 31
+ * @return the date in Japanese calendar system, not null
+ * @throws DateTimeException if the value of any field is out of range,
+ * or if the day-of-month is invalid for the month-year,
+ * or if the date is not a Japanese era
+ */
+ public static JapaneseDate of(Era era, int yearOfEra, int month, int dayOfMonth) {
+ if (era instanceof JapaneseEra == false) {
+ throw new DateTimeException("Era must be JapaneseEra");
+ }
+ return JapaneseDate.of((JapaneseEra) era, yearOfEra, month, dayOfMonth);
+ }
+
+ /**
+ * Obtains a {@code JapaneseDate} representing a date in the Japanese calendar
+ * system from the proleptic-year, month-of-year and day-of-month fields.
+ * <p>
+ * This returns a {@code JapaneseDate} with the specified fields.
+ * The day must be valid for the year and month, otherwise an exception will be thrown.
+ *
+ * @param prolepticYear the Japanese proleptic-year
+ * @param month the Japanese month-of-year, from 1 to 12
+ * @param dayOfMonth the Japanese day-of-month, from 1 to 31
+ * @return the date in Japanese calendar system, not null
+ * @throws DateTimeException if the value of any field is out of range,
+ * or if the day-of-month is invalid for the month-year
+ */
+ public static JapaneseDate of(int prolepticYear, int month, int dayOfMonth) {
+ return new JapaneseDate(LocalDate.of(prolepticYear, month, dayOfMonth));
+ }
+
+ /**
+ * Obtains a {@code JapaneseDate} representing a date in the Japanese calendar
+ * system from the proleptic-year and day-of-year fields.
+ * <p>
+ * This returns a {@code JapaneseDate} with the specified fields.
+ * The day must be valid for the year, otherwise an exception will be thrown.
+ *
+ * @param prolepticYear the chronology proleptic-year
+ * @param dayOfYear the chronology day-of-year, from 1 to 366
+ * @return the date in Japanese calendar system, not null
+ * @throws DateTimeException if the value of any field is out of range,
+ * or if the day-of-year is invalid for the year
+ */
+ public static JapaneseDate ofYearDay(int prolepticYear, int dayOfYear) {
+ LocalDate date = LocalDate.ofYearDay(prolepticYear, dayOfYear);
+ return of(prolepticYear, date.getMonthValue(), date.getDayOfMonth());
+ }
+
+ /**
+ * Obtains a {@code JapaneseDate} representing a date in the Japanese calendar
+ * system from the era, year-of-era, month-of-year and day-of-month fields.
+ * <p>
+ * This returns a {@code JapaneseDate} with the specified fields.
+ * The day must be valid for the year and month, otherwise an exception will be thrown.
+ *
+ * @param era the Japanese era, not null
+ * @param yearOfEra the Japanese year-of-era
+ * @param month the Japanese month-of-year, from 1 to 12
+ * @param dayOfMonth the Japanese day-of-month, from 1 to 31
+ * @return the date in Japanese calendar system, not null
+ * @throws DateTimeException if the value of any field is out of range,
+ * or if the day-of-month is invalid for the month-year
*/
static JapaneseDate of(JapaneseEra era, int yearOfEra, int month, int dayOfMonth) {
Objects.requireNonNull(era, "era");
- LocalGregorianCalendar.Date jdate = JapaneseChrono.JCAL.newCalendarDate(null);
+ LocalGregorianCalendar.Date jdate = JapaneseChronology.JCAL.newCalendarDate(null);
jdate.setEra(era.getPrivateEra()).setDate(yearOfEra, month, dayOfMonth);
- if (!JapaneseChrono.JCAL.validate(jdate)) {
+ if (!JapaneseChronology.JCAL.validate(jdate)) {
throw new IllegalArgumentException();
}
LocalDate date = LocalDate.of(jdate.getNormalizedYear(), month, dayOfMonth);
return new JapaneseDate(era, yearOfEra, date);
}
+ /**
+ * Obtains a {@code JapaneseDate} from a temporal object.
+ * <p>
+ * This obtains a date in the Japanese calendar system based on the specified temporal.
+ * A {@code TemporalAccessor} represents an arbitrary set of date and time information,
+ * which this factory converts to an instance of {@code JapaneseDate}.
+ * <p>
+ * The conversion typically uses the {@link ChronoField#EPOCH_DAY EPOCH_DAY}
+ * field, which is standardized across calendar systems.
+ * <p>
+ * This method matches the signature of the functional interface {@link TemporalQuery}
+ * allowing it to be used as a query via method reference, {@code JapaneseDate::from}.
+ *
+ * @param temporal the temporal object to convert, not null
+ * @return the date in Japanese calendar system, not null
+ * @throws DateTimeException if unable to convert to a {@code JapaneseDate}
+ */
+ public static JapaneseDate from(TemporalAccessor temporal) {
+ return JapaneseChronology.INSTANCE.date(temporal);
+ }
+
//-----------------------------------------------------------------------
/**
* Creates an instance from an ISO date.
*
* @param isoDate the standard local date, validated not null
@@ -161,12 +306,12 @@
this.isoDate = isoDate;
}
//-----------------------------------------------------------------------
@Override
- public JapaneseChrono getChrono() {
- return JapaneseChrono.INSTANCE;
+ public JapaneseChronology getChronology() {
+ return JapaneseChronology.INSTANCE;
}
@Override
public int lengthOfMonth() {
return isoDate.lengthOfMonth();
@@ -181,19 +326,19 @@
case DAY_OF_YEAR:
return actualRange(Calendar.DAY_OF_YEAR);
case YEAR_OF_ERA:
return actualRange(Calendar.YEAR);
}
- return getChrono().range(f);
+ return getChronology().range(f);
}
throw new DateTimeException("Unsupported field: " + field.getName());
}
- return field.doRange(this);
+ return field.rangeRefinedBy(this);
}
private ValueRange actualRange(int calendarField) {
- Calendar jcal = Calendar.getInstance(JapaneseChrono.LOCALE);
+ Calendar jcal = Calendar.getInstance(JapaneseChronology.LOCALE);
jcal.set(Calendar.ERA, era.getValue() + JapaneseEra.ERA_OFFSET);
jcal.set(yearOfEra, isoDate.getMonthValue() - 1, isoDate.getDayOfMonth());
return ValueRange.of(jcal.getActualMinimum(calendarField),
jcal.getActualMaximum(calendarField));
}
@@ -206,34 +351,34 @@
return yearOfEra;
case ERA:
return era.getValue();
case DAY_OF_YEAR: {
LocalGregorianCalendar.Date jdate = toPrivateJapaneseDate(isoDate);
- return JapaneseChrono.JCAL.getDayOfYear(jdate);
+ return JapaneseChronology.JCAL.getDayOfYear(jdate);
}
}
// TODO: review other fields
return isoDate.getLong(field);
}
- return field.doGet(this);
+ return field.getFrom(this);
}
/**
* Returns a {@code LocalGregorianCalendar.Date} converted from the given {@code isoDate}.
*
* @param isoDate the local date, not null
* @return a {@code LocalGregorianCalendar.Date}, not null
*/
private static LocalGregorianCalendar.Date toPrivateJapaneseDate(LocalDate isoDate) {
- LocalGregorianCalendar.Date jdate = JapaneseChrono.JCAL.newCalendarDate(null);
+ LocalGregorianCalendar.Date jdate = JapaneseChronology.JCAL.newCalendarDate(null);
sun.util.calendar.Era sunEra = JapaneseEra.privateEraFrom(isoDate);
int year = isoDate.getYear();
if (sunEra != null) {
year -= sunEra.getSinceDate().getYear() - 1;
}
jdate.setEra(sunEra).setYear(year).setMonth(isoDate.getMonthValue()).setDayOfMonth(isoDate.getDayOfMonth());
- JapaneseChrono.JCAL.normalize(jdate);
+ JapaneseChronology.JCAL.normalize(jdate);
return jdate;
}
//-----------------------------------------------------------------------
@Override
@@ -264,10 +409,44 @@
return with(isoDate.with(field, newValue));
}
return (JapaneseDate) ChronoLocalDate.super.with(field, newValue);
}
+ @Override
+ public Era getEra() {
+ return era;
+ }
+
+ /**
+ * {@inheritDoc}
+ * @throws DateTimeException {@inheritDoc}
+ * @throws ArithmeticException {@inheritDoc}
+ */
+ @Override
+ public JapaneseDate with(TemporalAdjuster adjuster) {
+ return (JapaneseDate)super.with(adjuster);
+ }
+
+ /**
+ * {@inheritDoc}
+ * @throws DateTimeException {@inheritDoc}
+ * @throws ArithmeticException {@inheritDoc}
+ */
+ @Override
+ public JapaneseDate plus(TemporalAmount amount) {
+ return (JapaneseDate)super.plus(amount);
+ }
+
+ /**
+ * {@inheritDoc}
+ * @throws DateTimeException {@inheritDoc}
+ * @throws ArithmeticException {@inheritDoc}
+ */
+ @Override
+ public JapaneseDate minus(TemporalAmount amount) {
+ return (JapaneseDate)super.minus(amount);
+ }
//-----------------------------------------------------------------------
/**
* Returns a copy of this date with the year altered.
* <p>
* This method changes the year of the date.
@@ -280,11 +459,11 @@
* @param yearOfEra the year-of-era to set in the returned date
* @return a {@code JapaneseDate} based on this date with the requested year, never null
* @throws DateTimeException if {@code year} is invalid
*/
private JapaneseDate withYear(JapaneseEra era, int yearOfEra) {
- int year = JapaneseChrono.INSTANCE.prolepticYear(era, yearOfEra);
+ int year = JapaneseChronology.INSTANCE.prolepticYear(era, yearOfEra);
return with(isoDate.withYear(year));
}
/**
* Returns a copy of this date with the year-of-era altered.
@@ -313,18 +492,63 @@
JapaneseDate plusMonths(long months) {
return with(isoDate.plusMonths(months));
}
@Override
+ JapaneseDate plusWeeks(long weeksToAdd) {
+ return with(isoDate.plusWeeks(weeksToAdd));
+ }
+
+ @Override
JapaneseDate plusDays(long days) {
return with(isoDate.plusDays(days));
}
+ @Override
+ public JapaneseDate plus(long amountToAdd, TemporalUnit unit) {
+ return (JapaneseDate)super.plus(amountToAdd, unit);
+ }
+
+ @Override
+ public JapaneseDate minus(long amountToAdd, TemporalUnit unit) {
+ return (JapaneseDate)super.minus(amountToAdd, unit);
+ }
+
+ @Override
+ JapaneseDate minusYears(long yearsToSubtract) {
+ return (JapaneseDate)super.minusYears(yearsToSubtract);
+ }
+
+ @Override
+ JapaneseDate minusMonths(long monthsToSubtract) {
+ return (JapaneseDate)super.minusMonths(monthsToSubtract);
+ }
+
+ @Override
+ JapaneseDate minusWeeks(long weeksToSubtract) {
+ return (JapaneseDate)super.minusWeeks(weeksToSubtract);
+ }
+
+ @Override
+ JapaneseDate minusDays(long daysToSubtract) {
+ return (JapaneseDate)super.minusDays(daysToSubtract);
+ }
+
private JapaneseDate with(LocalDate newDate) {
return (newDate.equals(isoDate) ? this : new JapaneseDate(newDate));
}
+ @Override // for javadoc and covariant return type
+ public final ChronoLocalDateTime<JapaneseDate> atTime(LocalTime localTime) {
+ return (ChronoLocalDateTime<JapaneseDate>)super.atTime(localTime);
+ }
+
+ @Override
+ public Period periodUntil(ChronoLocalDate<?> endDate) {
+ return isoDate.periodUntil(endDate);
+ }
+
@Override // override for performance
public long toEpochDay() {
return isoDate.toEpochDay();
}
@@ -341,37 +565,36 @@
return false;
}
@Override // override for performance
public int hashCode() {
- return getChrono().getId().hashCode() ^ isoDate.hashCode();
+ return getChronology().getId().hashCode() ^ isoDate.hashCode();
}
@Override
public String toString() {
if (era == JapaneseEra.SEIREKI) {
- return getChrono().getId() + " " + isoDate.toString();
+ return getChronology().getId() + " " + isoDate.toString();
}
return super.toString();
}
//-----------------------------------------------------------------------
private Object writeReplace() {
return new Ser(Ser.JAPANESE_DATE_TYPE, this);
}
void writeExternal(DataOutput out) throws IOException {
- // JapaneseChrono is implicit in the JAPANESE_DATE_TYPE
+ // JapaneseChronology is implicit in the JAPANESE_DATE_TYPE
out.writeInt(get(YEAR));
out.writeByte(get(MONTH_OF_YEAR));
out.writeByte(get(DAY_OF_MONTH));
}
- static ChronoLocalDate<JapaneseChrono> readExternal(DataInput in) throws IOException {
+ static JapaneseDate readExternal(DataInput in) throws IOException {
int year = in.readInt();
int month = in.readByte();
int dayOfMonth = in.readByte();
- return JapaneseChrono.INSTANCE.date(year, month, dayOfMonth);
+ return JapaneseChronology.INSTANCE.date(year, month, dayOfMonth);
}
-
}