Обобщения Java, заставляющие тип из литерала

Как заставить тип из литерала в следующем коде для методов one() и zero() внизу? Eclipse позволит компилировать и запускать, но Eclipse дает предупреждения (Фракция является сырым типом. Ссылки на общий тип Фракция должна быть параметризована), и она, похоже, не безопасна по типу. Я понимаю, что объект Fraction связан с тем, что представляет собой тип E, но тот факт, что я передаю целые числа для создания новой фракции, которая может быть двойной, касается меня. Есть ли способ передать буквальное значение типа E?

/**
 * A class representing fraction.
 * @param <A> generic type
 */
public class Fraction<A extends Number> extends Number
{
    /**
     * Constructs a new Fraction.
     * @param n numerator
     * @param d denominator
     * @precondition n != null && d != null && d != Double(0.0)
     */
    public Fraction(A n, A d)
    {
        assert n != null && d != null : "arguments cannot be null";
        assert (double) d != 0.0 : "denominator must not be zero";

        num = n;
        denom = d;
    }

    /** the numerator. */
    private A num;

    /** the denominator. */
    private A denom;

    /** serial version UID for serialization. */
    private static final long serialVersionUID = 161146059432882814L;
}



public class FractionOperation<E extends Number> implements Arithmetic<Fraction<E>>
{
    /**
     * Class constructor generates a new instance. The operations variable type
     * must be compatible with the type declared for FractionOperation<E>.
     * @param operations any object that implements IntegerArithmetic<E>
     */
    public FractionOperation(IntegerArithmetic<E> operations)
    {
        this.op = operations;
    }

    /**
     * Computes the greatest common divisor for a and b.
     * @param a an number
     * @param b an number
     * @return greatest common divisor of a and b
     */
    private E gcd(E a, E b)
    {
        if (0.0 == b.doubleValue())
            return a;

        return gcd(b, op.mod(a, b));
    }

    /**
     * Simplifies the fraction num/denom by dividing both by their greatest
     * common divisor.
     * @param num numerator
     * @param denom denominator
     * @return new fraction (num / gcd(num, denom)) / (denom / gcd(num, denom))
     */
    private Fraction<E> simplify(E num, E denom) {
        E gcd = gcd(num, denom);
        E nomSimpl = op.div(num, gcd);
        E denomSimpl = op.div(denom, gcd);

        return new Fraction<E>(nomSimpl, denomSimpl);
    }

    /**
     * Adds two fraction and simplifies the result.
     * @param lhs left hand side argument
     * @param rhs right hand side argument
     * @return lhs+rhs (simplified)
     */
    public Fraction<E> add(Fraction<E> lhs, Fraction<E> rhs) {
        E nom = op.add
            (
                op.mul(lhs.getNumerator(), rhs.getDenominator()),
                op.mul(rhs.getNumerator(), lhs.getDenominator())
            );
        E denom = op.mul(lhs.getDenominator(), rhs.getDenominator());

        return simplify(nom, denom);
    }
    /**
     * returns a representation for 0.
     * @return 0
     */
    public Fraction zero() {

        return new Fraction(0, 1);
    }

    /**
     * returns a representation for 1.
     * @return 1
     */
    public Fraction one() {
        return new Fraction(1, 1);
    }

    public E mod(E numerator, E denominator)
    {
        return op.mod(numerator, denominator);
    }

    private IntegerArithmetic<E> op;
}

Я исправил проблему в этом коде, используя методы op one() и zero() вместо литерала для общего типа. Я все еще хотел бы знать, как заставить литерал для дальнейшего использования.

/**
 * returns a representation for 0.
 * @return 0
 */
public Fraction<E> zero() {

    return new Fraction<E>(op.zero(), op.one());
}

/**
 * returns a representation for 1.
 * @return 1
 */
public Fraction<E> one() {
    return new Fraction<E>(op.one(), op.one());
}