public final Class JapaneseDate

public int hashCode()

Overrides java.time.chrono.ChronoLocalDateImpl.hashCode.

Implements java.time.chrono.ChronoLocalDate.hashCode.

A hash code for this date.

Returns:int

a suitable hash code based only on the Chronology and the date

Annotations

@Override

isSupported back to summary

isSupported	back to summary
public boolean isSupported(TemporalField field) Overrides default java.time.chrono.ChronoLocalDate.isSupported. Implements java.time.temporal.TemporalAccessor.isSupported. Checks if the specified field is supported. This checks if this date can be queried for the specified field. If false, then calling the `range` and `get` methods will throw an exception. If the field is a `ChronoField` then the query is implemented here. The supported fields are: `DAY_OF_WEEK` `DAY_OF_MONTH` `DAY_OF_YEAR` `EPOCH_DAY` `MONTH_OF_YEAR` `PROLEPTIC_MONTH` `YEAR_OF_ERA` `YEAR` `ERA` All other `ChronoField` instances will return false. If the field is not a `ChronoField`, then the result of this method is obtained by invoking `TemporalField.isSupportedBy(TemporalAccessor)` passing `this` as the argument. Whether the field is supported is determined by the field. Parameters field:TemporalField the field to check, null returns false Returns:boolean true if the field is supported on this date, false if not Annotations @Override

public boolean isSupported(TemporalField field)

Overrides default java.time.chrono.ChronoLocalDate.isSupported.

Implements java.time.temporal.TemporalAccessor.isSupported.

Checks if the specified field is supported.

This checks if this date can be queried for the specified field. If false, then calling the range and get methods will throw an exception.

If the field is a ChronoField then the query is implemented here. The supported fields are:

DAY_OF_WEEK
DAY_OF_MONTH
DAY_OF_YEAR
EPOCH_DAY
MONTH_OF_YEAR
PROLEPTIC_MONTH
YEAR_OF_ERA
YEAR
ERA

All other ChronoField instances will return false.

If the field is not a ChronoField, then the result of this method is obtained by invoking TemporalField.isSupportedBy(TemporalAccessor) passing this as the argument. Whether the field is supported is determined by the field.

Parameters

field:TemporalField: the field to check, null returns false

Returns:boolean

true if the field is supported on this date, false if not

Annotations

@Override

lengthOfMonth	back to summary
public int lengthOfMonth() Implements java.time.chrono.ChronoLocalDate.lengthOfMonth. Returns the length of the month represented by this date. This returns the length of the month in days. Month lengths match those of the ISO calendar system. Returns:int the length of the month in days Annotations @Override

lengthOfMonth

public int lengthOfMonth()

Implements java.time.chrono.ChronoLocalDate.lengthOfMonth.

Returns the length of the month represented by this date.

This returns the length of the month in days. Month lengths match those of the ISO calendar system.

Returns:int

the length of the month in days

Annotations

@Override

lengthOfYear back to summary

lengthOfYear	back to summary
public int lengthOfYear() Overrides default java.time.chrono.ChronoLocalDate.lengthOfYear. Doc from java.time.chrono.ChronoLocalDate.lengthOfYear. Returns the length of the year represented by this date, as defined by the calendar system. This returns the length of the year in days. The default implementation uses `isLeapYear()` and returns 365 or 366. Returns:int the length of the year in days Annotations @Override

public int lengthOfYear()

Overrides default java.time.chrono.ChronoLocalDate.lengthOfYear.

Doc from java.time.chrono.ChronoLocalDate.lengthOfYear.

Returns the length of the year represented by this date, as defined by the calendar system.

This returns the length of the year in days.

The default implementation uses isLeapYear() and returns 365 or 366.

Returns:int

the length of the year in days

Annotations

@Override

minus back to summary

minus	back to summary
public JapaneseDate minus(TemporalAmount amount) Overrides java.time.chrono.ChronoLocalDateImpl.minus. Overrides default java.time.chrono.ChronoLocalDate.minus, java.time.temporal.Temporal.minus. Doc from java.time.chrono.ChronoLocalDate.minus. Returns an object of the same type as this object with an amount subtracted. This adjusts this temporal, subtracting according to the rules of the specified amount. The amount is typically a `java.time.Period` but may be any other type implementing the `TemporalAmount` interface, such as `java.time.Duration`. Some example code indicating how and why this method is used: date = date.minus(period); // subtract a Period instance date = date.minus(duration); // subtract a Duration instance date = date.minus(workingDays(6)); // example user-written workingDays method Note that calling `plus` followed by `minus` is not guaranteed to return the same date-time. Parameters amount:TemporalAmount Doc from java.time.temporal.Temporal.minus. the amount to subtract, not null Returns:JapaneseDate Doc from java.time.temporal.Temporal.minus. an object of the same type with the specified adjustment made, not null Annotations @Override Exceptions DateTimeException: if the subtraction cannot be made ArithmeticException: if numeric overflow occurs

public JapaneseDate minus(TemporalAmount amount)

Overrides java.time.chrono.ChronoLocalDateImpl.minus.

Overrides default java.time.chrono.ChronoLocalDate.minus, java.time.temporal.Temporal.minus.

Doc from java.time.chrono.ChronoLocalDate.minus.

Returns an object of the same type as this object with an amount subtracted.

This adjusts this temporal, subtracting according to the rules of the specified amount. The amount is typically a java.time.Period but may be any other type implementing the TemporalAmount interface, such as java.time.Duration.

Some example code indicating how and why this method is used:

 date = date.minus(period);               // subtract a Period instance
 date = date.minus(duration);             // subtract a Duration instance
 date = date.minus(workingDays(6));       // example user-written workingDays method

Note that calling plus followed by minus is not guaranteed to return the same date-time.

Parameters

amount:TemporalAmount

the amount to subtract, not null

Returns:JapaneseDate

an object of the same type with the specified adjustment made, not null

Annotations

@Override

Exceptions

DateTimeException:: if the subtraction cannot be made
ArithmeticException:: if numeric overflow occurs

minus back to summary

minus	back to summary
public JapaneseDate minus(long amountToSubtract, TemporalUnit unit) Overrides java.time.chrono.ChronoLocalDateImpl.minus. Overrides default java.time.chrono.ChronoLocalDate.minus, java.time.temporal.Temporal.minus. Doc from java.time.chrono.ChronoLocalDate.minus. Returns an object of the same type as this object with the specified period subtracted. This method returns a new object based on this one with the specified period subtracted. For example, on a `LocalDate`, this could be used to subtract a number of years, months or days. The returned object will have the same observable type as this object. In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st March, then subtracting one month would be unclear. In cases like this, the field is responsible for resolving the result. Typically it will choose the previous valid date, which would be the last valid day of February in this example. Parameters amountToSubtract:long Doc from java.time.temporal.Temporal.minus. the amount of the specified unit to subtract, may be negative unit:TemporalUnit Doc from java.time.temporal.Temporal.minus. the unit of the amount to subtract, not null Returns:JapaneseDate Doc from java.time.temporal.Temporal.minus. an object of the same type with the specified period subtracted, not null Annotations @Override

public JapaneseDate minus(long amountToSubtract, TemporalUnit unit)

Overrides java.time.chrono.ChronoLocalDateImpl.minus.

Overrides default java.time.chrono.ChronoLocalDate.minus, java.time.temporal.Temporal.minus.

Doc from java.time.chrono.ChronoLocalDate.minus.

Returns an object of the same type as this object with the specified period subtracted.

This method returns a new object based on this one with the specified period subtracted. For example, on a LocalDate, this could be used to subtract a number of years, months or days. The returned object will have the same observable type as this object.

In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st March, then subtracting one month would be unclear. In cases like this, the field is responsible for resolving the result. Typically it will choose the previous valid date, which would be the last valid day of February in this example.

Parameters

amountToSubtract:long

the amount of the specified unit to subtract, may be negative

unit:TemporalUnit

the unit of the amount to subtract, not null

Returns:JapaneseDate

an object of the same type with the specified period subtracted, not null

Annotations

@Override

minusDays back to summary

minusDays	back to summary
pack-priv JapaneseDate minusDays(long daysToSubtract) Overrides java.time.chrono.ChronoLocalDateImpl.minusDays. Doc from java.time.chrono.ChronoLocalDateImpl.minusDays. Returns a copy of this date with the specified number of days subtracted. This subtracts the specified period in days to the date. The default implementation uses `plusDays(long)`. This instance is immutable and unaffected by this method call. Parameters daysToSubtract:long the days to subtract, may be negative Returns:JapaneseDate a date based on this one with the days subtracted, not null Annotations @Override

pack-priv JapaneseDate minusDays(long daysToSubtract)

Overrides java.time.chrono.ChronoLocalDateImpl.minusDays.

Doc from java.time.chrono.ChronoLocalDateImpl.minusDays.

Returns a copy of this date with the specified number of days subtracted.

This subtracts the specified period in days to the date.

The default implementation uses plusDays(long).

This instance is immutable and unaffected by this method call.

Parameters

daysToSubtract:long: the days to subtract, may be negative

Returns:JapaneseDate

a date based on this one with the days subtracted, not null

Annotations

@Override

minusMonths back to summary

minusMonths	back to summary
pack-priv JapaneseDate minusMonths(long monthsToSubtract) Overrides java.time.chrono.ChronoLocalDateImpl.minusMonths. Doc from java.time.chrono.ChronoLocalDateImpl.minusMonths. Returns a copy of this date with the specified number of months subtracted. This subtracts the specified period in months to the date. In some cases, subtracting months can cause the resulting date to become invalid. If this occurs, then other fields, typically the day-of-month, will be adjusted to ensure that the result is valid. Typically this will select the last valid day of the month. The default implementation uses `plusMonths(long)`. This instance is immutable and unaffected by this method call. Parameters monthsToSubtract:long the months to subtract, may be negative Returns:JapaneseDate a date based on this one with the months subtracted, not null Annotations @Override

pack-priv JapaneseDate minusMonths(long monthsToSubtract)

Overrides java.time.chrono.ChronoLocalDateImpl.minusMonths.

Doc from java.time.chrono.ChronoLocalDateImpl.minusMonths.

Returns a copy of this date with the specified number of months subtracted.

This subtracts the specified period in months to the date. In some cases, subtracting months can cause the resulting date to become invalid. If this occurs, then other fields, typically the day-of-month, will be adjusted to ensure that the result is valid. Typically this will select the last valid day of the month.

The default implementation uses plusMonths(long).

This instance is immutable and unaffected by this method call.

Parameters

monthsToSubtract:long: the months to subtract, may be negative

Returns:JapaneseDate

a date based on this one with the months subtracted, not null

Annotations

@Override

minusWeeks back to summary

minusWeeks	back to summary
pack-priv JapaneseDate minusWeeks(long weeksToSubtract) Overrides java.time.chrono.ChronoLocalDateImpl.minusWeeks. Doc from java.time.chrono.ChronoLocalDateImpl.minusWeeks. Returns a copy of this date with the specified number of weeks subtracted. This subtracts the specified period in weeks to the date. In some cases, subtracting weeks can cause the resulting date to become invalid. If this occurs, then other fields will be adjusted to ensure that the result is valid. The default implementation uses `plusWeeks(long)`. This instance is immutable and unaffected by this method call. Parameters weeksToSubtract:long the weeks to subtract, may be negative Returns:JapaneseDate a date based on this one with the weeks subtracted, not null Annotations @Override

pack-priv JapaneseDate minusWeeks(long weeksToSubtract)

Overrides java.time.chrono.ChronoLocalDateImpl.minusWeeks.

Doc from java.time.chrono.ChronoLocalDateImpl.minusWeeks.

Returns a copy of this date with the specified number of weeks subtracted.

This subtracts the specified period in weeks to the date. In some cases, subtracting weeks can cause the resulting date to become invalid. If this occurs, then other fields will be adjusted to ensure that the result is valid.

The default implementation uses plusWeeks(long).

This instance is immutable and unaffected by this method call.

Parameters

weeksToSubtract:long: the weeks to subtract, may be negative

Returns:JapaneseDate

a date based on this one with the weeks subtracted, not null

Annotations

@Override

minusYears back to summary

minusYears	back to summary
pack-priv JapaneseDate minusYears(long yearsToSubtract) Overrides java.time.chrono.ChronoLocalDateImpl.minusYears. Doc from java.time.chrono.ChronoLocalDateImpl.minusYears. Returns a copy of this date with the specified number of years subtracted. This subtracts the specified period in years to the date. In some cases, subtracting years can cause the resulting date to become invalid. If this occurs, then other fields, typically the day-of-month, will be adjusted to ensure that the result is valid. Typically this will select the last valid day of the month. The default implementation uses `plusYears(long)`. This instance is immutable and unaffected by this method call. Parameters yearsToSubtract:long the years to subtract, may be negative Returns:JapaneseDate a date based on this one with the years subtracted, not null Annotations @Override

pack-priv JapaneseDate minusYears(long yearsToSubtract)

Overrides java.time.chrono.ChronoLocalDateImpl.minusYears.

Doc from java.time.chrono.ChronoLocalDateImpl.minusYears.

Returns a copy of this date with the specified number of years subtracted.

This subtracts the specified period in years to the date. In some cases, subtracting years can cause the resulting date to become invalid. If this occurs, then other fields, typically the day-of-month, will be adjusted to ensure that the result is valid. Typically this will select the last valid day of the month.

The default implementation uses plusYears(long).

This instance is immutable and unaffected by this method call.

Parameters

yearsToSubtract:long: the years to subtract, may be negative

Returns:JapaneseDate

a date based on this one with the years subtracted, not null

Annotations

@Override

now back to summary

now	back to summary
public static JapaneseDate now() Obtains the current `JapaneseDate` from the system clock in the default time-zone. This will query the `system clock` in the default time-zone to obtain the current date. Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded. Returns:JapaneseDate the current date using the system clock and default time-zone, not null

public static JapaneseDate now()

Obtains the current JapaneseDate from the system clock in the default time-zone.

This will query the system clock in the default time-zone to obtain the current date.

Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded.

Returns:JapaneseDate: the current date using the system clock and default time-zone, not null

now back to summary

now	back to summary
public static JapaneseDate now(ZoneId zone) Obtains the current `JapaneseDate` from the system clock in the specified time-zone. This will query the `system clock` to obtain the current date. Specifying the time-zone avoids dependence on the default time-zone. Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded. Parameters zone:ZoneId the zone ID to use, not null Returns:JapaneseDate the current date using the system clock, not null

public static JapaneseDate now(ZoneId zone)

Obtains the current JapaneseDate from the system clock in the specified time-zone.

This will query the system clock to obtain the current date. Specifying the time-zone avoids dependence on the default time-zone.

Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded.

Parameters

zone:ZoneId: the zone ID to use, not null

Returns:JapaneseDate

the current date using the system clock, not null

now back to summary

now	back to summary
public static JapaneseDate now(Clock clock) Obtains the current `JapaneseDate` from the specified clock. 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 dependency injection. Parameters clock:Clock the clock to use, not null Returns:JapaneseDate the current date, not null Exceptions DateTimeException: if the current date cannot be obtained

public static JapaneseDate now(Clock clock)

Obtains the current JapaneseDate from the specified clock.

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 dependency injection.

Parameters

clock:Clock: the clock to use, not null

Returns:JapaneseDate

the current date, not null

Exceptions

DateTimeException:: if the current date cannot be obtained

of back to summary

of	back to summary
public static JapaneseDate of(JapaneseEra era, int yearOfEra, int month, int dayOfMonth) Obtains a `JapaneseDate` representing a date in the Japanese calendar system from the era, year-of-era, month-of-year and day-of-month fields. This returns a `JapaneseDate` with the specified fields. The day must be valid for the year and month, otherwise an exception will be thrown. The Japanese month and day-of-month are the same as those in the ISO calendar system. They are not reset when the era changes. For example: 6th Jan Showa 64 = ISO 1989-01-06 7th Jan Showa 64 = ISO 1989-01-07 8th Jan Heisei 1 = ISO 1989-01-08 9th Jan Heisei 1 = ISO 1989-01-09 Parameters era:JapaneseEra the Japanese era, not null yearOfEra:int the Japanese year-of-era month:int the Japanese month-of-year, from 1 to 12 dayOfMonth:int the Japanese day-of-month, from 1 to 31 Returns:JapaneseDate the date in Japanese calendar system, not null Exceptions 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(JapaneseEra era, int yearOfEra, int month, int dayOfMonth)

Obtains a JapaneseDate representing a date in the Japanese calendar system from the era, year-of-era, month-of-year and day-of-month fields.

This returns a JapaneseDate with the specified fields. The day must be valid for the year and month, otherwise an exception will be thrown.

The Japanese month and day-of-month are the same as those in the ISO calendar system. They are not reset when the era changes. For example:

 6th Jan Showa 64 = ISO 1989-01-06
 7th Jan Showa 64 = ISO 1989-01-07
 8th Jan Heisei 1 = ISO 1989-01-08
 9th Jan Heisei 1 = ISO 1989-01-09

Parameters

era:JapaneseEra: the Japanese era, not null
yearOfEra:int: the Japanese year-of-era
month:int: the Japanese month-of-year, from 1 to 12
dayOfMonth:int: the Japanese day-of-month, from 1 to 31

Returns:JapaneseDate

the date in Japanese calendar system, not null

Exceptions

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

of back to summary

of	back to summary
public static JapaneseDate of(int prolepticYear, int month, int dayOfMonth) Obtains a `JapaneseDate` representing a date in the Japanese calendar system from the proleptic-year, month-of-year and day-of-month fields. This returns a `JapaneseDate` with the specified fields. The day must be valid for the year and month, otherwise an exception will be thrown. The Japanese proleptic year, month and day-of-month are the same as those in the ISO calendar system. They are not reset when the era changes. Parameters prolepticYear:int the Japanese proleptic-year month:int the Japanese month-of-year, from 1 to 12 dayOfMonth:int the Japanese day-of-month, from 1 to 31 Returns:JapaneseDate the date in Japanese calendar system, not null Exceptions 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)

Obtains a JapaneseDate representing a date in the Japanese calendar system from the proleptic-year, month-of-year and day-of-month fields.

This returns a JapaneseDate with the specified fields. The day must be valid for the year and month, otherwise an exception will be thrown.

The Japanese proleptic year, month and day-of-month are the same as those in the ISO calendar system. They are not reset when the era changes.

Parameters

prolepticYear:int: the Japanese proleptic-year
month:int: the Japanese month-of-year, from 1 to 12
dayOfMonth:int: the Japanese day-of-month, from 1 to 31

Returns:JapaneseDate

the date in Japanese calendar system, not null

Exceptions

DateTimeException:: if the value of any field is out of range, or if the day-of-month is invalid for the month-year

ofYearDay back to summary

ofYearDay	back to summary
pack-priv static JapaneseDate ofYearDay(JapaneseEra era, int yearOfEra, int dayOfYear) Obtains a `JapaneseDate` representing a date in the Japanese calendar system from the era, year-of-era and day-of-year fields. This returns a `JapaneseDate` with the specified fields. The day must be valid for the year, otherwise an exception will be thrown. The day-of-year in this factory is expressed relative to the start of the year-of-era. This definition changes the normal meaning of day-of-year only in those years where the year-of-era is reset to one due to a change in the era. For example: 6th Jan Showa 64 = day-of-year 6 7th Jan Showa 64 = day-of-year 7 8th Jan Heisei 1 = day-of-year 1 9th Jan Heisei 1 = day-of-year 2 Parameters era:JapaneseEra the Japanese era, not null yearOfEra:int the Japanese year-of-era dayOfYear:int the chronology day-of-year, from 1 to 366 Returns:JapaneseDate the date in Japanese calendar system, not null Exceptions DateTimeException: if the value of any field is out of range, or if the day-of-year is invalid for the year

pack-priv static JapaneseDate ofYearDay(JapaneseEra era, int yearOfEra, int dayOfYear)

Obtains a JapaneseDate representing a date in the Japanese calendar system from the era, year-of-era and day-of-year fields.

This returns a JapaneseDate with the specified fields. The day must be valid for the year, otherwise an exception will be thrown.

The day-of-year in this factory is expressed relative to the start of the year-of-era. This definition changes the normal meaning of day-of-year only in those years where the year-of-era is reset to one due to a change in the era. For example:

 6th Jan Showa 64 = day-of-year 6
 7th Jan Showa 64 = day-of-year 7
 8th Jan Heisei 1 = day-of-year 1
 9th Jan Heisei 1 = day-of-year 2

Parameters

era:JapaneseEra: the Japanese era, not null
yearOfEra:int: the Japanese year-of-era
dayOfYear:int: the chronology day-of-year, from 1 to 366

Returns:JapaneseDate

the date in Japanese calendar system, not null

Exceptions

DateTimeException:: if the value of any field is out of range, or if the day-of-year is invalid for the year

plus back to summary

plus	back to summary
public JapaneseDate plus(TemporalAmount amount) Overrides java.time.chrono.ChronoLocalDateImpl.plus. Overrides default java.time.chrono.ChronoLocalDate.plus, java.time.temporal.Temporal.plus. Doc from java.time.chrono.ChronoLocalDate.plus. Returns an object of the same type as this object with an amount added. This adjusts this temporal, adding according to the rules of the specified amount. The amount is typically a `java.time.Period` but may be any other type implementing the `TemporalAmount` interface, such as `java.time.Duration`. Some example code indicating how and why this method is used: date = date.plus(period); // add a Period instance date = date.plus(duration); // add a Duration instance date = date.plus(workingDays(6)); // example user-written workingDays method Note that calling `plus` followed by `minus` is not guaranteed to return the same date-time. Parameters amount:TemporalAmount Doc from java.time.temporal.Temporal.plus. the amount to add, not null Returns:JapaneseDate Doc from java.time.temporal.Temporal.plus. an object of the same type with the specified adjustment made, not null Annotations @Override Exceptions DateTimeException: if the addition cannot be made ArithmeticException: if numeric overflow occurs

public JapaneseDate plus(TemporalAmount amount)

Overrides java.time.chrono.ChronoLocalDateImpl.plus.

Overrides default java.time.chrono.ChronoLocalDate.plus, java.time.temporal.Temporal.plus.

Doc from java.time.chrono.ChronoLocalDate.plus.

Returns an object of the same type as this object with an amount added.

This adjusts this temporal, adding according to the rules of the specified amount. The amount is typically a java.time.Period but may be any other type implementing the TemporalAmount interface, such as java.time.Duration.

Some example code indicating how and why this method is used:

 date = date.plus(period);                // add a Period instance
 date = date.plus(duration);              // add a Duration instance
 date = date.plus(workingDays(6));        // example user-written workingDays method

Note that calling plus followed by minus is not guaranteed to return the same date-time.

Parameters

amount:TemporalAmount

the amount to add, not null

Returns:JapaneseDate

an object of the same type with the specified adjustment made, not null

Annotations

@Override

Exceptions

DateTimeException:: if the addition cannot be made
ArithmeticException:: if numeric overflow occurs

plus back to summary

plus	back to summary
public JapaneseDate plus(long amountToAdd, TemporalUnit unit) Overrides java.time.chrono.ChronoLocalDateImpl.plus. Overrides default java.time.chrono.ChronoLocalDate.plus. Implements java.time.temporal.Temporal.plus. Doc from java.time.chrono.ChronoLocalDate.plus. Returns an object of the same type as this object with the specified period added. This method returns a new object based on this one with the specified period added. For example, on a `LocalDate`, this could be used to add a number of years, months or days. The returned object will have the same observable type as this object. In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st January, then adding one month would be unclear. In cases like this, the field is responsible for resolving the result. Typically it will choose the previous valid date, which would be the last valid day of February in this example. Parameters amountToAdd:long Doc from java.time.temporal.Temporal.plus. the amount of the specified unit to add, may be negative unit:TemporalUnit Doc from java.time.temporal.Temporal.plus. the unit of the amount to add, not null Returns:JapaneseDate Doc from java.time.temporal.Temporal.plus. an object of the same type with the specified period added, not null Annotations @Override

public JapaneseDate plus(long amountToAdd, TemporalUnit unit)

Overrides java.time.chrono.ChronoLocalDateImpl.plus.

Overrides default java.time.chrono.ChronoLocalDate.plus.

Implements java.time.temporal.Temporal.plus.

Doc from java.time.chrono.ChronoLocalDate.plus.

Returns an object of the same type as this object with the specified period added.

This method returns a new object based on this one with the specified period added. For example, on a LocalDate, this could be used to add a number of years, months or days. The returned object will have the same observable type as this object.

In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st January, then adding one month would be unclear. In cases like this, the field is responsible for resolving the result. Typically it will choose the previous valid date, which would be the last valid day of February in this example.

Parameters

amountToAdd:long

the amount of the specified unit to add, may be negative

unit:TemporalUnit

the unit of the amount to add, not null

Returns:JapaneseDate

an object of the same type with the specified period added, not null

Annotations

@Override

plusDays	back to summary
pack-priv JapaneseDate plusDays(long days) Implements abstract java.time.chrono.ChronoLocalDateImpl.plusDays. Doc from java.time.chrono.ChronoLocalDateImpl.plusDays. Returns a copy of this date with the specified number of days added. This adds the specified period in days to the date. This instance is immutable and unaffected by this method call. Parameters days:long the days to add, may be negative Returns:JapaneseDate a date based on this one with the days added, not null Annotations @Override

plusDays

pack-priv JapaneseDate plusDays(long days)

Implements abstract java.time.chrono.ChronoLocalDateImpl.plusDays.

Doc from java.time.chrono.ChronoLocalDateImpl.plusDays.

Returns a copy of this date with the specified number of days added.

This adds the specified period in days to the date.

This instance is immutable and unaffected by this method call.

Parameters

days:long: the days to add, may be negative

Returns:JapaneseDate

a date based on this one with the days added, not null

Annotations

@Override

plusMonths	back to summary
pack-priv JapaneseDate plusMonths(long months) Implements abstract java.time.chrono.ChronoLocalDateImpl.plusMonths. Doc from java.time.chrono.ChronoLocalDateImpl.plusMonths. Returns a copy of this date with the specified number of months added. This adds the specified period in months to the date. In some cases, adding months can cause the resulting date to become invalid. If this occurs, then other fields, typically the day-of-month, will be adjusted to ensure that the result is valid. Typically this will select the last valid day of the month. This instance is immutable and unaffected by this method call. Parameters months:long the months to add, may be negative Returns:JapaneseDate a date based on this one with the months added, not null Annotations @Override

plusMonths

pack-priv JapaneseDate plusMonths(long months)

Implements abstract java.time.chrono.ChronoLocalDateImpl.plusMonths.

Doc from java.time.chrono.ChronoLocalDateImpl.plusMonths.

Returns a copy of this date with the specified number of months added.

This adds the specified period in months to the date. In some cases, adding months can cause the resulting date to become invalid. If this occurs, then other fields, typically the day-of-month, will be adjusted to ensure that the result is valid. Typically this will select the last valid day of the month.

This instance is immutable and unaffected by this method call.

Parameters

months:long: the months to add, may be negative

Returns:JapaneseDate

a date based on this one with the months added, not null

Annotations

@Override

plusWeeks back to summary

plusWeeks	back to summary
pack-priv JapaneseDate plusWeeks(long weeksToAdd) Overrides java.time.chrono.ChronoLocalDateImpl.plusWeeks. Doc from java.time.chrono.ChronoLocalDateImpl.plusWeeks. Returns a copy of this date with the specified number of weeks added. This adds the specified period in weeks to the date. In some cases, adding weeks can cause the resulting date to become invalid. If this occurs, then other fields will be adjusted to ensure that the result is valid. The default implementation uses `plusDays(long)` using a 7 day week. This instance is immutable and unaffected by this method call. Parameters weeksToAdd:long the weeks to add, may be negative Returns:JapaneseDate a date based on this one with the weeks added, not null Annotations @Override

pack-priv JapaneseDate plusWeeks(long weeksToAdd)

Overrides java.time.chrono.ChronoLocalDateImpl.plusWeeks.

Doc from java.time.chrono.ChronoLocalDateImpl.plusWeeks.

Returns a copy of this date with the specified number of weeks added.

This adds the specified period in weeks to the date. In some cases, adding weeks can cause the resulting date to become invalid. If this occurs, then other fields will be adjusted to ensure that the result is valid.

The default implementation uses plusDays(long) using a 7 day week.

This instance is immutable and unaffected by this method call.

Parameters

weeksToAdd:long: the weeks to add, may be negative

Returns:JapaneseDate

a date based on this one with the weeks added, not null

Annotations

@Override

plusYears	back to summary
pack-priv JapaneseDate plusYears(long years) Implements abstract java.time.chrono.ChronoLocalDateImpl.plusYears. Doc from java.time.chrono.ChronoLocalDateImpl.plusYears. Returns a copy of this date with the specified number of years added. This adds the specified period in years to the date. In some cases, adding years can cause the resulting date to become invalid. If this occurs, then other fields, typically the day-of-month, will be adjusted to ensure that the result is valid. Typically this will select the last valid day of the month. This instance is immutable and unaffected by this method call. Parameters years:long the years to add, may be negative Returns:JapaneseDate a date based on this one with the years added, not null Annotations @Override

plusYears

pack-priv JapaneseDate plusYears(long years)

Implements abstract java.time.chrono.ChronoLocalDateImpl.plusYears.

Doc from java.time.chrono.ChronoLocalDateImpl.plusYears.

Returns a copy of this date with the specified number of years added.

This adds the specified period in years to the date. In some cases, adding years can cause the resulting date to become invalid. If this occurs, then other fields, typically the day-of-month, will be adjusted to ensure that the result is valid. Typically this will select the last valid day of the month.

This instance is immutable and unaffected by this method call.

Parameters

years:long: the years to add, may be negative

Returns:JapaneseDate

a date based on this one with the years added, not null

Annotations

@Override

range back to summary

range	back to summary
public ValueRange range(TemporalField field) Overrides default java.time.temporal.TemporalAccessor.range. Doc from java.time.temporal.TemporalAccessor.range. Gets the range of valid values for the specified field. All fields can be expressed as a `long` integer. This method returns an object that describes the valid range for that value. The value of this temporal object is used to enhance the accuracy of the returned range. If the date-time cannot return the range, because the field is unsupported or for some other reason, an exception will be thrown. Note that the result only describes the minimum and maximum valid values and it is important not to read too much into them. For example, there could be values within the range that are invalid for the field. Parameters field:TemporalField the field to query the range for, not null Returns:ValueRange the range of valid values for the field, not null Annotations @Override

public ValueRange range(TemporalField field)

Overrides default java.time.temporal.TemporalAccessor.range.

Doc from java.time.temporal.TemporalAccessor.range.

Gets the range of valid values for the specified field.

All fields can be expressed as a long integer. This method returns an object that describes the valid range for that value. The value of this temporal object is used to enhance the accuracy of the returned range. If the date-time cannot return the range, because the field is unsupported or for some other reason, an exception will be thrown.

Note that the result only describes the minimum and maximum valid values and it is important not to read too much into them. For example, there could be values within the range that are invalid for the field.

Parameters

field:TemporalField: the field to query the range for, not null

Returns:ValueRange

the range of valid values for the field, not null

Annotations

@Override

readExternal	back to summary
pack-priv static JapaneseDate readExternal(DataInput in) throws IOException

readObject	back to summary
private void readObject(ObjectInputStream s) throws InvalidObjectException Defend against malicious streams. Parameters s:ObjectInputStream the stream to read Annotations @Serial Exceptions InvalidObjectException: always

readObject

private void readObject(ObjectInputStream s) throws InvalidObjectException

Defend against malicious streams.

Parameters

s:ObjectInputStream: the stream to read

Annotations

@Serial

Exceptions

InvalidObjectException:: always

toEpochDay back to summary

toEpochDay	back to summary
public long toEpochDay() Overrides default java.time.chrono.ChronoLocalDate.toEpochDay. Doc from java.time.chrono.ChronoLocalDate.toEpochDay. Converts this date to the Epoch Day. The `Epoch Day count` is a simple incrementing count of days where day 0 is 1970-01-01 (ISO). This definition is the same for all chronologies, enabling conversion. This default implementation queries the `EPOCH_DAY` field. Returns:long the Epoch Day equivalent to this date Annotations @Override

public long toEpochDay()

Overrides default java.time.chrono.ChronoLocalDate.toEpochDay.

Doc from java.time.chrono.ChronoLocalDate.toEpochDay.

Converts this date to the Epoch Day.

The Epoch Day count is a simple incrementing count of days where day 0 is 1970-01-01 (ISO). This definition is the same for all chronologies, enabling conversion.

This default implementation queries the EPOCH_DAY field.

Returns:long

the Epoch Day equivalent to this date

Annotations

@Override

toPrivateJapaneseDate back to summary

toPrivateJapaneseDate	back to summary
private static LocalGregorianCalendar.Date toPrivateJapaneseDate(LocalDate isoDate) Returns a `LocalGregorianCalendar.Date` converted from the given `isoDate`. Parameters isoDate:LocalDate the local date, not null Returns:LocalGregorianCalendar.Date a `LocalGregorianCalendar.Date`, not null

private static LocalGregorianCalendar.Date toPrivateJapaneseDate(LocalDate isoDate)

Returns a LocalGregorianCalendar.Date converted from the given isoDate.

Parameters

isoDate:LocalDate: the local date, not null

Returns:LocalGregorianCalendar.Date

a LocalGregorianCalendar.Date, not null

until back to summary

until	back to summary
public ChronoPeriod until(ChronoLocalDate endDate) Implements java.time.chrono.ChronoLocalDate.until. Doc from java.time.chrono.ChronoLocalDate.until. Calculates the period between this date and another date as a `ChronoPeriod`. This calculates the period between two dates. All supplied chronologies calculate the period using years, months and days, however the `ChronoPeriod` API allows the period to be represented using other units. The start and end points are `this` and the specified date. The result will be negative if the end is before the start. The negative sign will be the same in each of year, month and day. The calculation is performed using the chronology of this date. If necessary, the input date will be converted to match. This instance is immutable and unaffected by this method call. Parameters endDate:ChronoLocalDate the end date, exclusive, which may be in any chronology, not null Returns:ChronoPeriod the period between this date and the end date, not null Annotations @Override

public ChronoPeriod until(ChronoLocalDate endDate)

Implements java.time.chrono.ChronoLocalDate.until.

Doc from java.time.chrono.ChronoLocalDate.until.

Calculates the period between this date and another date as a ChronoPeriod.

This calculates the period between two dates. All supplied chronologies calculate the period using years, months and days, however the ChronoPeriod API allows the period to be represented using other units.

The start and end points are this and the specified date. The result will be negative if the end is before the start. The negative sign will be the same in each of year, month and day.

The calculation is performed using the chronology of this date. If necessary, the input date will be converted to match.

This instance is immutable and unaffected by this method call.

Parameters

endDate:ChronoLocalDate: the end date, exclusive, which may be in any chronology, not null

Returns:ChronoPeriod

the period between this date and the end date, not null

Annotations

@Override

with back to summary

with	back to summary
public JapaneseDate with(TemporalField field, long newValue) Overrides java.time.chrono.ChronoLocalDateImpl.with. Overrides default java.time.chrono.ChronoLocalDate.with. Implements java.time.temporal.Temporal.with. Doc from java.time.chrono.ChronoLocalDate.with. Returns an object of the same type as this object with the specified field altered. This returns a new object based on this one with the value for the specified field changed. For example, on a `LocalDate`, this could be used to set the year, month or day-of-month. The returned object will have the same observable type as this object. In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st January, then changing the month to February would be unclear. In cases like this, the field is responsible for resolving the result. Typically it will choose the previous valid date, which would be the last valid day of February in this example. Parameters field:TemporalField Doc from java.time.temporal.Temporal.with. the field to set in the result, not null newValue:long Doc from java.time.temporal.Temporal.with. the new value of the field in the result Returns:JapaneseDate Doc from java.time.temporal.Temporal.with. an object of the same type with the specified field set, not null Annotations @Override

public JapaneseDate with(TemporalField field, long newValue)

Overrides java.time.chrono.ChronoLocalDateImpl.with.

Overrides default java.time.chrono.ChronoLocalDate.with.

Implements java.time.temporal.Temporal.with.

Doc from java.time.chrono.ChronoLocalDate.with.

Returns an object of the same type as this object with the specified field altered.

This returns a new object based on this one with the value for the specified field changed. For example, on a LocalDate, this could be used to set the year, month or day-of-month. The returned object will have the same observable type as this object.

In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st January, then changing the month to February would be unclear. In cases like this, the field is responsible for resolving the result. Typically it will choose the previous valid date, which would be the last valid day of February in this example.

Parameters

field:TemporalField

the field to set in the result, not null

newValue:long

the new value of the field in the result

Returns:JapaneseDate

an object of the same type with the specified field set, not null

Annotations

@Override

with back to summary

with	back to summary
public JapaneseDate with(TemporalAdjuster adjuster) Overrides java.time.chrono.ChronoLocalDateImpl.with. Overrides default java.time.chrono.ChronoLocalDate.with, java.time.temporal.Temporal.with. Doc from java.time.chrono.ChronoLocalDate.with. Returns an adjusted object of the same type as this object with the adjustment made. This adjusts this date-time according to the rules of the specified adjuster. 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 `TemporalAdjusters`. These include finding the "last day of the month" and "next Wednesday". The adjuster is responsible for handling special cases, such as the varying lengths of month and leap years. Some example code indicating how and why this method is used: date = date.with(Month.JULY); // most key classes implement TemporalAdjuster date = date.with(lastDayOfMonth()); // static import from Adjusters date = date.with(next(WEDNESDAY)); // static import from Adjusters and DayOfWeek Parameters adjuster:TemporalAdjuster Doc from java.time.temporal.Temporal.with. the adjuster to use, not null Returns:JapaneseDate Doc from java.time.temporal.Temporal.with. an object of the same type with the specified adjustment made, not null Annotations @Override Exceptions DateTimeException: if unable to make the adjustment ArithmeticException: if numeric overflow occurs

public JapaneseDate with(TemporalAdjuster adjuster)

Overrides java.time.chrono.ChronoLocalDateImpl.with.

Overrides default java.time.chrono.ChronoLocalDate.with, java.time.temporal.Temporal.with.

Doc from java.time.chrono.ChronoLocalDate.with.

Returns an adjusted object of the same type as this object with the adjustment made.

This adjusts this date-time according to the rules of the specified adjuster. 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 TemporalAdjusters. These include finding the "last day of the month" and "next Wednesday". The adjuster is responsible for handling special cases, such as the varying lengths of month and leap years.

Some example code indicating how and why this method is used:

 date = date.with(Month.JULY);        // most key classes implement TemporalAdjuster
 date = date.with(lastDayOfMonth());  // static import from Adjusters
 date = date.with(next(WEDNESDAY));   // static import from Adjusters and DayOfWeek

Parameters

adjuster:TemporalAdjuster

the adjuster to use, not null

Returns:JapaneseDate