Beginner Java is not "I know classes and loops exist." It is being able to read a short piece of code and say, correctly, what it does when it runs — including the single most famous beginner trap in the language: comparing two Strings with == instead of .equals(), which the compiler happily accepts either way and only one of which actually compares their content.
What "Beginner" Actually Covers
The core primitive types (int, double, boolean, char) and their default values, if/else and switch branching, for/while loops, arrays, and writing a basic class with fields, a constructor, and methods. You can use String methods (length, substring, indexOf, concatenation) and understand the difference between a primitive and an object reference.
You also understand that Java is statically typed — a variable's type is fixed at compile time — and that this is why the compiler catches many category-of-mistake errors (assigning a String to an int variable) that a dynamically typed language would only catch at runtime, if at all.
That is a genuine, employable floor. It also looks, from a CV line alone, identical to having only read about Java syntax — which is why naming the specific things you can do reads as far more credible than the bare word "Java".
Where It Breaks
- Comparing two String objects with == instead of .equals(), which sometimes works by coincidence (string literal interning) and sometimes does not, making the bug intermittent rather than obviously wrong
- Integer division truncating instead of rounding — `5 / 2` is `2`, not `2.5`, unless at least one operand is a floating-point type
- Forgetting that Java arrays have a fixed size once created, and that accessing an index outside that size throws ArrayIndexOutOfBoundsException at runtime, not compile time
- Confusing `=` (assignment) with `==` (comparison) inside an if condition — Java's compiler actually catches this specific mistake for boolean conditions (unlike C), because it will not implicitly convert most other types to boolean, but it is still a common typo worth knowing about
- A NullPointerException from calling a method on a reference that was never assigned an object, which is one of the most common runtime errors in beginner Java code and reads, to someone new to the language, like a mysterious crash rather than a specific, predictable cause
None of these require advanced knowledge to avoid. They require knowing that Java has a small, specific list of places where the compiler accepting your code is not the same as the code doing what you meant — which is exactly what beginner-level testing checks for.
What to Put on a CV at This Level
"Basic Java: primitives, control flow, arrays, basic classes/constructors, String methods" is accurate and it is enough for a real share of junior QA and simple application-maintenance roles that never ask for a stream pipeline or a custom equals/hashCode.
What would overstate it: "Java" with nothing after it, or naming things you have only read about — generics, streams, concurrency — without having written one. Those get tested directly in the first working week, not the interview.
The Next Rung
Two things separate beginner from intermediate: comfort with the Collections framework (List, Map, Set and when to reach for each), and Integer autoboxing — the automatic conversion between the primitive `int` and the object type `Integer` — which has its own well-known == trap distinct from the String one.
The Java Test scores 30 code-reading questions across core language, collections/generics, and OOP/concurrency fundamentals in about six minutes, which is a faster way to see which of those is the actual gap than guessing from a tutorial.
Why This Gap Shows Up Fast Once Code Is Reused
A beginner-level Java class tends to survive exactly as long as it is written, compiled and run once. The moment a String comparison is used to check user input against an expected value, or an array is filled from a source whose size was not what was assumed, the gaps stop being private and start being an exception in someone else's stack trace.
That is the honest reason this tier is worth taking seriously rather than rushing past it. Someone who has genuinely internalised the == versus .equals() distinction and the fixed-size nature of arrays has removed most of what makes small Java programs unreliable once real, unpredictable input reaches them. Everything the next tier adds builds on that foundation being solid.