If you have worked through the Java basics — syntax, classes, collections, exceptions, streams — the question is what comes next. This page is a recap of what those pieces add up to, a checklist for judging where you actually are, and three concrete directions worth choosing between.
What you have covered#
| Topic | The idea underneath |
|---|---|
| Types and variables | the compiler checks your work before it runs |
| Classes and objects | data and the operations on it live together |
| Interfaces | depend on what something can do, not what it is |
| Collections | choosing the right structure is a performance decision |
| Exceptions | failure is a path through your code, not an accident |
| Streams | describe the transformation, not the loop |
| Files and I/O | resources must be released, whatever happens |
| Concurrency | shared mutable state is where the bugs live |
Those are not Java facts. They are ideas that transfer to C#, Kotlin, Go and most of what you will meet later. The syntax is the smallest part of what you learned.
An honest checklist#
Not “have you read about it” but “could you do it now, without looking it up”:
- Write a class with private fields, a constructor that validates its arguments, and useful methods
- Choose between
ArrayList,HashMapandHashSetand say why - Explain what happens if you put an object in a
HashSetwithout overridingequalsandhashCode - Read a file line by line with try-with-resources
- Turn a loop that filters and collects into a stream, and back again
- Catch a specific exception and explain why not a general one
- Say what
staticmeans and when you would use it - Write a test that fails, then make it pass
Anything you hesitated on is a better use of an hour than starting a new topic. Depth on the fundamentals compounds; breadth without it does not.
Three directions#
Back-end development#
The largest market for Java by a wide margin. The path is Spring Boot, then databases, then everything around a running service.
- Spring Boot: dependency injection, controllers, services, repositories
- JPA and Hibernate, and knowing when to drop to SQL
- REST API design, validation and error responses
- Testing: JUnit, Mockito, and Testcontainers for the database
- Docker, and reading logs from a service you cannot attach a debugger to
Android#
Kotlin is now the preferred language, but the platform, the tooling and a great deal of existing code are Java, so the transition is short.
- The Android SDK, activities, fragments and the lifecycle
- Jetpack Compose for interfaces
- Room for local storage, Retrofit for network calls
- Kotlin, which is worth learning early rather than late
Data engineering#
Less visible than the other two and consistently in demand.
- Kafka for streaming, Spark for batch processing
- The JVM memory model and garbage collection, in more depth than most people need
- SQL, properly — window functions, execution plans, indexes
The habits that matter more than the syntax#
- Write the test for every bug you fix. The failing test first, then the fix. It is the cheapest way to stop the same bug returning.
- Name things for what they are.
daysUntilExpiryneeds no comment;dneeds a paragraph. - Keep methods short enough to describe in one sentence. If the sentence needs an “and”, it is two methods.
- Read the stack trace from the bottom. The deepest frame in your own code is nearly always the one that matters.
- Prefer composition to inheritance. Deep hierarchies are hard to change; a class with collaborators is not.
- Let the tools do the formatting. Configure your IDE once and stop thinking about it.
Modern Java is worth catching up on#
If you learned Java from older material, several recent additions genuinely change how the language reads:
// Records - a data class in one line
record Point(double x, double y) { }
// Pattern matching
if (shape instanceof Circle c && c.radius() > 10) { }
// Switch expressions
String label = switch (day) {
case SATURDAY, SUNDAY -> "weekend";
default -> "weekday";
};
// Text blocks
String query = """
SELECT id, name
FROM products
""";
// Virtual threads - millions of them, cheaply
Thread.startVirtualThread(() -> handle(request));
Virtual threads in particular change how you design I/O-heavy servers, since the thread-per-request model becomes viable again at scale.
Where to keep learning#
- The official documentation. The Javadoc is genuinely good, and reading it is a skill that pays back constantly.
- Release notes. Skimming what changed in each Java version keeps you from writing code that was superseded years ago.
- Other people’s source. Large parts of the JDK and of Spring are readable, well-commented Java. Following a method into a library is the fastest way to stop treating it as magic.
- A real project. Something you actually want to exist. Tutorials teach syntax; a project you care about teaches everything else.
Questions people ask#
How long does it take to become employable?
Longer than a course and shorter than people fear. Roughly: a few months to write small programs confidently, six to twelve months of regular practice plus a couple of real projects to be useful on a team. Consistency matters more than intensity.
Should I learn Kotlin next?
If you are heading for Android, yes. Otherwise it is optional — a nicer language for many things, and one that runs on the same JVM, so the knowledge is not wasted either way.
Do I need to memorise the collections API?
No. You need to know which structure to choose and why. The method names are one autocomplete away.
Is it worth learning older Java for existing codebases?
Being able to read older idioms is useful, because you will meet them. Writing new code that way is not. Learn modern Java and recognise the old patterns.
Where to go next#
- Java and the Spring framework — the back-end path.
- Java testing — the habit that separates hobby code from professional code.
- Which language should I learn? — if you are weighing a second one.