Should I do a runtime type check inside generic constructors?

Given this generic class and constructor,

class A<E extends Number> {      A(E number, Comparable<E> comparable) {         //...     } } 

it is ensured that a call to the generic constructor will check the arguments’ types at compile time:

new A<>(Integer.valueOf(4), Integer.valueOf(4)); // ok new A<>(Integer.valueOf(4), Long.valueOf(4)); // error: Cannot infer type arguments for A<> 

(of course, even explicitly stating the parametrized type instead of letting the compiler infer the type gives the same end result because the relation cannot be satisfied).

However, the raw constructor allows both calls to compile:

new A(Integer.valueOf(4), Integer.valueOf(4)); new A(Integer.valueOf(4), Long.valueOf(4)); 

with the warning on both invocations:

Type safety: The constructor A(Number, Comparable) belongs to the raw type A. References to generic type A<E> should be parameterized 

My question is, should the constructor perform type checks (e.g., instanceof, isAssignableFrom or isInstance) in its body to ensure that the class is not created in an invalid state in case the raw constructor is called?
These type checks are completely redundant if the constructor call is parametrized. Is the compiler warning about type safety a good enough excuse to not do these checks?