Package tech.units.indriya

Class AbstractQuantity<Q extends Quantity<Q>>

  • All Implemented Interfaces:
    Serializable, Comparable<Quantity<Q>>, Quantity<Q>, ComparableQuantity<Q>, tech.uom.lib.common.function.QuantityConverter<Q>, tech.uom.lib.common.function.UnitSupplier<Q>, tech.uom.lib.common.function.ValueSupplier<Number>
    Direct Known Subclasses:
    NumberQuantity, TemporalQuantity, TimeUnitQuantity
    @API(status=STABLE)
public abstract class AbstractQuantity<Q extends Quantity<Q>>
extends Object
implements ComparableQuantity<Q>, tech.uom.lib.common.function.UnitSupplier<Q>, tech.uom.lib.common.function.ValueSupplier<Number>

    This class represents the immutable result of a scalar quantity stated in a known unit.

    To avoid any loss of precision, known exact quantities (e.g. physical constants) should not be created from double constants but from their decimal representation.
    public static final Quantity<Velocity> C = NumberQuantity.parse("299792458 m/s").asType(Velocity.class); // Speed of Light (exact).

    Quantities can be converted to different units.
    Quantity<Velocity> milesPerHour = C.to(MILES_PER_HOUR); // Use double implementation (fast). System.out.println(milesPerHour); > 670616629.3843951 m/h

    Applications may sub-class AbstractQuantity for particular quantity types.
    // Quantity of type Mass based on double primitive types.
    public class MassAmount extends AbstractQuantity<Mass> {
    private final double kilograms; // Internal SI representation.
    private Mass(double kg) { kilograms = kg; }
    public static Mass of(double value, Unit<Mass> unit) {
    return new Mass(unit.getConverterTo(SI.KILOGRAM).convert(value));
    }
    public Unit<Mass> getUnit() { return SI.KILOGRAM; }
    public Double getValue() { return kilograms; }
    ...
    }

    // Complex number quantities.
    public class ComplexQuantity <Q extends Quantity>extends AbstractQuantity <Q>{
    public Complex getValue() { ... } // Assuming Complex is a Number.
    ...
    }

    // Specializations of complex numbers quantities.
    public final class Current extends ComplexQuantity<ElectricCurrent> {...}
    public final class Tension extends ComplexQuantity<ElectricPotential> {...}

    All instances of this class shall be immutable.

    Since:
    1.0
    Version:
    2.6 Oct 6, 2024
    Author:
    Werner Keil, Andi Huber
    See Also:
    Serialized Form

    • Constructor Detail

      • AbstractQuantity

        protected AbstractQuantity​(Unit<Q> unit)
        Constructor. Applies ABSOLUTE Scale if none was given.
        Parameters:
        unit - a unit

    • Method Detail

      • getValue

        public abstract Number getValue()
        Returns the numeric value of the quantity.
        Specified by:
        getValue in interface Quantity<Q extends Quantity<Q>>
        Specified by:
        getValue in interface tech.uom.lib.common.function.ValueSupplier<Q extends Quantity<Q>>
        Returns:
        the quantity value.

      • getUnit

        public Unit<Q> getUnit()
        Returns the measurement unit.
        Specified by:
        getUnit in interface Quantity<Q extends Quantity<Q>>
        Specified by:
        getUnit in interface tech.uom.lib.common.function.UnitSupplier<Q extends Quantity<Q>>
        Returns:
        the measurement unit.

      • to

        public ComparableQuantity<Q> to​(Unit<Q> anotherUnit)
        Returns this quantity after conversion to specified unit. The default implementation returns NumberQuantity.of(doubleValue(unit), unit) . If this quantity is already stated in the specified unit, then this quantity is returned and no conversion is performed.
        Specified by:
        to in interface ComparableQuantity<Q extends Quantity<Q>>
        Specified by:
        to in interface Quantity<Q extends Quantity<Q>>
        Specified by:
        to in interface tech.uom.lib.common.function.QuantityConverter<Q extends Quantity<Q>>
        Parameters:
        anotherUnit - the unit in which the returned quantity is stated.
        Returns:
        this quantity or a new quantity equivalent to this quantity stated in the specified unit.
        Throws:
        ArithmeticException - if the result is inexact and the quotient has a non-terminating decimal expansion.
        See Also:
        Quantity.to(Unit)

      • compareTo

        public int compareTo​(Quantity<Q> that)
        Compares this quantity to the specified quantity. The default implementation compares the value of both this quantity and the specified quantity stated in the same unit (this quantity's unit). If units are not the same, the unit of the specified quantity is converted.
        Specified by:
        compareTo in interface Comparable<Q extends Quantity<Q>>
        Parameters:
        that - Quantity to which this AbstractQuantity is to be compared.
        Returns:
        a negative integer, zero, or a positive integer as this quantity is less than, equal/equivalent to, or greater than the specified Measurement quantity.

      • equals

        public boolean equals​(Object obj)
        Compares this quantity against the specified object for strict equality (same unit and same amount).

        Similarly to the BigDecimal.equals(java.lang.Object) method which consider 2.0 and 2.00 as different objects because of different internal scales, quantities such as Quantities.getQuantity(3.0, KILOGRAM) Quantities.getQuantity(3, KILOGRAM) and Quantities.getQuantity("3 kg") might not be considered equals because of possible differences in their implementations.

        To compare quantities stated using different units or using different amount implementations the compareTo or isEquivalentTo(javax.measure.Quantity<Q>) methods should be used.

        Overrides:
        equals in class Object
        Parameters:
        obj - the object to compare with.
        Returns:
        this.getUnit.equals(obj.getUnit()) && this.getScale().equals(obj.getScale() && this.getValue().equals(obj.getValue())

      • hashCode

        public int hashCode()
        Returns the hash code for this quantity.
        Overrides:
        hashCode in class Object
        Returns:
        the hash code value.

      • toString

        public String toString()
        Returns the String representation of this quantity. The string produced for a given quantity is always the same; it is not affected by locale. This means that it can be used as a canonical string representation for exchanging quantity, or as a key for a Hashtable, etc. Locale-sensitive quantity formatting and parsing is handled by the QuantityFormat implementations and its subclasses.
        Overrides:
        toString in class Object
        Returns:
        SimpleQuantityFormat.getInstance().format(this)

      • asType

        public final <T extends Quantity<T>> ComparableQuantity<T> asType​(Class<T> type)
                                                           throws ClassCastException
        Casts this quantity to a parameterized quantity of specified nature or throw a ClassCastException if the dimension of the specified quantity and its unit's dimension do not match. For example:
        Quantity length = AbstractQuantity.parse("2 km").asType(Length.class);
        Specified by:
        asType in interface ComparableQuantity<Q extends Quantity<Q>>
        Specified by:
        asType in interface Quantity<Q extends Quantity<Q>>
        Parameters:
        type - the quantity class identifying the nature of the quantity.
        Returns:
        this quantity parameterized with the specified type.
        Throws:
        ClassCastException - if the dimension of this unit is different from the specified quantity dimension.
        UnsupportedOperationException - if the specified quantity class does not have a public static field named "UNIT" holding the SI unit for the quantity.
        See Also:
        Unit.asType(Class)

      • parse

        public static Quantity<?> parse​(CharSequence csq)
        Returns the quantity of unknown type corresponding to the specified representation. This method can be used to parse dimensionless quantities.
        Quantity proportion = AbstractQuantity.parse("0.234").asType(Dimensionless.class);

        Note: This method handles only standard unit format. Locale-sensitive or mixed quantity parsing is currently not supported by this class. If you need flexible parsing of both single and mixed quantities, please use getQuantity() method of the Quantities facade instead.

        Parameters:
        csq - the decimal value and its unit (if any) separated by space(s).
        Returns:
        SimpleQuantityFormat.getInstance().parse(csq)

      • hasFraction

        protected boolean hasFraction​(double value)
        Deprecated.
        seems unused