Java Practical courses

Freelance de logo 1 LMU Ebit Systems HUK COBURG Hochschule der Medien Max Blank Institut Bayerische Oberlandbahn Samsung

Customized Java training

Does your team regularly work with the Java programming language? If so, we have just the thing for you! Customized training courses are also available for Java users and programmers. Get the most out of your projects. Thanks to individual modules, your development team can receive personalized training.

We are sure to find the optimal combination for your team's needs. Bring all your questions. We are happy to take the time to advise you individually.

All courses live

In the Academy or online

Your Team Benefits at a Glance

  • Customized Topics

  • Flexible Dates and Training Formats

  • Experienced Trainers

  • Certificate for Active Participation

  • Learning Material

  • Practice-oriented, Compact and Lively

Java topics and modules

Just to clarify upfront: Any topic can be explored in depth at your request. Your needs come first. You decide what your team needs. We create the concept. If your team just wants an overview, then you can select a wide range of topics. However, it will likely be challenging for the team to implement what they have learned in practice afterwards.

So, if you want to work seriously and professionally with Java, it's better, based on our experience, to select fewer topics which we then discuss in depth during the training and conduct a sufficient number of practical workshops. Here, indeed, "less is more". In a consultation, we can best jointly identify which topics will be most beneficial for your team and your projects.

We don't preach theory, we solve problems! Get the maximum knowledge for your team. Compile the topics according to your previous knowledge and needs, depending on the project. Because individual learning brings the desired success!

Java Grundlagen

These topics cover the language elements, concepts and core of the object-oriented programming language Java in a practical and lively way. Anyone who wants to work with Java must master the content of these modules, whether creating simple Java programs consisting of multiple classes or understanding complex programs.

The Java Basics module includes the following focus areas:

  • Java development environments: Eclipse, IntelliJ, NetBeans
  • Data types and operations
  • Object-oriented Pillar I: Encapsulation principle, classes and objects
  • Constructors and methods
  • Control flow: Conditions and loops
  • Object-oriented Pillar II: Inheritance and abstract classes
  • Object-oriented Pillar III: Polymorphism and interfaces
  • Basic data structures: list, map
  • Exception handling (error handling)

Java Advanced Topics

With the basic modules, you can write simple programs consisting of several classes in Java. But for large projects and demanding requirements, you need much more know-how about advanced topics and best practices.

The Java Advanced module includes the following focus areas:

  • Java Input/Ouput: IO and NIO
  • Java and structured data (JSON, CSV, XML, ...)
  • Server client programming in Java
  • Multithreading from Java 1 to Java 19
  • Multithreading: Tasks, Callable and Executor Services
  • Multithreading: the Future Class
  • Thread-safe collections
  • Database programming
  • Java Persistence API
  • Java Internationalization
  • Security in Java
  • Java Native Interface
  • GUI Programming with JavaFX

Functional Programming in Java

By far the most important innovation among the Java versions was Java 8 with the introduction of Lambda Expressions, Functional Interfaces and Streams. For many software developers it is still syntax and topics that need getting used to.

Nevertheless, once you understand these concepts deeply and well, you don't want to miss them! This is because these new features massively simplify many routine tasks and allow for a less error-prone and more efficient declarative style, rather than the traditionally used imperative style. Declarative style focuses on the "what-question" instead of the "how-question". The what-question expresses what a method should do, such as filtering data. The "how-question" explains the steps that are necessary to complete the task, e.g. going through all the data, filtering according to certain criteria, etc. In imperative style, the software developer has to take care of the two questions (what and how) and therefore write a lot of code. In declarative style, the software developer only cares about the "what should the method do" question and lets the Java API take care of the "how question". This proves to be very powerful when processing data with Lambda Expression and Streams and saves a lot of time.

The module system as of Java 9 allows large projects to be organized into multiple modules that are cleanly separated from each other. No project may have more cycles in its software architecture. A cycle results, for example, when a module A refers to B, module B refers to C, and then module C refers to A again. Such cycles arise quickly: when new requirements come in, deadlines and delivery dates are very short, then even experienced software developers help themselves out of time pressure and convenience with cross references between different modules in order to be able to access methods or data more quickly. As soon as everything works correctly, this is not very tragic. But as soon as an error (bug) occurs, it is incredibly difficult to locate the source, if A depends on B, B on C and C again on A. It can take days and weeks to correctly identify the source of such errors and to correct the bug. Java 9 tries to protect us from exactly this by having the module system prohibit such cycles from the start! These are just a few examples of the advantages of Java 8 and 9. In our opinion, anyone who wants to program seriously and effectively with Java should master the new features of Java 8 and 9.

The Functional Programming with Java 8-11 module includes the following focus areas:

  • Imperativer vs. deklarativer Stil
  • Behavior Parameterisation
  • Lambda Expression
  • Functional Interface
  • Optional Class
  • Methods and Constructor Reference
  • Collections and Stream API
  • Module System as of Java 9
  • The new Date API
  • Immutable Collections: list.of( ), set.of( ), map.of( )

News from Java 09 to XX

(XX stands for the latest version: currently 18)

The Java programming language is constantly evolving. More precisely, Oracle now releases a new Java version every 6 months and a new major version every 3 years. Some innovations are "only" nice and "nice to have", so that the software developers can accomplish some tasks without detour and more directly than before, other changes are quite interesting and important and contribute to the fact that one can realize the same task with e.g. Java 19 clearly better and faster than with Java 10. From this module you can select the following innovation to Java 19:

The News from Java 09 to Java XX module includes the following focus areas:

  • The new Date API (Java 8)
  • Module System as of Java 9
  • var keyword (Java 10)
  • Collectors API (Java 10)
  • String API Update (Java 11)
  • File API Update (Java 11)
  • Micro Benchmark Suite (Java 12)
  • Immutable Collections: list.of( ), set.of( ), map.of( )
  • Defaulting Class Data Sharing Records (Java 12)
  • JVM Numbers API (Java 12)
  • Switch Expression (Java 13)
  • Pattern Matching (Java 13)
  • Null Pointer Exceptions (Java 13)
  • Text Blocks (Java 14)
  • Pattern Corresponding (Java 14)
  • Records (Java 14)
  • Closes Classes with Edges (Java 15)
  • Hidden Classes (Java 15)
  • More Text Block / Multiline Strings (Java 15)
  • Vector API (Java 16)
  • Foreign Linker API (Java 16)
  • Enable C++ (Java 16)
  • Pattern Matching for switch (Java 17)
  • Sealed Classes (Java 17)
  • Foreign Function & Memory API (Java 17)
  • Context-Specific Deserialization Filters (Java 17)
  • Simple Web Server (Java 18)
  • Code Snippets in Java API Documentation (Java 18)
  • Record Patterns (Java 19)
  • Virtual Threads (Java 19)
  • Structured Concurrency (Java 19)

Clean Code and Unit Test

The topics in this module are aimed at Java programmers who want to write high quality, good code. If you want all your Java developers to reach a certain standard of quality and write above average code, then the topics here are the right ones! Because here we don't deal with language elements or concepts but with the question: how can I write better Java code? Code that has as few errors as possible, is easy to understand, change and extend. How can I produce code that other team members can easily test, extend and build upon? Because a team should never be dependent on a few people. This is not good for the team or for the people involved. Because if a team is dependent on a few people because they are the only ones who know about complex code segments, then the team can't move forward if those people are absent due to illness or vacation! On the other hand, even on their well-deserved vacation, these experienced people have to be available all the time because they are the only ones who know code very well! This is a typical situation, which is not optimal for both sides.

The topics from this module try to solve exactly this problem by having all team members write Clean Code and provide it with Clean Unit Test, so that the produced new code is quickly understandable for all and also new team members, shortens the learning curve and enables productive collaboration.

This module covers Clean Code rules, Clean Unit Test rules, the most important object-oriented concepts and refactoring patterns in a practical and optimized way, so that your Java development team can immediately apply what they have learned in this module to ongoing projects, thereby permanently improving code quality and productivity.

The topics in this module further deepen Java best practice techniques and also address aspects for which there is no time in a typical Java basic or advanced course.

The Clean Code and Clean Unit Test in Java module includes the following focus areas:

  • How can I recognize bad code?
  • Clean Code and risk management
  • Clean Code rules for names, comments, functions
  • Code smell catalog and avoidance of code smells
  • JUnit 5 basics: annotation, assertion, parameterized test
  • Test Driven Development (TDD)
  • Behavior Driven Development (BDD)
  • Mocking Frameworks: Mockito and PowerMock
  • Refactoring Patterns and Best Practice in Java
  • Finding test data: equivalence classes and boundary data test
  • Test Double techniques: Mocks, Fakes, Stubs, and Dummies

OOP design and architecture

As soon as a developer works in only one class, the Clean Code and unit test rules are often sufficient, in order to write on this level above average good Java code. However, as soon as a Java developer writes more than one class, which is often the case, the question comes to the fore: how do I organize my classes? In which relations do they stand to each other? Which dependencies and interfaces are there between them? The correct class structure is decisive and crucial for the quality of the entire code. Thus, it becomes even more important that your Java team is well versed in modern object-oriented concepts and software architecture patterns, called design patterns. Often, you can combine several proven design patterns and/or proven object-oriented concepts to implement a flexible and good software architecture. These modules teach how your Java development team can use a variety of techniques and patterns to better structure Java programs. Both the fundamentals of object orientation, which are independent of any particular programming language, and possible implementations in Java are discussed here.

The Object orientation, design and architecture in Java module includes the following focus areas:

  • Basic concepts of object orientation
  • Inheritance, abstract classes, and interfaces.
  • Practice-relevant software architecture
  • Design patterns in Java
  • Designing, structuring, and implementing large projects:
  • Architecture styles, hexagonal architecture

Working with legacy code

Every programmer likes to work on modern, well-structured code that is thoroughly documented and tested. Unfortunately, the practice often looks different. If your team has to maintain a codebase characterized by structural issues, insufficient documentation, and no or poor testing, then unfortunately we can't promise you that any of our courses will solve the problem overnight. But in these modules, your team will learn many proven techniques that they can use step by step to get their code into a shape that makes it fun to work with again.

The Working with Legacy Code in Java module includes the following focus areas:

  • Safeguarding tests
  • Incremental improvement of code and tests
  • Seams and their special features in Java
  • Refactoring patterns for legacy code

Working effectively as a team

These modules cover techniques that help make teamwork more productive and improve the quality of the resulting software.

The Working effectively as a team module includes the following focus areas:

  • Versionskontrolle (Git)
  • Docker
  • Continuous Integration (CI)
  • Workflows: Issue Tracking, Pull/Merge Requests
  • Example: working with a local GitLab instance in Docker
  • Kubernetes
  • Elasticsearch/Kibana (OpenSearch/Dashboards)

Examples: Customized Java courses

These examples illustrate how some courses can be structured for typical customer requirements.

Example 1: Introduction to Modern Java

You are starting a Java project, but some of the team members have knowledge of C++ or C#, but not Java. To get these team members to a level where they could productively work on the code base, a course with the following modules would be appropriate:

  • Data types and Operations
  • Classes and Objects
  • Arrays, Enum and String
  • Methods and Control Flow
  • Abstract Classes and Interfaces
  • Data Structure: List, Map
  • Lambda Expression
  • Stream APIs
  • Module System

Example 2: Clean Softwarearchitektur in Java

You are a team of experienced developers for whom neither the Java programming language itself nor the basics of object orientation are new territory. But you want to better structure the large software project you are currently working on and prepare it for future requirements. Then the following modules might be right for you:

  • Practice-relevant software architecture
  • Design patterns in Java
  • Designing, structuring, and implementing large projects:
  • Architectural styles, hexagonal architecture

Your Trainers

Allaithy Raed
Allaithy Raed

Expert: Java, Python, Clean Code, Unit Test, Clean Design

Dr. Matthias Ludwig
Dr. Matthias Ludwig

Expert: Optimize processes, Agile Methods, Java, Python

Prof. Dr. Peer Kröger
Prof. Dr. Peer Kröger

Expert: Artificial Intelligence, Data Science, Python, Java

Questions and answers about Java training

What course formats are available?

3-day on-site course at the Coding Academy

The course takes place in our modern and top-equipped training rooms. We provide each participant with a modern laptop during the training. Drinks are provided by the Coding Academy. You will receive access to the materials no later than the first day of the course.

3-day in-house training on-site at your location

Our trainers are also happy to come to you if this is expressly desired by you and you have a good training room and the necessary infrastructure for the training.

3-day online course

The course takes place online. All you need is a computer with internet access; however, for some courses, it may be necessary to install the software used; this is indicated in the description of the respective course. You will receive access to the materials no later than the first day of the course.

4-Week Training Program

A new and innovative learning concept. You can find more information about the 4-Week Training Programm here.

What is the formal process (ordering, training, invoice)?

  • If you are interested in a training course, it is best to contact us so that we can clarify the technical topics.
  • If you would like to take the training course with us, we will be happy to send you a non-binding offer.
  • If the offer suits you, please accept it (a short confirmation by email is sufficient).
  • If you need an order confirmation, we will be happy to send it to you.
  • Afterwards, we will find a date that fits well for your team.
  • For online training, we will provide you with the link: MS-Teams, BBBServer, or Zoom.
  • A few days after the training, you will receive an invoice with a payment term of two weeks.
  • Upon active participation in the training, participants will receive their certificates by email afterwards.

Do graduates of the Java courses receive a certificate?

Of course, as a participant in a Java course, you will receive a certificate. The prerequisite for this is full participation in all course units and programming tasks, and the successful programming of a small final project. However, after an intensive Java course, this will certainly bring you more joy than stress.

What distinguishes courses at the Coding Academy?

  • Individual: We specifically address your needs and take into account your previous knowledge, desired topics, and focus areas.
  • Developed by experts using the RAED teaching method®
  • Compact, lively, and entertaining
  • Structured and easy to understand
  • A lot of practice: You can immediately apply the knowledge learned in the course.
  • Theory optimized to the essentials
  • Many examples and tasks, the difficulty of which increases linearly
  • Small groups: max. 8 participants in the 3-day course; max. 15 participants in online coaching
  • Highly qualified trainers with up to 30 years of experience in industry and teaching at German universities and colleges
  • For on-site trainings, we provide modern laptops to the participants at no additional cost.

Customer testimonials

We thank our customers for their trust. 


My IT team completed a JAVA-SE training course at the Coding Academy in Munich. We can recommend this without reservation. Mr. Raed explained the most important innovations of Java 8 to 12 in the form of workshops. We are therefore planning further training courses in JavaScript, Python and Clean Code with the Coding Academy and are very happy that we have found a competent seminar provider.

Simon Gravel,
Geschäftsführer von Freelance.DE

When our employees ask me about training courses in the field of coding and clean code, there is now only one contact name and that is of course you: the Munich Coding Academy! In your courses you have scored with a super performance and great communication, our employees are happy and learn a lot, it could not be better!

Herr Tim Stuckmann,


We are very happy to take time for you. Use our contact form for a written contact. Our team will respond quickly and within 24 hours at the latest. In case of technical questions and to clarify the focal points, which are target-oriented for your team, please use the possibility of a non-binding consultation appointment.