Java TemporalAmount.subtractFrom方法代码示例

import java.time.temporal.TemporalAmount; //导入方法依赖的package包/类
/**
 * Returns a copy of this date-time with the specified amount subtracted.
 * <p>
 * This returns a {@code LocalDateTime}, based on this one, with the specified amount subtracted.
 * The amount is typically {@link Period} or {@link Duration} but may be
 * any other type implementing the {@link TemporalAmount} interface.
 * <p>
 * The calculation is delegated to the amount object by calling
 * {@link TemporalAmount#subtractFrom(Temporal)}. The amount implementation is free
 * to implement the subtraction in any way it wishes, however it typically
 * calls back to {@link #minus(long, TemporalUnit)}. Consult the documentation
 * of the amount implementation to determine if it can be successfully subtracted.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param amountToSubtract  the amount to subtract, not null
 * @return a {@code LocalDateTime} based on this date-time with the subtraction made, not null
 * @throws DateTimeException if the subtraction cannot be made
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public LocalDateTime minus(TemporalAmount amountToSubtract) {
    if (amountToSubtract instanceof Period) {
        Period periodToSubtract = (Period) amountToSubtract;
        return with(date.minus(periodToSubtract), time);
    }
    Objects.requireNonNull(amountToSubtract, "amountToSubtract");
    return (LocalDateTime) amountToSubtract.subtractFrom(this);
}
 

import java.time.temporal.TemporalAmount; //导入方法依赖的package包/类
/**
 * Returns a copy of this date-time with the specified amount subtracted.
 * <p>
 * This returns a {@code ZonedDateTime}, based on this one, with the specified amount subtracted.
 * The amount is typically {@link Period} or {@link Duration} but may be
 * any other type implementing the {@link TemporalAmount} interface.
 * <p>
 * The calculation is delegated to the amount object by calling
 * {@link TemporalAmount#subtractFrom(Temporal)}. The amount implementation is free
 * to implement the subtraction in any way it wishes, however it typically
 * calls back to {@link #minus(long, TemporalUnit)}. Consult the documentation
 * of the amount implementation to determine if it can be successfully subtracted.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param amountToSubtract  the amount to subtract, not null
 * @return a {@code ZonedDateTime} based on this date-time with the subtraction made, not null
 * @throws DateTimeException if the subtraction cannot be made
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public ZonedDateTime minus(TemporalAmount amountToSubtract) {
    if (amountToSubtract instanceof Period) {
        Period periodToSubtract = (Period) amountToSubtract;
        return resolveLocal(dateTime.minus(periodToSubtract));
    }
    Objects.requireNonNull(amountToSubtract, "amountToSubtract");
    return (ZonedDateTime) amountToSubtract.subtractFrom(this);
}
 

import java.time.temporal.TemporalAmount; //导入方法依赖的package包/类
/**
 * Returns a copy of this date with the specified amount subtracted.
 * <p>
 * This returns a {@code LocalDate}, based on this one, with the specified amount subtracted.
 * The amount is typically {@link Period} but may be any other type implementing
 * the {@link TemporalAmount} interface.
 * <p>
 * The calculation is delegated to the amount object by calling
 * {@link TemporalAmount#subtractFrom(Temporal)}. The amount implementation is free
 * to implement the subtraction in any way it wishes, however it typically
 * calls back to {@link #minus(long, TemporalUnit)}. Consult the documentation
 * of the amount implementation to determine if it can be successfully subtracted.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param amountToSubtract  the amount to subtract, not null
 * @return a {@code LocalDate} based on this date with the subtraction made, not null
 * @throws DateTimeException if the subtraction cannot be made
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public LocalDate minus(TemporalAmount amountToSubtract) {
    if (amountToSubtract instanceof Period) {
        Period periodToSubtract = (Period) amountToSubtract;
        return minusMonths(periodToSubtract.toTotalMonths()).minusDays(periodToSubtract.getDays());
    }
    Objects.requireNonNull(amountToSubtract, "amountToSubtract");
    return (LocalDate) amountToSubtract.subtractFrom(this);
}
 

import java.time.temporal.TemporalAmount; //导入方法依赖的package包/类
/**
 * Returns a copy of this time with the specified amount subtracted.
 * <p>
 * This returns an {@code OffsetTime}, based on this one, with the specified amount subtracted.
 * The amount is typically {@link Duration} but may be any other type implementing
 * the {@link TemporalAmount} interface.
 * <p>
 * The calculation is delegated to the amount object by calling
 * {@link TemporalAmount#subtractFrom(Temporal)}. The amount implementation is free
 * to implement the subtraction in any way it wishes, however it typically
 * calls back to {@link #minus(long, TemporalUnit)}. Consult the documentation
 * of the amount implementation to determine if it can be successfully subtracted.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param amountToSubtract  the amount to subtract, not null
 * @return an {@code OffsetTime} based on this time with the subtraction made, not null
 * @throws DateTimeException if the subtraction cannot be made
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public OffsetTime minus(TemporalAmount amountToSubtract) {
    return (OffsetTime) amountToSubtract.subtractFrom(this);
}
 

import java.time.temporal.TemporalAmount; //导入方法依赖的package包/类
/**
 * Returns a copy of this date-time with the specified amount subtracted.
 * <p>
 * This returns an {@code OffsetDateTime}, based on this one, with the specified amount subtracted.
 * The amount is typically {@link Period} or {@link Duration} but may be
 * any other type implementing the {@link TemporalAmount} interface.
 * <p>
 * The calculation is delegated to the amount object by calling
 * {@link TemporalAmount#subtractFrom(Temporal)}. The amount implementation is free
 * to implement the subtraction in any way it wishes, however it typically
 * calls back to {@link #minus(long, TemporalUnit)}. Consult the documentation
 * of the amount implementation to determine if it can be successfully subtracted.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param amountToSubtract  the amount to subtract, not null
 * @return an {@code OffsetDateTime} based on this date-time with the subtraction made, not null
 * @throws DateTimeException if the subtraction cannot be made
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public OffsetDateTime minus(TemporalAmount amountToSubtract) {
    return (OffsetDateTime) amountToSubtract.subtractFrom(this);
}
 

import java.time.temporal.TemporalAmount; //导入方法依赖的package包/类
/**
 * Returns a copy of this instant with the specified amount subtracted.
 * <p>
 * This returns an {@code Instant}, based on this one, with the specified amount subtracted.
 * The amount is typically {@link Duration} but may be any other type implementing
 * the {@link TemporalAmount} interface.
 * <p>
 * The calculation is delegated to the amount object by calling
 * {@link TemporalAmount#subtractFrom(Temporal)}. The amount implementation is free
 * to implement the subtraction in any way it wishes, however it typically
 * calls back to {@link #minus(long, TemporalUnit)}. Consult the documentation
 * of the amount implementation to determine if it can be successfully subtracted.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param amountToSubtract  the amount to subtract, not null
 * @return an {@code Instant} based on this instant with the subtraction made, not null
 * @throws DateTimeException if the subtraction cannot be made
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public Instant minus(TemporalAmount amountToSubtract) {
    return (Instant) amountToSubtract.subtractFrom(this);
}
 

import java.time.temporal.TemporalAmount; //导入方法依赖的package包/类
/**
 * Returns a copy of this year with the specified amount subtracted.
 * <p>
 * This returns a {@code Year}, based on this one, with the specified amount subtracted.
 * The amount is typically {@link Period} but may be any other type implementing
 * the {@link TemporalAmount} interface.
 * <p>
 * The calculation is delegated to the amount object by calling
 * {@link TemporalAmount#subtractFrom(Temporal)}. The amount implementation is free
 * to implement the subtraction in any way it wishes, however it typically
 * calls back to {@link #minus(long, TemporalUnit)}. Consult the documentation
 * of the amount implementation to determine if it can be successfully subtracted.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param amountToSubtract  the amount to subtract, not null
 * @return a {@code Year} based on this year with the subtraction made, not null
 * @throws DateTimeException if the subtraction cannot be made
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public Year minus(TemporalAmount amountToSubtract) {
    return (Year) amountToSubtract.subtractFrom(this);
}
 

import java.time.temporal.TemporalAmount; //导入方法依赖的package包/类
/**
 * Returns a copy of this time with the specified amount subtracted.
 * <p>
 * This returns a {@code LocalTime}, based on this one, with the specified amount subtracted.
 * The amount is typically {@link Duration} but may be any other type implementing
 * the {@link TemporalAmount} interface.
 * <p>
 * The calculation is delegated to the amount object by calling
 * {@link TemporalAmount#subtractFrom(Temporal)}. The amount implementation is free
 * to implement the subtraction in any way it wishes, however it typically
 * calls back to {@link #minus(long, TemporalUnit)}. Consult the documentation
 * of the amount implementation to determine if it can be successfully subtracted.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param amountToSubtract  the amount to subtract, not null
 * @return a {@code LocalTime} based on this time with the subtraction made, not null
 * @throws DateTimeException if the subtraction cannot be made
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public LocalTime minus(TemporalAmount amountToSubtract) {
    return (LocalTime) amountToSubtract.subtractFrom(this);
}
 

import java.time.temporal.TemporalAmount; //导入方法依赖的package包/类
/**
 * Returns a copy of this year-month with the specified amount subtracted.
 * <p>
 * This returns a {@code YearMonth}, based on this one, with the specified amount subtracted.
 * The amount is typically {@link Period} but may be any other type implementing
 * the {@link TemporalAmount} interface.
 * <p>
 * The calculation is delegated to the amount object by calling
 * {@link TemporalAmount#subtractFrom(Temporal)}. The amount implementation is free
 * to implement the subtraction in any way it wishes, however it typically
 * calls back to {@link #minus(long, TemporalUnit)}. Consult the documentation
 * of the amount implementation to determine if it can be successfully subtracted.
 * <p>
 * This instance is immutable and unaffected by this method call.
 *
 * @param amountToSubtract  the amount to subtract, not null
 * @return a {@code YearMonth} based on this year-month with the subtraction made, not null
 * @throws DateTimeException if the subtraction cannot be made
 * @throws ArithmeticException if numeric overflow occurs
 */
@Override
public YearMonth minus(TemporalAmount amountToSubtract) {
    return (YearMonth) amountToSubtract.subtractFrom(this);
}