Java WithAdjuster.doWithAdjustment方法代码示例

import java.time.calendrical.DateTime.WithAdjuster; //导入方法依赖的package包/类
@Override
public Instant with(WithAdjuster adjuster) {

  return (Instant) adjuster.doWithAdjustment(this);
}
 

import java.time.calendrical.DateTime.WithAdjuster; //导入方法依赖的package包/类
/**
 * Returns an adjusted time based on this time.
 * <p>
 * This adjusts the time according to the rules of the specified adjuster. A simple adjuster might simply
 * set the one of the fields, such as the hour field. A more complex adjuster might set the time to the last
 * hour of the day. The adjuster is responsible for handling special cases, such as the varying lengths of
 * month and leap years.
 * <p>
 * For example, were there to be a class {@code AmPm} implementing the adjuster interface then this method
 * could be used to change the AM/PM value.
 * <p>
 * This instance is immutable and unaffected by this method call.
 * 
 * @param adjuster the adjuster to use, not null
 * @return an {@code OffsetTime} based on this time with the adjustment made, not null
 * @throws DateTimeException if the adjustment cannot be made
 */
@Override
public OffsetTime with(WithAdjuster adjuster) {

  if (adjuster instanceof LocalTime) {
    return with((LocalTime) adjuster, this.offset);
  } else if (adjuster instanceof ZoneOffset) {
    return with(this.time, (ZoneOffset) adjuster);
  } else if (adjuster instanceof OffsetTime) {
    return (OffsetTime) adjuster;
  }
  return (OffsetTime) adjuster.doWithAdjustment(this);
}
 

import java.time.calendrical.DateTime.WithAdjuster; //导入方法依赖的package包/类
/**
 * Returns an adjusted year-month based on this year-month.
 * <p>
 * This adjusts the year-month 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
 * year-month to the next month that Halley's comet will pass the Earth.
 * <p>
 * In addition, all principal classes implement the {@link WithAdjuster} interface, including this one. For
 * example, {@link Month} implements the adjuster interface. As such, this code will compile and run:
 * 
 * <pre>
   *  yearMonth.with(month);
   * </pre>
 * <p>
 * This instance is immutable and unaffected by this method call.
 * 
 * @param adjuster the adjuster to use, not null
 * @return a {@code YearMonth} based on this year-month with the adjustment made, not null
 * @throws DateTimeException if the adjustment cannot be made
 */
@Override
public YearMonth with(WithAdjuster adjuster) {

  if (adjuster instanceof YearMonth) {
    return (YearMonth) adjuster;
  }
  return (YearMonth) adjuster.doWithAdjustment(this);
}
 

import java.time.calendrical.DateTime.WithAdjuster; //导入方法依赖的package包/类
/**
 * Returns an adjusted date-time based on this date-time.
 * <p>
 * This adjusts the 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-time
 * to the last day of the month. A selection of common adjustments is provided in {@link DateTimeAdjusters}.
 * 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.
 * <p>
 * In addition, all principal classes implement the {@link WithAdjuster} interface, including this one. For
 * example, {@link LocalDate} implements the adjuster interface. As such, this code will compile and run:
 * 
 * <pre>
   *  dateTime.with(date);
   * </pre>
 * <p>
 * This instance is immutable and unaffected by this method call.
 * 
 * @param adjuster the adjuster to use, not null
 * @return an {@code OffsetDateTime} based on this date-time with the adjustment made, not null
 * @throws DateTimeException if the adjustment cannot be made
 */
@Override
public OffsetDateTime with(WithAdjuster adjuster) {

  if (adjuster instanceof LocalDate || adjuster instanceof LocalTime || adjuster instanceof LocalDateTime) {
    return with(this.dateTime.with(adjuster), this.offset);
  } else if (adjuster instanceof ZoneOffset) {
    return with(this.dateTime, (ZoneOffset) adjuster);
  } else if (adjuster instanceof OffsetDateTime) {
    return (OffsetDateTime) adjuster;
  }
  return (OffsetDateTime) adjuster.doWithAdjustment(this);
}
 

import java.time.calendrical.DateTime.WithAdjuster; //导入方法依赖的package包/类
/**
 * Returns an adjusted time based on this time.
 * <p>
 * This adjusts the time according to the rules of the specified adjuster. A simple adjuster might simply
 * set the one of the fields, such as the hour field. A more complex adjuster might set the time to the last
 * hour of the day. The adjuster is responsible for handling special cases, such as the varying lengths of
 * month and leap years.
 * <p>
 * For example, were there to be a class {@code AmPm} implementing the adjuster interface then this method
 * could be used to change the AM/PM value.
 * <p>
 * This instance is immutable and unaffected by this method call.
 * 
 * @param adjuster the adjuster to use, not null
 * @return a {@code LocalTime} based on this time with the adjustment made, not null
 * @throws DateTimeException if the adjustment cannot be made
 */
@Override
public LocalTime with(WithAdjuster adjuster) {

  if (adjuster instanceof LocalTime) {
    return (LocalTime) adjuster;
  }
  return (LocalTime) adjuster.doWithAdjustment(this);
}
 

import java.time.calendrical.DateTime.WithAdjuster; //导入方法依赖的package包/类
/**
 * Returns an adjusted date based on this date.
 * <p>
 * This adjusts the date 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 {@link DateTimeAdjusters}. 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.
 * <p>
 * In addition, all principal classes implement the {@link WithAdjuster} interface, including this one. For
 * example, {@link Month} implements the adjuster interface. As such, this code will compile and run:
 * 
 * <pre>
   *  date.with(Month.JULY);
   * </pre>
 * <p>
 * This instance is immutable and unaffected by this method call.
 * 
 * @param adjuster the adjuster to use, not null
 * @return a {@code LocalDate} based on this date with the adjustment made, not null
 * @throws DateTimeException if the adjustment cannot be made
 */
@Override
public LocalDate with(WithAdjuster adjuster) {

  if (adjuster instanceof LocalDate) {
    return (LocalDate) adjuster;
  }
  return (LocalDate) adjuster.doWithAdjustment(this);
}
 

import java.time.calendrical.DateTime.WithAdjuster; //导入方法依赖的package包/类
/**
 * Returns an adjusted date-time based on this date-time.
 * <p>
 * This adjusts the 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-time
 * to the last day of the month. A selection of common adjustments is provided in {@link DateTimeAdjusters}.
 * 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.
 * <p>
 * In addition, all principal classes implement the {@link WithAdjuster} interface, including this one. For
 * example, {@link LocalDate} implements the adjuster interface. As such, this code will compile and run:
 * 
 * <pre>
   *  dateTime.with(date);
   * </pre>
 * <p>
 * This instance is immutable and unaffected by this method call.
 * 
 * @param adjuster the adjuster to use, not null
 * @return a {@code LocalDateTime} based on this date-time with the adjustment made, not null
 * @throws DateTimeException if the adjustment cannot be made
 */
@Override
public LocalDateTime with(WithAdjuster adjuster) {

  if (adjuster instanceof LocalDate) {
    return with((LocalDate) adjuster, this.time);
  } else if (adjuster instanceof LocalTime) {
    return with(this.date, (LocalTime) adjuster);
  } else if (adjuster instanceof LocalDateTime) {
    return (LocalDateTime) adjuster;
  }
  return (LocalDateTime) adjuster.doWithAdjustment(this);
}
 

import java.time.calendrical.DateTime.WithAdjuster; //导入方法依赖的package包/类
/**
 * Returns an adjusted year based on this year.
 * <p>
 * This adjusts the year according to the rules of the specified adjuster.
 * <p>
 * This instance is immutable and unaffected by this method call.
 * 
 * @param adjuster the adjuster to use, not null
 * @return a {@code LocalDate} based on this date with the adjustment made, not null
 * @throws DateTimeException if the adjustment cannot be made
 */
@Override
public Year with(WithAdjuster adjuster) {

  if (adjuster instanceof Year) {
    return (Year) adjuster;
  }
  return (Year) adjuster.doWithAdjustment(this);
}
 

import java.time.calendrical.DateTime.WithAdjuster; //导入方法依赖的package包/类
/**
 * Returns an adjusted date based on this date.
 * <p>
 * This adjusts the date 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 {@link DateTimeAdjusters}. 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.
 * <p>
 * In addition, all principal classes implement the {@link WithAdjuster} interface, including this one. For
 * example, {@link Month} implements the adjuster interface. As such, this code will compile and run:
 * 
 * <pre>
   *  date.with(Month.JULY);
   * </pre>
 * <p>
 * This instance is immutable and unaffected by this method call.
 * 
 * @param adjuster the adjuster to use, not null
 * @return an {@code OffsetDate} based on this date with the adjustment made, not null
 * @throws DateTimeException if the adjustment cannot be made
 */
@Override
public OffsetDate with(WithAdjuster adjuster) {

  if (adjuster instanceof LocalDate) {
    return with((LocalDate) adjuster, this.offset);
  } else if (adjuster instanceof ZoneOffset) {
    return with(this.date, (ZoneOffset) adjuster);
  } else if (adjuster instanceof OffsetDate) {
    return (OffsetDate) adjuster;
  }
  return (OffsetDate) adjuster.doWithAdjustment(this);
}