This rule prohibits “half-parameterized types” while still permitting raw types. Raw types are generic types with no type parameters provided. They are provided as a legacy feature and shouldn’t be used in new code. (Do note that due to type erasure, code that uses raw types typically compiles to the same as code using parametrized types).

The following statements from JLS 4.8 are appropriate:

The use of raw types is allowed only as a concession to compatibility of legacy code. The use of raw types in code written after the introduction of generics into the Java programming language is strongly discouraged.

and

There is no practical justification for this half-baked [half-parameterized] type. In legacy code, no type arguments are used. In non-legacy code, we should use the generic types correctly and pass all the required type arguments.

An example of the situation described in your quote is given in the box a few paragraphs up. Given the following class declaration:

class Outer<T>{
    class Inner<S> {
        S s;
    }
}

The following declaration is illegal according to the rule you’ve quoted:

Outer.Inner<Double> w; // illegal

Here, Outer is used as a raw type, as it is not given any type parameters. Thus, Outer.Inner is a “non-static member class of a raw type that is not inherited from its superclass”. Therefore, passing type arguments to it is illegal.

The following forms are legal:

Outer.Inner x; // ok, fully raw (legacy)
Outer<Integer>.Inner<Double> y; // ok

The following form is also illegal as it mixes raw and parameterized types in a different way, and is banned by the paragraph after the one you’ve quoted ("It is a compile-time error to attempt to use a member class or interface of a parameterized type as a raw type."):

Outer<Integer>.Inner z; // illegal

Try out the code online.