src/share/classes/java/time/chrono/JapaneseChronology.java

Print this page

        

@@ -52,29 +52,26 @@
  * 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 java.io.Serializable;
+import java.time.Clock;
 import java.time.DateTimeException;
+import java.time.Instant;
 import java.time.LocalDate;
-import java.time.temporal.Chrono;
 import java.time.temporal.ChronoField;
-import java.time.temporal.ChronoLocalDate;
-import java.time.temporal.Era;
-import java.time.temporal.ISOChrono;
 import java.time.temporal.TemporalAccessor;
 import java.time.temporal.ValueRange;
-import java.time.temporal.Year;
+import java.time.Year;
+import java.time.ZoneId;
 import java.util.Arrays;
 import java.util.Calendar;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
-import java.util.Map;
 
 import sun.util.calendar.CalendarSystem;
 import sun.util.calendar.LocalGregorianCalendar;
 
 /**

@@ -91,11 +88,11 @@
  * <h3>Specification for implementors</h3>
  * This class is immutable and thread-safe.
  *
  * @since 1.8
  */
-public final class JapaneseChrono extends Chrono<JapaneseChrono> implements Serializable {
+public final class JapaneseChronology extends Chronology implements Serializable {
     // TODO: definition for unknown era may break requirement that year-of-era >= 1
 
     static final LocalGregorianCalendar JCAL =
         (LocalGregorianCalendar) CalendarSystem.forName("japanese");
 

@@ -103,47 +100,47 @@
     static final Locale LOCALE = Locale.forLanguageTag("ja-JP-u-ca-japanese");
 
     /**
      * Singleton instance for Japanese chronology.
      */
-    public static final JapaneseChrono INSTANCE = new JapaneseChrono();
+    public static final JapaneseChronology INSTANCE = new JapaneseChronology();
 
     /**
      * The singleton instance for the before Meiji era ( - 1868-09-07)
      * which has the value -999.
      */
-    public static final Era<JapaneseChrono> ERA_SEIREKI = JapaneseEra.SEIREKI;
+    public static final Era ERA_SEIREKI = JapaneseEra.SEIREKI;
     /**
      * The singleton instance for the Meiji era (1868-09-08 - 1912-07-29)
      * which has the value -1.
      */
-    public static final Era<JapaneseChrono> ERA_MEIJI = JapaneseEra.MEIJI;
+    public static final Era ERA_MEIJI = JapaneseEra.MEIJI;
     /**
      * The singleton instance for the Taisho era (1912-07-30 - 1926-12-24)
      * which has the value 0.
      */
-    public static final Era<JapaneseChrono> ERA_TAISHO = JapaneseEra.TAISHO;
+    public static final Era ERA_TAISHO = JapaneseEra.TAISHO;
     /**
      * The singleton instance for the Showa era (1926-12-25 - 1989-01-07)
      * which has the value 1.
      */
-    public static final Era<JapaneseChrono> ERA_SHOWA = JapaneseEra.SHOWA;
+    public static final Era ERA_SHOWA = JapaneseEra.SHOWA;
     /**
      * The singleton instance for the Heisei era (1989-01-08 - current)
      * which has the value 2.
      */
-    public static final Era<JapaneseChrono> ERA_HEISEI = JapaneseEra.HEISEI;
+    public static final Era ERA_HEISEI = JapaneseEra.HEISEI;
     /**
      * Serialization version.
      */
     private static final long serialVersionUID = 459996390165777884L;
 
     //-----------------------------------------------------------------------
     /**
      * Restricted constructor.
      */
-    private JapaneseChrono() {
+    private JapaneseChronology() {
     }
 
     /**
      * Resolve singleton.
      *

@@ -155,12 +152,12 @@
 
     //-----------------------------------------------------------------------
     /**
      * Gets the ID of the chronology - 'Japanese'.
      * <p>
-     * The ID uniquely identifies the {@code Chrono}.
-     * It can be used to lookup the {@code Chrono} using {@link #of(String)}.
+     * The ID uniquely identifies the {@code Chronology}.
+     * It can be used to lookup the {@code Chronology} using {@link #of(String)}.
      *
      * @return the chronology ID - 'Japanese'
      * @see #getCalendarType()
      */
     @Override

@@ -171,11 +168,11 @@
     /**
      * Gets the calendar type of the underlying calendar system - 'japanese'.
      * <p>
      * The calendar type is an identifier defined by the
      * <em>Unicode Locale Data Markup Language (LDML)</em> specification.
-     * It can be used to lookup the {@code Chrono} using {@link #of(String)}.
+     * It can be used to lookup the {@code Chronology} using {@link #of(String)}.
      * It can also be used as part of a locale, accessible via
      * {@link Locale#getUnicodeLocaleType(String)} with the key 'ca'.
      *
      * @return the calendar system type - 'japanese'
      * @see #getId()

@@ -185,36 +182,71 @@
         return "japanese";
     }
 
     //-----------------------------------------------------------------------
     @Override
-    public ChronoLocalDate<JapaneseChrono> date(Era<JapaneseChrono> era, int yearOfEra, int month, int dayOfMonth) {
+    public JapaneseDate date(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);
     }
 
     @Override
-    public ChronoLocalDate<JapaneseChrono> date(int prolepticYear, int month, int dayOfMonth) {
+    public JapaneseDate date(int prolepticYear, int month, int dayOfMonth) {
         return new JapaneseDate(LocalDate.of(prolepticYear, month, dayOfMonth));
     }
 
     @Override
-    public ChronoLocalDate<JapaneseChrono> dateYearDay(int prolepticYear, int dayOfYear) {
+    public JapaneseDate dateYearDay(int prolepticYear, int dayOfYear) {
         LocalDate date = LocalDate.ofYearDay(prolepticYear, dayOfYear);
         return date(prolepticYear, date.getMonthValue(), date.getDayOfMonth());
     }
 
     @Override
-    public ChronoLocalDate<JapaneseChrono> date(TemporalAccessor temporal) {
+    public JapaneseDate date(TemporalAccessor temporal) {
         if (temporal instanceof JapaneseDate) {
             return (JapaneseDate) temporal;
         }
         return new JapaneseDate(LocalDate.from(temporal));
     }
 
+    @Override
+    public JapaneseDate dateYearDay(Era era, int yearOfEra, int dayOfYear) {
+        return dateYearDay(prolepticYear(era, yearOfEra), dayOfYear);
+    }
+
+    @Override
+    public JapaneseDate dateNow() {
+        return dateNow(Clock.systemDefaultZone());
+    }
+
+    @Override
+    public JapaneseDate dateNow(ZoneId zone) {
+        return dateNow(Clock.system(zone));
+    }
+
+    @Override
+    public JapaneseDate dateNow(Clock clock) {
+        return date(LocalDate.now(clock));
+    }
+
+    @Override
+    public ChronoLocalDateTime<JapaneseDate> localDateTime(TemporalAccessor temporal) {
+        return (ChronoLocalDateTime<JapaneseDate>)super.localDateTime(temporal);
+    }
+
+    @Override
+    public ChronoZonedDateTime<JapaneseDate> zonedDateTime(TemporalAccessor temporal) {
+        return (ChronoZonedDateTime<JapaneseDate>)super.zonedDateTime(temporal);
+    }
+
+    @Override
+    public ChronoZonedDateTime<JapaneseDate> zonedDateTime(Instant instant, ZoneId zone) {
+        return (ChronoZonedDateTime<JapaneseDate>)super.zonedDateTime(instant, zone);
+    }
+
     //-----------------------------------------------------------------------
     /**
      * Checks if the specified year is a leap year.
      * <p>
      * Japanese calendar leap years occur exactly in line with ISO leap years.

@@ -224,15 +256,15 @@
      * @param prolepticYear  the proleptic-year to check, not validated for range
      * @return true if the year is a leap year
      */
     @Override
     public boolean isLeapYear(long prolepticYear) {
-        return ISOChrono.INSTANCE.isLeapYear(prolepticYear);
+        return IsoChronology.INSTANCE.isLeapYear(prolepticYear);
     }
 
     @Override
-    public int prolepticYear(Era<JapaneseChrono> era, int yearOfEra) {
+    public int prolepticYear(Era era, int yearOfEra) {
         if (era instanceof JapaneseEra == false) {
             throw new DateTimeException("Era must be JapaneseEra");
         }
         JapaneseEra jera = (JapaneseEra) era;
         int gregorianYear = jera.getPrivateEra().getSinceDate().getYear() + yearOfEra - 1;

@@ -259,17 +291,17 @@
      * @param eraValue  the era value
      * @return the Japanese {@code Era} for the given numeric era value
      * @throws DateTimeException if {@code eraValue} is invalid
      */
     @Override
-    public Era<JapaneseChrono> eraOf(int eraValue) {
+    public Era eraOf(int eraValue) {
         return JapaneseEra.of(eraValue);
     }
 
     @Override
-    public List<Era<JapaneseChrono>> eras() {
-        return Arrays.<Era<JapaneseChrono>>asList(JapaneseEra.values());
+    public List<Era> eras() {
+        return Arrays.<Era>asList(JapaneseEra.values());
     }
 
     //-----------------------------------------------------------------------
     @Override
     public ValueRange range(ChronoField field) {