PlainTime (Time4J-Core 3.10 API)

java.lang.Object
- net.time4j.engine.ChronoEntity<T>
- - net.time4j.engine.TimePoint<IsoTimeUnit,PlainTime>
  - - net.time4j.PlainTime

All Implemented Interfaces:

Serializable, Comparable<PlainTime>, WallTime, ChronoDisplay, Temporal<PlainTime>, LocalizedPatternSupport
```
@CalendarType(value="iso8601")
public final class PlainTime
extends TimePoint<IsoTimeUnit,PlainTime>
implements WallTime, Temporal<PlainTime>, LocalizedPatternSupport
```
Represents a plain wall time without any timezone or date component as defined in ISO-8601 up to nanosecond precision.

This type also supports the special value 24:00 in its state space. That value means midnight at the end of day and can be both set and queried.

Following elements which are declared as constants are registered by this class:
Author:

Meno Hochschild

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static ZonalElement<Meridiem>`	`AM_PM_OF_DAY` Element with the half day section relative to noon (ante meridiem or post meridiem).
`static AdjustableElement<Integer,PlainTime>`	`CLOCK_HOUR_OF_AMPM` Element with the hour of half day in the value range `1-12` (dial on an analogue watch).
`static AdjustableElement<Integer,PlainTime>`	`CLOCK_HOUR_OF_DAY` Element with the hour in the value range `1-24` (analogue display).
`static WallTimeElement`	`COMPONENT` Element with the wall time in the value range `[T00:00:00,000000000]` until `[T24:00:00,000000000]` (inclusive in the context of `PlainTime` else exclusive).
`static ZonalElement<BigDecimal>`	`DECIMAL_HOUR` Decimal hour in the value range `0.0` inclusive until `24.0` exclusive (inclusive in `PlainTime`).
`static ZonalElement<BigDecimal>`	`DECIMAL_MINUTE` Decimal minute in the value range `0.0` inclusive until `60.0` exclusive.
`static ZonalElement<BigDecimal>`	`DECIMAL_SECOND` Decimal second in the value range `0.0` inclusive until `60.0` exclusive.
`static ProportionalElement<Integer,PlainTime>`	`DIGITAL_HOUR_OF_AMPM` Element with the digital hour of half day in the value range `0-11`.
`static ProportionalElement<Integer,PlainTime>`	`DIGITAL_HOUR_OF_DAY` Element with the digital hour in the value range `0-23`.
`static ProportionalElement<Integer,PlainTime>`	`ISO_HOUR` Element with the ISO-8601-hour of day in the value range `0-24`.
`static ProportionalElement<Long,PlainTime>`	`MICRO_OF_DAY` Element with the day time in microseconds in the value range `0-86400000000`.
`static ProportionalElement<Integer,PlainTime>`	`MICRO_OF_SECOND` Element with the microsecond in the value range `0-999999`.
`static ProportionalElement<Integer,PlainTime>`	`MILLI_OF_DAY` Element with the day time in milliseconds in the value range `0-86400000`.
`static ProportionalElement<Integer,PlainTime>`	`MILLI_OF_SECOND` Element with the millisecond in the value range `0-999`.
`static ProportionalElement<Integer,PlainTime>`	`MINUTE_OF_DAY` Element with the minute of day in the value range `0-1440`.
`static ProportionalElement<Integer,PlainTime>`	`MINUTE_OF_HOUR` Element with the minute of hour in the value range `0-59`.
`static ProportionalElement<Long,PlainTime>`	`NANO_OF_DAY` Element with the day time in nanoseconds in the value range `0-86400000000000`.
`static ProportionalElement<Integer,PlainTime>`	`NANO_OF_SECOND` Element with the nanosecond in the value range `0-999999999`.
`static ChronoElement<ClockUnit>`	`PRECISION` Defines the precision as the smallest non-zero time element and truncates time parts of higher precision if necessary.
`static ProportionalElement<Integer,PlainTime>`	`SECOND_OF_DAY` Element with the second of day in the value range `0-86400`.
`static ProportionalElement<Integer,PlainTime>`	`SECOND_OF_MINUTE` Element with the second of minute in the value range `0-59`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static TimeAxis<IsoTimeUnit,PlainTime>`	`axis()` Provides a static access to the associated time axis respective chronology which contains the chronological rules.
`int`	`compareTo(PlainTime time)` Defines a natural order which is solely based on the timeline order.
`boolean`	`equals(Object obj)` Compares the full state, that is hour, minute, second and nanosecond of this instance and given argument.
`static TemporalFormatter<PlainTime>`	`formatter(DisplayMode mode, Locale locale)` Creates a new formatter which uses the given display mode and locale for formatting and parsing plain times.
`static <P extends ChronoPattern<P>> TemporalFormatter<PlainTime>`	`formatter(String formatPattern, P patternType, Locale locale)` Creates a new formatter which uses the given pattern and locale for formatting and parsing plain times.
`static PlainTime`	`from(WallTime time)` Common conversion method.
`int`	`getHour()` Yields the hour of day.
`int`	`getMinute()` Liefert die Minute (der aktuellen Stunde).
`int`	`getNanosecond()` Yields the nanosecond.
`int`	`getSecond()` Yields the second of minute.
`int`	`hashCode()` Subclasses must redefine this method corresponding to the behaviour of `equals()`.
`boolean`	`isAfter(PlainTime time)` Queries if this object is after given object on a timeline.
`boolean`	`isBefore(PlainTime time)` Queries if this object is before given object on a timeline.
`boolean`	`isMidnight()` Is this instance at midnight, either at start or at end of day?
`boolean`	`isSimultaneous(PlainTime time)` Queries if this object and given object have the same position on the time axis.
`static TemporalFormatter<PlainTime>`	`localFormatter(DisplayMode mode)` Creates a new formatter which uses the given display mode in the default locale for formatting and parsing plain times.
`static <P extends ChronoPattern<P>> TemporalFormatter<PlainTime>`	`localFormatter(String formatPattern, P patternType)` Creates a new formatter which uses the given pattern in the default locale for formatting and parsing plain times.
`static PlainTime`	`midnightAtEndOfDay()` Yields midnight at the end of the day, that is midnight at the start of the following day.
`static PlainTime`	`midnightAtStartOfDay()` Yields midnight at the start of the day.
`static PlainTime`	`of(BigDecimal decimal)` Creates a wall time by given decimal hour.
`static PlainTime`	`of(int hour)` Creates a wall time as full hour.
`static PlainTime`	`of(int hour, int minute)` Creates a wall time with hour and minute.
`static PlainTime`	`of(int hour, int minute, int second)` Creates a wall time with hour, minute and second.
`static PlainTime`	`of(int hour, int minute, int second, int nanosecond)` Creates a wall time with hour, minute, second and nanosecond.
`DayCycles`	`roll(long amount, ClockUnit unit)` Rolls this time by the given duration (as amount and unit) and also counts possible day overflow.
`String`	`toString()` Dependent on the precision of this instance, this method yields a canonical representation in one of following formats (CLDR-syntax): 'T'HH 'T'HH:mm 'T'HH:mm:ss 'T'HH:mm:ss,SSS 'T'HH:mm:ss,SSSSSS 'T'HH:mm:ss,SSSSSSSSS The fraction part will be preceded by a comma as recommended by ISO unless the system property "net.time4j.format.iso.decimal.dot" was set to "true".

Methods inherited from class net.time4j.engine.TimePoint
max, min, minus, minus, plus, plus, until, until

Methods inherited from class net.time4j.engine.ChronoEntity
contains, get, get, getMaximum, getMinimum, getTimezone, hasTimezone, isValid, isValid, isValid, matches, with, with, with, with

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - COMPONENT
```
public static final WallTimeElement COMPONENT
```
    Element with the wall time in the value range [T00:00:00,000000000] until [T24:00:00,000000000] (inclusive in the context of PlainTime else exclusive).
    
    Example of usage:
```
  PlainTimestamp tsp =
      PlainTimestamp.localFormatter("uuuu-MM-dd", PatternType.CLDR)
          .withDefault(
              PlainTime.COMPONENT,
              PlainTime.midnightAtStartOfDay())
          .parse("2014-08-20");
  System.out.println(tsp); // output: 2014-08-20T00
 
```
    Note: This element does not define any base unit.
    Since:
    
    1.2
  - AM_PM_OF_DAY
```
@FormattableElement(format="a")
public static final ZonalElement<Meridiem> AM_PM_OF_DAY
```
    Element with the half day section relative to noon (ante meridiem or post meridiem).
    
    This element handles the value 24:00 in the same way as 00:00, hence does not make any difference between start and end of day. In detail the mapping from hours to meridiem values looks like following:
    
    Legend
    AM_PM_OF_DAY AM AM ... AM PM PM ... PM AM
    
    ISO-8601-Wert T0 T1 ... T11 T12 T13 ... T23 T24
    
    Example:
```
  import static net.time4j.PlainTime.AM_PM_OF_DAY;

  PlainTime time = PlainTime.of(12, 45, 20);
  System.out.println(time.get(AM_PM_OF_DAY));
  // Output: PM
 
```
    This element does not define a base unit.
  - CLOCK_HOUR_OF_AMPM
```
@FormattableElement(format="h")
public static final AdjustableElement<Integer,PlainTime> CLOCK_HOUR_OF_AMPM
```
    Element with the hour of half day in the value range 1-12 (dial on an analogue watch).
    
    This element handles the value 24:00 in the same way as 00:00, hence does not make any difference between start and end of day. This is a limitation which preserves the compatibility with CLDR and the class java.text.SimpleDateFormat. In order to support the full hour range users can use the element PlainTime.ISO_HOUR. In detail the mapping to ISO-hours looks like following:
    
    Legend
    CLOCK_HOUR_OF_AMPM 12 1 ... 11 12 1 ... 11 12
    
    ISO-8601-Wert T0 T1 ... T11 T12 T13 ... T23 T24
  - CLOCK_HOUR_OF_DAY
```
@FormattableElement(format="k")
public static final AdjustableElement<Integer,PlainTime> CLOCK_HOUR_OF_DAY
```
    Element with the hour in the value range 1-24 (analogue display).
    
    This element handles the value 24:00 in the same way as 00:00, hence does not make any difference between start and end of day. This is a limitation which preserves the compatibility with CLDR and the class java.text.SimpleDateFormat. In order to support the full hour range users can use the element PlainTime.ISO_HOUR. In detail the mapping to ISO-hours looks like following:
    
    Legend
    CLOCK_HOUR_OF_DAY 24 1 ... 11 12 13 ... 23 24
    
    ISO-8601-Wert T0 T1 ... T11 T12 T13 ... T23 T24
  - DIGITAL_HOUR_OF_AMPM
```
@FormattableElement(format="K")
public static final ProportionalElement<Integer,PlainTime> DIGITAL_HOUR_OF_AMPM
```
    Element with the digital hour of half day in the value range 0-11.
    
    This element handles the value 24:00 in the same way as 00:00, hence does not make any difference between start and end of day. This is a limitation which preserves the compatibility with CLDR and the class java.text.SimpleDateFormat. In order to support the full hour range users can use the element PlainTime.ISO_HOUR. In detail the mapping to ISO-hours looks like following:
    
    Legend
    DIGITAL_HOUR_OF_AMPM 0 1 ... 11 0 1 ... 11 0
    
    ISO-8601-Wert T0 T1 ... T11 T12 T13 ... T23 T24
  - DIGITAL_HOUR_OF_DAY
```
@FormattableElement(format="H")
public static final ProportionalElement<Integer,PlainTime> DIGITAL_HOUR_OF_DAY
```
    Element with the digital hour in the value range 0-23.
    
    This element handles the value 24:00 in the same way as 00:00, hence does not make any difference between start and end of day. This is a limitation which preserves the compatibility with CLDR and the class java.text.SimpleDateFormat. In order to support the full hour range users can use the element PlainTime.ISO_HOUR. In detail the mapping to ISO-hours looks like following:
    
    Legend
    DIGITAL_HOUR_OF_DAY 0 1 ... 11 12 13 ... 23 0
    
    ISO-8601-Wert T0 T1 ... T11 T12 T13 ... T23 T24
  - ISO_HOUR
```
public static final ProportionalElement<Integer,PlainTime> ISO_HOUR
```
    Element with the ISO-8601-hour of day in the value range 0-24.
    
    Given a context of PlainTime with full hours, the maximum is 24 and stands for the time 24:00 (midnight at end of day), else the maximum is 23 in every different context.
    
    See Also:
    
    PlainTime.getHour()
  - MINUTE_OF_HOUR
```
@FormattableElement(format="m")
public static final ProportionalElement<Integer,PlainTime> MINUTE_OF_HOUR
```
    Element with the minute of hour in the value range 0-59.
    
    See Also:
    
    PlainTime.getMinute()
  - MINUTE_OF_DAY
```
public static final ProportionalElement<Integer,PlainTime> MINUTE_OF_DAY
```
    Element with the minute of day in the value range 0-1440.
    
    Given a context of PlainTime with full minutes, the maximum is 1440 and stands for the time 24:00 (midnight at end of day), else the maximum is 1439 in every different context.
  - SECOND_OF_MINUTE
```
@FormattableElement(format="s")
public static final ProportionalElement<Integer,PlainTime> SECOND_OF_MINUTE
```
    Element with the second of minute in the value range 0-59.
    
    This element does not know any leapseconds in a local context and refers to a normal analogue clock. If this element is used in UTC-context (Moment) however then the value range is 0-58/59/60 instead.
    
    See Also:
    
    PlainTime.getSecond()
  - SECOND_OF_DAY
```
public static final ProportionalElement<Integer,PlainTime> SECOND_OF_DAY
```
    Element with the second of day in the value range 0-86400.
    
    Given a context of PlainTime with full seconds, the maximum is 86400 and stands for the time 24:00 (midnight at end of day), else the maximum is 86399 in every different context. Leapseconds are never counted.
  - MILLI_OF_SECOND
```
public static final ProportionalElement<Integer,PlainTime> MILLI_OF_SECOND
```
    Element with the millisecond in the value range 0-999.
  - MICRO_OF_SECOND
```
public static final ProportionalElement<Integer,PlainTime> MICRO_OF_SECOND
```
    Element with the microsecond in the value range 0-999999.
  - NANO_OF_SECOND
```
@FormattableElement(format="S")
public static final ProportionalElement<Integer,PlainTime> NANO_OF_SECOND
```
    Element with the nanosecond in the value range 0-999999999.
  - MILLI_OF_DAY
```
@FormattableElement(format="A")
public static final ProportionalElement<Integer,PlainTime> MILLI_OF_DAY
```
    Element with the day time in milliseconds in the value range 0-86400000.
    
    Given a context of PlainTime with full milliseconds, the maximum is 86400000 and stands for the time 24:00 (midnight at end of day), else the maximum is 86399999 in every different context. Leapseconds are never counted.
  - MICRO_OF_DAY
```
public static final ProportionalElement<Long,PlainTime> MICRO_OF_DAY
```
    Element with the day time in microseconds in the value range 0-86400000000.
    
    Given a context of PlainTime with full microseconds, the maximum is 86400000000 and stands for the time 24:00 (midnight at end of day), else the maximum is 86399999999 in every different context. Leapseconds are never counted.
  - NANO_OF_DAY
```
public static final ProportionalElement<Long,PlainTime> NANO_OF_DAY
```
    Element with the day time in nanoseconds in the value range 0-86400000000000.
    
    Given any context of PlainTime, the maximum is always 86400000000000 and stands for the time 24:00 (midnight at end of day), else the maximum is 86399999999999 in every different context. Leapseconds are never counted.
    
    Example:
```
  import static net.time4j.ClockUnit.HOURS;
  import static net.time4j.PlainTime.NANO_OF_DAY;

  PlainTime time =
      PlainTime.midnightAtStartOfDay().plus(6, HOURS); // T06:00
  System.out.println(
      time.get(NANO_OF_DAY.ratio())
          .multiply(BigDecimal.ofHour(100)).stripTrailingZeros()
      + "% of day are over.");
  // Output: 25% of day are over.
 
```
  - DECIMAL_HOUR
```
public static final ZonalElement<BigDecimal> DECIMAL_HOUR
```
    Decimal hour in the value range 0.0 inclusive until 24.0 exclusive (inclusive in PlainTime).
    
    This element does not define any base unit.
  - DECIMAL_MINUTE
```
public static final ZonalElement<BigDecimal> DECIMAL_MINUTE
```
    Decimal minute in the value range 0.0 inclusive until 60.0 exclusive.
    
    This element does not define any base unit.
  - DECIMAL_SECOND
```
public static final ZonalElement<BigDecimal> DECIMAL_SECOND
```
    Decimal second in the value range 0.0 inclusive until 60.0 exclusive.
    
    This element does not define any base unit.
  - PRECISION
```
public static final ChronoElement<ClockUnit> PRECISION
```
    Defines the precision as the smallest non-zero time element and truncates time parts of higher precision if necessary.
    
    Setting higher precisions than available is without any effect. But setting lower precisions can truncate data however. Examples:
```
  // reading of precision -------------------------------------
  PlainTime time = PlainTime.of(12, 26, 52, 987654000);
  System.out.println(time.get(PRECISION)); // Output: MICROS

  // setting of precision -------------------------------------
  PlainTime time = PlainTime.of(12, 26, 52, 987654000);
  System.out.println(time.with(PRECISION, ClockUnit.MILLIS));
  // Output: T12:26:52,987
 
```
    This element does not define any base unit.
- Method Detail
  - getHour
```
public int getHour()
```
    Description copied from interface: WallTime
    
    Yields the hour of day.
    
    Specified by:
    
    getHour in interface WallTime
    
    Returns:
    
    hour in range 0 - 24 (the value 24 is only allowed if minute and second have the value 0)
  - getMinute
```
public int getMinute()
```
    Description copied from interface: WallTime
    
    Liefert die Minute (der aktuellen Stunde).
    
    Specified by:
    
    getMinute in interface WallTime
    
    Returns:
    
    minute in range 0 - 59
  - getSecond
```
public int getSecond()
```
    Description copied from interface: WallTime
    
    Yields the second of minute.
    
    Given this context and the fact that this interface describes an analogue clock without UTC reference, the special leapsecond value 60 cannot be supported.
    
    Specified by:
    
    getSecond in interface WallTime
    
    Returns:
    
    second in range 0 - 59
  - getNanosecond
```
public int getNanosecond()
```
    Description copied from interface: WallTime
    
    Yields the nanosecond.
    
    Implementations which are not capable of nanosecond precision will just yield 0 or another suitable rounded value.
    
    Specified by:
    
    getNanosecond in interface WallTime
    
    Returns:
    
    nanosecond in range 0 - 999,999,999
  - midnightAtStartOfDay
```
public static PlainTime midnightAtStartOfDay()
```
    Yields midnight at the start of the day.
    
    Returns:
    
    midnight at the start of day T00:00
    
    See Also:
    
    PlainTime.midnightAtEndOfDay()
  - midnightAtEndOfDay
```
public static PlainTime midnightAtEndOfDay()
```
    Yields midnight at the end of the day, that is midnight at the start of the following day.
    
    Returns:
    
    midnight at the end of day T24:00
    
    See Also:
    
    PlainTime.midnightAtStartOfDay()
  - of
```
public static PlainTime of(int hour)
```
    Creates a wall time as full hour.
    
    Parameters:
    
    hour - iso-hour of day in the range 0-24
    
    Returns:
    
    cached full hour
    
    Throws:
    
    IllegalArgumentException - if given hour is out of range
  - of
```
public static PlainTime of(int hour,
                           int minute)
```
    Creates a wall time with hour and minute.
    
    Parameters:
    
    hour - hour of day in the range 0-23 or 24 if the given minute equals to 0
    
    minute - minute in the range 0-59
    
    Returns:
    
    new or cached wall time
    
    Throws:
    
    IllegalArgumentException - if any argument is out of range
  - of
```
public static PlainTime of(int hour,
                           int minute,
                           int second)
```
    Creates a wall time with hour, minute and second.
    
    Parameters:
    
    hour - hour in the range 0-23 or 24 if the other arguments are equal to 0
    
    minute - minute in the range 0-59
    
    second - second in the range 0-59
    
    Returns:
    
    new or cached wall time
    
    Throws:
    
    IllegalArgumentException - if any argument is out of range
  - of
```
public static PlainTime of(int hour,
                           int minute,
                           int second,
                           int nanosecond)
```
    Creates a wall time with hour, minute, second and nanosecond.
    
    Parameters:
    
    hour - hour in the range 0-23 or 24 if the other argumenta equal to 0
    
    minute - minute in the range 0-59
    
    second - second in the range 0-59
    
    nanosecond - nanosecond in the range 0-999,999,999
    
    Returns:
    
    new or cached wall time
    
    Throws:
    
    IllegalArgumentException - if any argument is out of range
    
    See Also:
    
    PlainTime.of(int), PlainTime.of(int, int), PlainTime.of(int, int, int), PlainTime.NANO_OF_SECOND
  - of
```
public static PlainTime of(BigDecimal decimal)
```
    Creates a wall time by given decimal hour.
    
    Parameters:
    
    decimal - decimal hour of day in the range [0.0-24.0]
    
    Returns:
    
    new or cached wall time
    
    Throws:
    
    IllegalArgumentException - if the argument is out of range
    
    See Also:
    
    PlainTime.DECIMAL_HOUR
  - from
```
public static PlainTime from(WallTime time)
```
    Common conversion method.
    
    Parameters:
    
    time - ISO-time
    
    Returns:
    
    PlainTime
  - roll
```
public DayCycles roll(long amount,
                      ClockUnit unit)
```
    Rolls this time by the given duration (as amount and unit) and also counts possible day overflow.
    
    Parameters:
    
    amount - amount to be added (maybe negative)
    
    unit - time unit
    
    Returns:
    
    result of rolling including possible day overflow
    
    See Also:
    
    plus(long, IsoTimeUnit)
  - localFormatter
```
public static <P extends ChronoPattern<P>> TemporalFormatter<PlainTime> localFormatter(String formatPattern,
                                                                                       P patternType)
```
    Creates a new formatter which uses the given pattern in the default locale for formatting and parsing plain times.
    
    Type Parameters:
    
    P - generic pattern type
    
    Parameters:
    
    formatPattern - format definition as pattern
    
    patternType - pattern dialect
    
    Returns:
    
    format object for formatting PlainTime-objects using system locale
    
    Throws:
    
    IllegalArgumentException - if resolving of pattern fails
    
    Since:
    
    3.0
  - localFormatter
```
public static TemporalFormatter<PlainTime> localFormatter(DisplayMode mode)
```
    Creates a new formatter which uses the given display mode in the default locale for formatting and parsing plain times.
    
    Parameters:
    
    mode - formatting style
    
    Returns:
    
    format object for formatting PlainTime-objects using system locale
    
    Throws:
    
    IllegalStateException - if format pattern cannot be retrieved
    
    Since:
    
    3.0
  - formatter
```
public static <P extends ChronoPattern<P>> TemporalFormatter<PlainTime> formatter(String formatPattern,
                                                                                  P patternType,
                                                                                  Locale locale)
```
    Creates a new formatter which uses the given pattern and locale for formatting and parsing plain times.
    
    Type Parameters:
    
    P - generic pattern type
    
    Parameters:
    
    formatPattern - format definition as pattern
    
    patternType - pattern dialect
    
    locale - locale setting
    
    Returns:
    
    format object for formatting PlainTime-objects using given locale
    
    Throws:
    
    IllegalArgumentException - if resolving of pattern fails
    
    Since:
    
    3.0
    
    See Also:
    
    PlainTime.localFormatter(String, ChronoPattern)
  - formatter
```
public static TemporalFormatter<PlainTime> formatter(DisplayMode mode,
                                                     Locale locale)
```
    Creates a new formatter which uses the given display mode and locale for formatting and parsing plain times.
    
    Parameters:
    
    mode - formatting style
    
    locale - locale setting
    
    Returns:
    
    format object for formatting PlainTime-objects using given locale
    
    Throws:
    
    IllegalStateException - if format pattern cannot be retrieved
    
    Since:
    
    3.0
    
    See Also:
    
    PlainTime.localFormatter(DisplayMode)
  - equals
```
public boolean equals(Object obj)
```
    Compares the full state, that is hour, minute, second and nanosecond of this instance and given argument.
    
    Specified by:
    
    equals in class TimePoint<IsoTimeUnit,PlainTime>
    
    See Also:
    
    TimePoint.compareTo(TimePoint)
  - hashCode
```
public int hashCode()
```
    Description copied from class: TimePoint
    
    Subclasses must redefine this method corresponding to the behaviour of equals().
    
    Specified by:
    
    hashCode in class TimePoint<IsoTimeUnit,PlainTime>
  - isBefore
```
public boolean isBefore(PlainTime time)
```
    Description copied from interface: Temporal
    
    Queries if this object is before given object on a timeline.
    
    Specified by:
    
    isBefore in interface Temporal<PlainTime>
    
    Parameters:
    
    time - object this instance is compared to
    
    Returns:
    
    true if this instance is temporally before temporal else false
  - isAfter
```
public boolean isAfter(PlainTime time)
```
    Description copied from interface: Temporal
    
    Queries if this object is after given object on a timeline.
    
    Specified by:
    
    isAfter in interface Temporal<PlainTime>
    
    Parameters:
    
    time - object this instance is compared to
    
    Returns:
    
    true if this instance is temporally after temporal else false
  - isSimultaneous
```
public boolean isSimultaneous(PlainTime time)
```
    Description copied from interface: Temporal
    
    Queries if this object and given object have the same position on the time axis.
    
    Is equivalent to !isAfter(temporal) && !isBefore(temporal). This method differs from the Object-method equals() such that first the comparison type must be a temporal one and second that only temporal-only state will be considered.
    
    Specified by:
    
    isSimultaneous in interface Temporal<PlainTime>
    
    Parameters:
    
    time - object this instance is compared to
    
    Returns:
    
    true if this instance is temporally equal to temporal else false
  - isMidnight
```
public boolean isMidnight()
```
    Is this instance at midnight, either at start or at end of day?
    
    Returns:
    
    boolean
  - compareTo
```
public int compareTo(PlainTime time)
```
    Defines a natural order which is solely based on the timeline order.
    
    The natural order is consistent with equals().
    
    Specified by:
    
    compareTo in interface Comparable<PlainTime>
    
    Specified by:
    
    compareTo in class TimePoint<IsoTimeUnit,PlainTime>
    
    See Also:
    
    PlainTime.isBefore(PlainTime), PlainTime.isAfter(PlainTime)
  - toString
```
public String toString()
```
    Dependent on the precision of this instance, this method yields a canonical representation in one of following formats (CLDR-syntax):
    - 'T'HH
    - 'T'HH:mm
    - 'T'HH:mm:ss
    - 'T'HH:mm:ss,SSS
    - 'T'HH:mm:ss,SSSSSS
    - 'T'HH:mm:ss,SSSSSSSSS
    The fraction part will be preceded by a comma as recommended by ISO unless the system property "net.time4j.format.iso.decimal.dot" was set to "true".
    Specified by:
    
    toString in interface WallTime
    
    Specified by:
    
    toString in class TimePoint<IsoTimeUnit,PlainTime>
    
    Returns:
    
    canonical ISO-8601-formatted string
  - axis
```
public static TimeAxis<IsoTimeUnit,PlainTime> axis()
```
    Provides a static access to the associated time axis respective chronology which contains the chronological rules.
    
    Returns:
    
    chronological system as time axis (never null)

AM_PM_OF_DAY	AM	AM	...	AM	PM	PM	...	PM	AM
ISO-8601-Wert	T0	T1	...	T11	T12	T13	...	T23	T24

CLOCK_HOUR_OF_AMPM	12	1	...	11	12	1	...	11	12
ISO-8601-Wert	T0	T1	...	T11	T12	T13	...	T23	T24

CLOCK_HOUR_OF_DAY	24	1	...	11	12	13	...	23	24
ISO-8601-Wert	T0	T1	...	T11	T12	T13	...	T23	T24

DIGITAL_HOUR_OF_AMPM	0	1	...	11	0	1	...	11	0
ISO-8601-Wert	T0	T1	...	T11	T12	T13	...	T23	T24

DIGITAL_HOUR_OF_DAY	0	1	...	11	12	13	...	23	0
ISO-8601-Wert	T0	T1	...	T11	T12	T13	...	T23	T24

Class PlainTime

Field Summary

Method Summary

Methods inherited from class net.time4j.engine.TimePoint

Methods inherited from class net.time4j.engine.ChronoEntity

Methods inherited from class java.lang.Object

Field Detail

COMPONENT

AM_PM_OF_DAY

CLOCK_HOUR_OF_AMPM

CLOCK_HOUR_OF_DAY

DIGITAL_HOUR_OF_AMPM

DIGITAL_HOUR_OF_DAY

ISO_HOUR

MINUTE_OF_HOUR

MINUTE_OF_DAY

SECOND_OF_MINUTE

SECOND_OF_DAY

MILLI_OF_SECOND

MICRO_OF_SECOND

NANO_OF_SECOND

MILLI_OF_DAY

MICRO_OF_DAY

NANO_OF_DAY

DECIMAL_HOUR

DECIMAL_MINUTE

DECIMAL_SECOND

PRECISION

Method Detail

getHour

getMinute

getSecond

getNanosecond

midnightAtStartOfDay

midnightAtEndOfDay

of

of

of

of

of

from

roll

localFormatter

localFormatter

formatter

formatter

equals

hashCode

isBefore

isAfter

isSimultaneous

isMidnight

compareTo

toString

axis