Great question! Let's break this down clearly, because there are a couple of confusing parts in your code that are worth unpacking.

First, let's separate the two distinct <T> declarations in your code—they're not the same, even though they share the same name:

• The class-level generic: abstract class Trie <T extends HasPoint>
  This <T> defines the generic type for the entire Trie class, restricting it to work with types that extend HasPoint. Every instance of Trie will be tied to one specific subtype of HasPoint.
• The method-level generic: abstract <T> Trie insert(T point);
  This <T> is a separate generic parameter that only applies to the insert method. It shadows (hides) the class-level <T>, meaning inside this method, any reference to T refers to the method's generic type, not the class's. Worse, this method's <T> has no bounds—you could pass any object to insert, which contradicts the class's design intent of working only with HasPoint subtypes.

Now, to your core question: what's the purpose of the Trie before the method name?
That Trie is the return type of the method, but it's using the raw type of your generic class. A raw type is when you use a generic class without specifying its type parameter (e.g., Trie instead of Trie<SomeType>).

Is this necessary? #

No—this is actually a poor practice for two key reasons:

1. Loss of type safety: Using a raw type bypasses Java's generic type checks. When you call insert, the returned Trie won't have any type constraints, so you could accidentally add non-HasPoint objects later and get a ClassCastException at runtime.
2. Confusing shadowing: The method's <T> already obscures the class's generic type, and returning a raw type makes the code even harder to read and maintain.

What's the better approach? #

If your Trie class is meant to handle a single subtype of HasPoint per instance, you should remove the method-level <T> and return a properly typed Trie<T>:

abstract class Trie <T extends HasPoint> {
    abstract Trie<T> insert(T point);
    abstract Trie<T> delete(T point);
}

This way, the insert method only accepts the same T type the class is bound to, and returns a type-safe Trie<T> instance—no raw types, no shadowing, full compile-time type checks.

If you truly need the method to work with any HasPoint subtype (not just the class's T), rename the method's generic parameter to avoid shadowing and return a typed Trie:

abstract class Trie <T extends HasPoint> {
    abstract <U extends HasPoint> Trie<U> insert(U point);
    abstract <U extends HasPoint> Trie<U> delete(U point);
}

(Note: This design is less common for Tries, which typically handle homogeneous data, but it's valid if your use case requires it.)

内容的提问来源于stack exchange，提问作者DevM