Lessons

In this lecture, we’ll cover when and why to create your own exceptions in Java: how to choose between Exception and RuntimeException, design constructors with the String message and Throwable cause parameters, add useful fields, and use them correctly in code. We’ll discuss naming, scope of responsibility, documenting via throws, and common mistakes. Plus—why it’s sometimes better to throw an exception than return false.

A step-by-step guide to exception chaining in Java: how to correctly “wrap” exceptions and pass the cause so you don’t lose the call stack. We’ll examine constructors with a Throwable parameter, the use of getCause() and printStackTrace(), show an example with UserManagementException, and discuss common mistakes—from throwing a new exception without a cause to “swallowing” errors.

Advanced exception handling in Java: multiple catch blocks, the multi-catch syntax and its rules, ordering from specific to general, as well as best practices — from the inadmissibility of “swallowing” errors to throwing the most specific exceptions and avoiding exceptions as a control-flow mechanism. Everything is accompanied by examples, a breakdown of common mistakes, and style tips.

In this lecture we’ll break down why exceptions are part of a method’s contract in Java, how to document them via Javadoc with the @throws tag, when to choose checked vs. unchecked exceptions, and how to work with resources safely using the try-with-resources construct. We’ll discuss the role of the AutoCloseable interface, show practical examples, and cover common pitfalls.

In this lecture, you will learn what Git is and why modern developers need it, create your first repository on GitHub, and learn how to set up your IDE environment for effective version control workflows.

In this lecture, you’ll master the basic workflow: learn to save changes (commit), push them to GitHub, and configure ignoring unnecessary files with .gitignore.

In this lecture, you will learn how to create separate branches for new tasks, switch between them, merge changes, and—most importantly—confidently resolve merge conflicts using powerful IDE tools.

In this lecture, you will learn what a pull request (PR) is, why it is the key tool for team development, and how to create and review PRs right from your IDE.

In this lecture, you will learn how to undo changes, remove bad commits, temporarily stash your work, and use the project history to search for information — all with your IDE’s tools.

This lecture is a quick, hands-on overview of Java collections. We’ll discuss why fixed-size arrays are not enough, how collections help, and how to choose between List, Set and Map. We’ll show practical examples with ArrayList and HashMap, compare arrays with collections (operations add(), remove(), contains(), sorting via Collections.sort()), and finish by covering common pitfalls: raw types, imports, confusion between length and size(), order expectations, and primitives in collections.

This lecture is a hands-on introduction to the List interface and its popular implementations: ArrayList and LinkedList. We will cover how to create lists, call basic methods ( add, get, set, remove, size, clear), iterate over elements, and search them. We will compare operation performance and discuss when to choose one implementation over the other. Finally, we will look at typical mistakes and how to avoid them ( IndexOutOfBoundsException, ConcurrentModificationException, a correct equals implementation, and working with generics).

In this lecture, we examine maps in Java: the Map interface, key operations ( put, get, remove, containsKey), the differences between HashMap (fast access) and TreeMap (key sorting), iterating via keySet(), values(), and entrySet(), as well as typical pitfalls: expecting order in HashMap, using null keys in TreeMap, and issues with ConcurrentModificationException. Plenty of code examples and practical scenarios will help you confidently use Map in your projects.