Java

The registry row this page is generated from

Read at render time from the same family row the register reads, so nothing in this block can disagree with it.

Extensions

.java

Registry names

java

Recorded symbols

classes · interfaces · methods · constructors

Relationship types this analyzer constructs

10 of 14 constructed, read from this analyzer's source and re-derived by the languages gate. Each row below is one of the engine's types, in the engine's own order.

10 constructed, 4 not constructed. All 4 absent types are recorded as ruled absent: the written reason and the corpus measurement behind each are in this family's completeness record. The register explains what each label means.

What this analyzer does not resolve

• A table or column name taken from the ORM's naming convention rather than from text written in the annotation is published as an inference and marked below the fabrication threshold: the edge is kept, the certainty is not.
• Cross-file override resolution reads a shared companion index of declared member names. Where that index is absent, an unannotated method is left unmatched, and only an @Override-annotated one falls back to the first parent in its hierarchy at reduced confidence.
• A static import is recorded but not expanded per member, so import static Util.helper gives you the import rather than a resolved edge to every name it brings in.

Every line above was written against Java’s own analyzer module and is named against a construct in it, so it can be checked against the source. Nothing here is inherited from a template, or from another language’s page.

Where you meet it in a repository

Recognised by extension — .java. Everything below is about where those files actually sit in a working repository.

• A Spring service is annotations over plain Java: the class name says little and the mapping annotations carry the URL contract.
• Record components and Lombok annotations declare members nobody wrote in the file, so those members are published as generated rather than as source.
• Packages are the namespace, so two classes with the same qualified name in different jars are one name as far as this view is concerned.

Questions this index answers

Phrased as retrievals, because that is what an index can honestly do: it holds the symbols and the edges between them, and hands them back with the evidence attached.

1. Which controller method serves this route?
2. Which entity is mapped to this table?
3. Which classes extend this one, and which methods override which?
4. Which members here are generated rather than written in the file?

What the analyzer sees in code like this

@Entity @Table(name = "auction_item")   // bb records: AuctionItem uses auction_item
public class AuctionItem extends BaseItem {   // bb records: extends BaseItem
    private final String name;                // bb records: property name

    @GetMapping("/items/{id}")                // bb records: route /items/{id} on render
    public String render(Object o) { return name; }
}

Symbols are stored with the file they came from and the bytes they span, so a hit points at a line rather than at a guess. The annotations in the sample are commentary for the reader, not strings the index would store.

Languages that turn up in the same repository

Application & systems — the count beside each name is how many relationship types that family’s analyzer constructs.

• TypeScript14 types
• JavaScript12 types
• Python11 types
• Rust14 types
• Go12 types
• C++11 types
• C9 types
• C#11 types
• Swift11 types
• Kotlin11 types
• Dart13 types
• Zig8 types
• Objective-C11 types
• Visual Basic11 types
• VBA9 types