Programming Java 2026

О курсе

Команда курса

Преподаватель - Мария Рубаненко

Расписание

с 9 сентября

Лекция - Среда 9:00 - 10:25 Аудитория 705 КПМ

Семинар - Суббота 9:00 - 10:25 Аудитория 705 КПМ

Чат курса

Направлен на почту

Course outline:

Block 1: Language Foundations, Syntax, and OOP

Module 1: Introduction to Java, Primitives, and OOP Core

Lecture: How Java works: compilation, bytecode, JRE/JDK, and high-level JVM architecture. Primitive data types, explicit and implicit casting. Control flow statements and loops. Classes, objects, methods, and constructors. The this and static keywords. The four pillars of OOP in practice: encapsulation, inheritance, polymorphism, and abstraction. Access modifiers.

Seminar: +

Module 2: Reference Types, Arrays, Strings, and Exception Handling

Lecture: One-dimensional and multidimensional arrays. Working with strings: String (why is it immutable?), the String Pool, StringBuilder, and StringBuffer. Packages and imports. The exception hierarchy (Throwable, Exception, Error, RuntimeException). Checked vs. Unchecked exceptions. The try-catch-finally blocks, throw, and throws operators. The try-with-resources statement and the AutoCloseable interface.

Seminar: +

Module 3: Java Collections Framework Architecture

Lecture: The Collections hierarchy: List, Set, Queue, and Map. Deep dive under the hood: ArrayList (dynamic resizing) and LinkedList (doubly-linked list). The equals() and hashCode() contract—why it is critical. Mechanics of HashMap and HashSet (buckets, collisions, treeification in Java 8+). TreeSet and TreeMap (Red-Black trees) along with the Comparable and Comparator interfaces.

Seminar: +

Block 2: Hardcore Core Java (Generics, FP, and Memory)

Module 4: Deep Dive into Generics (Type Erasure & PECS)

Lecture: The purpose of Generics. Parameterized classes, interfaces, and methods. How generics work under the hood: Type Erasure and Bridge Methods. Bounded type parameters: extends vs. super. The PECS rule (Producer Extends, Consumer Super). Wildcards in complex class hierarchies. Invariance, covariance, and contravariance.

Seminar: +

Module 5: Functional Interfaces and Stream API

Lecture: Comprehensive breakdown of Functional Programming concepts. Core functional interfaces: Predicate, Consumer, Function, Supplier, and UnaryOperator. Creating custom interfaces with @FunctionalInterface. How lambdas compile: invokedynamic instructions. Method References and Variable Capture. Stream API lifecycle: intermediate vs. terminal operations. Lazy evaluations. Crafting custom Collector implementations.

Seminar: +

Module 6: Concurrency — Part 1: Foundations and Synchronization

Lecture: Understanding Processes and Threads. Thread creation using Thread and Runnable. Thread lifecycle and states (NEW, RUNNABLE, BLOCKED, WAITING, etc.). Common multithreading pitfalls: Race Conditions, Deadlocks, and Livelocks. The synchronized keyword (intrinsic locks, object-level vs. class-level locking). The wait(), notify(), and notifyAll() coordination mechanisms. The volatile keyword and atomicity constraints.

Seminar: +

Module 7: Concurrency — Part 2: Concurrency Utilities and JMM

Lecture: The Java Memory Model (JMM): visibility, instruction reordering, and the happens-before guarantee. Exploring the java.util.concurrent package. Atomic variables (AtomicInteger, AtomicReference). Explicit locks: ReentrantLock and ReadWriteLock. Synchronizers: CountDownLatch, CyclicBarrier, and Semaphore. Thread pools and the ExecutorService. Handling future results with Callable and Future. Thread-safe collections (ConcurrentHashMap, CopyOnWriteArrayList).

Seminar: +

Module 8: Modern JVM Memory Management

Lecture: JVM memory layout (Java 17-25): Heap (Eden, Survivor, Tenured), Metaspace, Code Cache, and Off-Heap (Direct Memory). Stack vs. Heap allocation. Object allocation and garbage collection lifecycles. The evolution of Garbage Collectors: from Serial/Parallel to G1, and modern ultra-low-latency collectors like ZGC (Z Garbage Collector) and Shenandoah (Colored Pointers, Load Barriers).

Seminar: +

🏗 Block 3: Build Automation, Spring Ecosystem, and Data

Module 9: Maven Architecture and Build Automation

Lecture: How Maven operates: build lifecycles, phases, and goals. Anatomy of pom.xml. Dependency management and conflict resolution: Dependency Mediation (nearest-wins rule) and dependency scopes. Working with <dependencyManagement> and build plugins (<plugins>). Designing and configuring multi-module project structures.

Seminar: +

Module 10: Spring Core Under the Hood (IoC, DI & AOP)

Lecture: The philosophy behind Inversion of Control (IoC) and Dependency Injection (DI). The Spring Bean Lifecycle: from BeanDefinition parsing to destruction. Initialization phases, BeanFactoryPostProcessor, and BeanPostProcessor (BPP). Proxying in Spring: JDK Dynamic Proxies vs. CGLIB. Resolving circular dependencies using Spring's three-level cache. Aspects, Advices (Before, After, Around), and Pointcuts. Spring AOP vs. AspectJ.

Seminar: +

Module 11: Spring Data JPA, Hibernate, and Transactions

Lecture: Architectural foundations of JPA and Hibernate. Entity life cycle states (Transient, Persistent, Detached, Removed). Dirty Checking mechanics and the first-level cache. Exposing and solving the N+1 Query problem (JOIN FETCH, EntityGraph). Mapping entity relationships (@OneToMany, @ManyToMany). Internal mechanics of the @Transactional annotation. Transaction isolation levels and propagation behaviors (REQUIRED, REQUIRES).

Seminar: +

Module 12: Spring Web (REST API), Validation, and Spring Boot 3.x

Lecture: Spring Boot philosophy and Auto-configuration using @Conditional annotations. Anatomy of Spring Web: DispatcherServlet, controllers, and request mapping. Designing mature RESTful APIs. Centralized error handling using @ControllerAdvice and @ExceptionHandler. Incoming DTO validation with the Jakarta Validation API. System monitoring with Spring Boot Actuator.

Seminar: +

Block 4: Security, Containerization, and Production Deployment

Module 13: Spring Security, JWT, and Docker Containerization

Lecture: Spring Security architecture: the SecurityFilterChain. The Authentication and Authorization processes. Implementing stateless security architectures using JWT (JSON Web Tokens). Core concepts of Docker containerization: images, containers, layers, volumes, and networking. Writing highly efficient Multi-stage Dockerfiles to strip away build overhead and minimize target production Java runtimes.

Seminar: +

Module 14: CI/CD Pipelines, Nginx, and Production Deployment

Lecture: Continuous Integration and Continuous Delivery (CI/CD) workflows using GitHub Actions or GitLab CI. Automating the pipeline: Maven build ➡ unit/integration testing ➡ Docker image compilation ➡ pushing to a container Registry ➡ remote server deployment. Setting up Nginx as a Reverse Proxy to forward external traffic, load balance, and manage SSL/TLS certificates (via Certbot/Let's Encrypt).

Seminar: