The generics mechanism in the language provides compile-time
(static) type checking, but it is possible to defeat this mechanism
with unchecked casts. Usually this is not a problem, as the compiler
issues warnings on all such unchecked operations. There are, however,
times when static type checking alone is not sufficient. For example,
suppose a collection is passed to a third-party library and it is
imperative that the library code not corrupt the collection by
inserting an element of the wrong type.

Another use of dynamically typesafe views is debugging. Suppose a
program fails with a ClassCastException, indicating that an
incorrectly typed element was put into a parameterized collection.
Unfortunately, the exception can occur at any time after the erroneous
element is inserted, so it typically provides little or no information
as to the real source of the problem. If the problem is reproducible,
one can quickly determine its source by temporarily modifying the
program to wrap the collection with a dynamically typesafe view.
For example, this declaration:

    Collection<String> c = new HashSet<String>();

may be replaced temporarily by this one:

    Collection<String> c =
        Collections.checkedCollection(new HashSet<String>(), String.class);

Running the program again will cause it to fail at the point where
an incorrectly typed element is inserted into the collection, clearly
identifying the source of the probelm. Once the problem is fixed, the
modified declaration may be reverted back to the original.