🎓 Java Learning

Welcome! This is the main navigator for my educational projects.

📁 JavaBasics

👉 Collections and generics.

Generics: why they are needed, basic syntax.

Set: HashSet and TreeSet, uniqueness of elements.

Task 452 Shopping List: Automated Deduplication V0.1 — Redundancy in data can lead to unnecessary processing and logical errors. This project addresses the common problem of Removing Duplicates from a Collection. Using a shopping list scenario, we demonstrate a highly efficient Java idiom: converting a List containing duplicate entries into a Set. Since the Set interface fundamentally prohibits duplicate elements, the conversion process automatically filters the data, leaving only unique items.
Task 451 Event Organizer: Sorted Unique Sets V0.1 — In event management, maintaining a clean and ordered guest list is essential for check-in efficiency. This project demonstrates the usage of TreeSet, a collection that implements the SortedSet interface. Unlike a standard HashSet, a TreeSet automatically maintains its elements in their natural order (alphabetical for Strings). Additionally, it strictly enforces uniqueness, ensuring that each attendee is listed only once. This project covers collection initialization, data insertion, and verifying the sorted, duplicate-free output.

Map: HashMap and TreeMap, keys and values.

Task 450 Warehouse Inventory: Sorted Maps V0.1 — In warehouse logistics, having data sorted alphabetically is crucial for quick navigation and reporting. This project demonstrates the usage of TreeMap, a specialized Map implementation in Java that maintains its keys in their natural order (alphabetical for Strings). Unlike HashMap, which offers no order guarantees, TreeMap ensures that every iteration over the collection reflects a sorted state. We practice data insertion and custom formatting of the sorted output.
Task 449 Smart Task Scheduler: Map Iteration V0.1 — Efficient scheduling requires a clear mapping between descriptors and their numerical values. This project demonstrates the use of a HashMap to associate the days of the week with their ordinal numbers. The core focus is on Collection Iteration, specifically using the entrySet() method. This approach allows access to both the key and the value simultaneously during a single loop, providing a clean and efficient way to format and display associated data for the end user.

List: ArrayList and LinkedList, basic operations.

Task 448 Streaming Service: List Search & State Management V0.1 — User experience in streaming platforms depends heavily on the ability to manage personal watchlists. This project demonstrates advanced ArrayList operations for a "To Watch" feature. Key functionalities include:
- Index Search: Using indexOf() to identify the position of specific elements (e.g., tracking duplicate entries).
- Membership Verification: Using contains() to check for the presence of a title without iterating manually.
- Bulk Reset: Utilizing clear() to perform a complete state reset of the collection.
  *These operations are essential for maintaining clean and responsive user interfaces.
Task 447 Student Schedule: Dynamic List Manipulation V0.1 — University schedules are subject to frequent changes during the registration period. This project simulates a Course Scheduling System using Java's ArrayList. We explore advanced list operations beyond simple addition:
- Positional Insertion: Using index-based add(index, element) to prioritize subjects.
- Element Removal: Using remove(Object) to drop specific courses.
- Iterative Display: Printing each element individually to simulate a structured schedule view.

Java Collections Overview - Why Use Collections?

Task 446 Student Card Index: Working with Maps V0.1 — Efficient data retrieval is key to administrative systems. This project demonstrates the use of a Map collection (HashMap) to create a digital student card index. Unlike lists, a Map stores data in key-value pairs. In this scenario, we use the student's name as a unique key to store and quickly access their age. This practice covers map initialization, data insertion using the put() method, and displaying the entire collection.
Task 445 Fruit Store Inventory: Dynamic Lists V0.1 — In inventory management, static arrays are often insufficient because the number of items can change frequently. This project demonstrates the use of a Dynamic List (ArrayList) to manage a fruit store's stock. Unlike arrays, an ArrayList in Java can grow and shrink as needed. We practice the core operations of a collection: initialization, adding elements, and performing a bulk display of contents using the built-in string representation of the collection.

👉 Advanced work with exceptions.

Exceptions as part of the API and try-with-resources.

Complex exception handling and best practices.

Exception Chaining.

Creating your own exceptions.

Hierarchy of exceptions in Java.

👉 OOP - typical mistakes and best practices.

Clean Code: Code style and readability, code conventions.

Problems of polymorphism and abstractions.

Errors with access modifiers.

Errors with inheritance and method overloading.

Errors when declaring classes and objects.

👉 Record classes.

Differences between record and class, limitations of record.

Task 404 User Profiles: Mutability vs Immutability V0.1 — In profile management systems, distinguishing between active (modifiable) and archived (read-only) records is crucial for data consistency. This project highlights the Structural Differences between Regular Classes and Records. We implement a FlexibleUser class with setters to allow state changes and a FixedUser record to enforce strict immutability. This comparison demonstrates how records protect data from modification, whereas regular classes provide the flexibility needed for dynamic updates.
Task 403 Document Management: Records and Interfaces V0.1 — In modular software systems, defining common contracts through interfaces is essential for interoperability. This project explores the Integration of Interfaces with Java Records. While records are primarily data-oriented, they can implement interfaces to provide specific functionality. Here, we define a Printable interface and implement it within a Document record. This demonstrates how a concise data carrier can participate in a polymorphic system, providing its own implementation of the print() method while maintaining its immutable state.
Task 402 Map Coordinates: Automatic Equality V0.1 — In mapping and navigation systems, identifying identical locations is a fundamental task. This project explores how Java Records simplify this process by providing a built-in implementation of the equals() method. Unlike standard classes, which compare object references by default, records compare the actual data stored in their components. This ensures that two separate Point instances with the same horizontal and vertical coordinates are logically treated as the same location.
Task 401 Home Library Assistant V0.1 — Managing a large collection of books requires a structured and reliable data model. This project demonstrates the implementation of a Java Record to act as a digital entry for a home library assistant. By utilizing the record keyword, we benefit from built-in immutability, thread safety, and automatic generation of accessor methods (title() and author()). This approach minimizes boilerplate code while ensuring that book information remains consistent and easy to access.

Record with methods.

Task 400 Bank System: Transaction Integrity V0.1 — Ensuring data integrity in financial systems is a critical requirement. This project demonstrates how to use a Java Record as a secure data carrier for bank transactions. By implementing a Compact Constructor, we enforce strict validation rules: the transfer amount must be positive, and both sender and recipient names must be provided. This "Fail-Fast" design ensures that no invalid transaction object can ever be instantiated, guaranteeing system stability and reliable audit trails.
Task 399 Character Biography: Records with Behavior V0.1 — In application design, data carriers often need to provide derived information or standardized interactions. This project explores the Extended Capabilities of Java Records. While records are primarily for data storage, they can include static constants and instance methods. In this character biography simulation, we define a Person record that shares a common SPECIES constant among all instances while providing a personalized greeting() method. This demonstrates how to encapsulate both state and relevant behavior in a concise, modern Java structure.
Task 398 Registration System: Record Validation V0.1 — Ensuring data integrity at the moment of creation is a cornerstone of robust software architecture. This project explores the Compact Constructor feature of Java Records. Unlike traditional constructors, a compact constructor doesn't require explicit parameter declarations or field assignments; its primary purpose is data validation and normalization. In this email registration simulation, the Email record strictly enforces business rules: preventing null values, empty strings, and malformed addresses without the "@" symbol. This approach ensures that every instance of Email in the system is guaranteed to be valid.
Task 397 Weather Station: Factory Methods in Records V0.1 — Weather monitoring systems often encounter heterogeneous data sources. This project demonstrates the use of Static Factory Methods within Java Records to handle data conversion. By implementing the fromFahrenheit() method, the Temperature record gains the ability to encapsulate complex conversion logic while maintaining its primary focus as a Celsius data carrier. This approach improves API clarity and ensures that conversion formulas are centralized within the relevant data model.

Auto-generation: equals, hashCode, toString.

Task 396 Product Catalog: Identity Logic V0.1 — In e-commerce systems, a product's identity is often defined by its name or SKU, while attributes like price may fluctuate. This project demonstrates how to Override Core Record Methods (equals and hashCode). While Java Records provide default value-based equality for all components, we can refine this behavior to focus only on specific fields. In this simulation, two Product instances are considered identical if their names match, regardless of their price differences. This ensures consistent behavior in collections and search operations.
Task 395 Social Network: Custom Record Formatting V0.1 — Standard data representations are often too technical for end-user applications. This project demonstrates how to Override Default Behavior in Java Records. While records automatically generate a toString() method, developers can provide a custom implementation to meet specific formatting requirements. In this social network profile simulation, we replace the default record syntax with a more readable, user-centric string format: User: [Name] ([Age] years). This maintains the record's efficiency while enhancing its presentation layer.
Task 394 Mapping System: Record Equality & Hashing V0.1 — In geographic information systems (GIS), coordinate precision and identity are paramount. This project demonstrates the Contractual Consistency of equals() and hashCode() within Java Records. Records provide an out-of-the-box implementation where equality is determined by the state of their components (X and Y coordinates). Crucially, they also ensure that equal objects produce identical hash codes, which is a mandatory requirement for Java's hash-based collections like HashSet or HashMap.
Task 393 Library Reports: Automatic String Representation V0.1 — Generating standardized reports requires consistent formatting of data objects. This project explores the Automatic toString() generation in Java Records. One of the core features of a record is that it provides a built-in, human-readable string representation of its state without any additional code. This project demonstrates how a Book record can be directly printed to the console, producing a clear output of its title and author, which is essential for logging, debugging, and report generation.

Immutability of record classes.

Task 392 Sensor Data: Shallow Immutability V0.1 — Understanding the boundaries of immutability is critical for processing streaming data. This project explores Shallow Immutability in Java Records. While a record's components are final and cannot be reassigned to new objects, if a component is a mutable object (like an array), its internal state can still be modified from the outside. This demonstration shows how a record stores a reference to an existing array, allowing external changes to reflect inside the record, highlighting the importance of defensive copying in secure system design.
Task 391 Game Coordinates: Record Transformation V0.1 — In game development, tracking object positions with precision is essential. This project demonstrates how to handle spatial data using Java Records. Given that records are immutable, "moving" an object requires creating a new record instance with updated coordinates derived from the original. This pattern, known as a Wither-like transformation, ensures that the original state remains intact while producing a new state, facilitating easier debugging and state management in grid-based systems.
Task 390 Historical Catalog: Record Immutability V0.1 — When managing historical or critical data, ensuring that information remains unchanged is a key architectural requirement. This project explores the Immutability of Java Records. Unlike traditional classes, records do not provide setter methods, and their components are implicitly private and final. This demonstration attempts to modify a HistoricalFigure record using standard class approaches, proving that records are inherently read-only and thread-safe data carriers.
Task 389 Library Tracker: Book Records V0.1 — In data-oriented applications, managing object states efficiently is crucial. This project demonstrates the implementation of a Java Record to act as a simple data carrier for book information. By using the record keyword, we leverage built-in immutability and automatic accessor methods. This approach simplifies the code and ensures that each book entry remains consistent throughout the application's lifecycle.

Record: syntax, advantages.

Task 388 Access Management: Records in Hash-Based Collections V0.1 — In security and access control systems, identifying a user based on their data profile is a fundamental task. This project explores the Interoperability of Java Records and HashMaps. Since Records automatically provide stable and consistent implementations of hashCode() and equals(), they act as perfect immutable keys for collections. This demonstration shows how a user can be identified and their role retrieved even when using a newly instantiated lookup object, provided the internal components (Name and ID) remain identical.
Task 387 City Catalog: Record Equality V0.1 — In data-centric applications, comparing two objects based on their content rather than their memory address is a frequent requirement. This project explores the Automatic Equality feature of Java Records. Unlike standard classes where equals() must be manually implemented, Records automatically generate a structural equality check. This ensures that two separate instances with identical component values are considered equal, promoting reliable data handling in catalogs and collections.
Task 386 Student Records: Record Accessors V0.1 — Efficient data retrieval is a cornerstone of any administrative system. This project explores the Accessor Methods of Java Records. Unlike traditional POJOs that rely on the get prefix, Records provide accessors with the same name as the components they represent. This project demonstrates how to instantiate a Student record and retrieve its individual components using these automatically generated, concise methods, ensuring high readability and reducing boilerplate code.
Task 385 Digital Library: Data Records V0.1 — Modern Java development focuses on reducing boilerplate code for classes that primarily act as data carriers. This project demonstrates the use of Java Records. By defining BookCard as a record, we eliminate the need for manual constructor definition and getter methods. This ensures that our "digital library cards" are immutable, thread-safe, and highly readable, following the best practices of functional and clean code architecture.

👉 Advanced interfaces and functional interfaces.

Interfaces from the standard library: Comparable, Serializable, etc.

Task 384 Resource Management: AutoCloseable V0.1 — Handling sensitive system resources like database connections, sockets, or file streams requires guaranteed release logic. This project explores the AutoCloseable interface and the try-with-resources statement. By implementing the close() method, the DemoResource class ensures that its cleanup logic is executed automatically at the end of the try block. This modern Java approach (introduced in Java 7) eliminates the need for manual resource management and reduces the risk of resource leaks.
Task 383 Online Store: Dynamic Sorting V0.1 — Standard object sorting often needs to be overridden for specific business cases. This project explores the use of the Comparator<T> interface via an Anonymous Class. Unlike Comparable, which defines a permanent natural order, a Comparator allows for ad-hoc sorting logic. By implementing a name-based comparison on the fly, we can sort a list of Product objects alphabetically without altering the core class logic, demonstrating high flexibility and decoupling in Java.
Task 382 Urban Planning: Automated Sorting V0.1 — Urban data analytics require efficient ways to organize information. This project demonstrates how the Comparable<T> interface integrates with the Java Collections Framework. By defining a "natural order" based on population, we enable the Collections.sort() method to process a list of City objects automatically. This showcases the power of polymorphism and standardized interfaces in Java for solving real-world data organization tasks.
Task 381 Smart Container: Object Comparison V0.1 — In software systems, objects often need an inherent way to define their "natural order." This project demonstrates the implementation of the Comparable<T> interface. By implementing the compareTo() method, the NumberBox class gains the ability to compare itself with other instances. This internal logic is essential for enabling automatic sorting and searching within standard Java collections.

Static methods in interfaces.

Task 380 Unified Logging: Private Interface Methods V0.1 — Ensuring consistent formatting across different log levels is a common requirement in enterprise applications. This project demonstrates the use of Private Static Methods in Interfaces. Introduced in Java 9, this feature allows developers to share common logic between multiple static or default methods without exposing that logic to the outside world. By encapsulating the formatting logic within a private format() method, we maintain a clean API while ensuring that all log messages follow the exact same structural pattern.
Task 379 Math Utility: Instance vs. Static Methods V0.1 — In engineering applications, distinguishing between object-specific behavior and global utility functions is vital for code organization. This project demonstrates the coexistence of Default Methods and Static Methods within a single interface. The printSquare method provides a default instance-level implementation, while printCube acts as a global static utility. This separation allows for flexible inheritance patterns while maintaining a centralized repository for common mathematical operations.
Task 378 Modular Printer: Static Dispatchers V0.1 — In modular systems, it is often useful to have centralized functions that can operate on any component implementing a specific interface. This project demonstrates a Static Interface Method acting as a universal utility. The printHello method within the Printer interface accepts an instance of Printer and invokes its abstract print() method with a predefined string. This pattern centralizes common operations, reducing code duplication and ensuring that all components share a consistent greeting logic.
Task 377 Web Registration: Static Interface Methods V0.1 — Utility functions often clutter project structures when placed in separate "Utils" classes. This project demonstrates the use of Static Methods in Interfaces to keep related helper logic encapsulated. By defining isEmpty as a static method within the StringChecker interface, we provide a globally accessible validation tool that doesn't require object instantiation. This approach follows the principle of high cohesion, ensuring that the interface provides both the contract and the necessary tools to work with it.

Default methods in interfaces.

Task 376 Module Integration: Conflict Resolution V0.1 — In modular programming, integrating independent components often leads to naming collisions. This project demonstrates how Java handles Multiple Interface Implementation when default method conflicts occur. By implementing interfaces A and B in class C, we encounter two identical show() signatures. We resolve this by explicitly invoking each interface's version using the InterfaceName.super.method() syntax. This ensures a predictable execution order and maintains the integrity of both original modules within a single unified system.
Task 375 Notification System: Method Chaining V0.1 — Code reuse can be achieved not only through inheritance but also by defining composite logic within interfaces. This project demonstrates how a Default Method can call an Abstract Method within the same interface. By defining printTwice() in the Printer contract, we provide a pre-built algorithm that depends on the concrete implementation of print(). This ensures that any new printer type automatically gains "doubling" capabilities without additional coding.
Task 374 Virtual Zoo: Interface Method Overriding V0.1 — In object-oriented design, a default implementation in an interface provides a fallback behavior. This project explores the Overriding of Default Methods. While the Animal interface defines a universal sleep() pattern, the Dog class provides its own specialized implementation. This demonstrates the hierarchy of method resolution in Java: a concrete implementation in a class always takes precedence over a default method in an interface. This is a key technique for creating extensible and customizable software components.
Task 373 Smart Device Remote: Default Methods V0.1 — In hardware and software interface design, certain operations are universal across all implementations. This project demonstrates the use of Interface Default Methods to provide a standard "factory reset" functionality. By defining reset() within the Counter interface, we ensure that every implementing device possesses this capability without requiring manual re-implementation. This promotes code reuse and ensures a consistent behavior across different device models.

Method References ( : : ): references to methods.

Task 372 Virtual Pet Simulator: Constructor References V0.1 — Manually instantiating objects can lead to rigid code structures. This project explores Constructor References, a specialized form of method reference that points to a class constructor. By binding the AnimalFactory interface to the Animal : : new reference, we decouple the logic of "when to create" from "how to create". This approach is essential for modern Java patterns, such as the Abstract Factory and the use of Collectors in Stream API.
Task 371 Warehouse Inventory: Alphabetical Sorting V0.1 — In logistics and warehouse management, quick data organization is essential for efficiency. This project demonstrates Method References to Instance Methods of Arbitrary Objects. Instead of manually defining a comparison lambda, we leverage the existing String.compareToIgnoreCase method. This allows the List.sort mechanism to treat the method as a functional interface implementation, resulting in highly readable and idiomatic Java code.
Task 370 Custom Logging: Object Method References V0.1 — Abstracting output mechanisms is a key step towards building maintainable logging systems. This project focuses on Non-static Object Method References. Instead of creating a new lambda block, we bind a functional interface directly to the println method of the existing System.out instance. This creates a "delegate" that can be passed around the application, allowing any component to log messages without needing direct knowledge of the underlying output stream.
Task 369 Smart Device Firmware: Static Method References V0.1 — Efficiency and readability are crucial in firmware development. This project explores Method References, a shorthand notation for a lambda expression that executes a single method. Instead of writing a manual transformation logic, we use a reference to the static Integer.toHexString method. This demonstrates how to leverage existing Java Standard Library functions within a functional programming context to produce clean, maintainable code.

Introduction to Lambda Expressions.

Task 368 Financial Reporting: Data Transformation V0.1 — In financial systems, raw data must often undergo specific transformations and formatting before being presented to the user. This project demonstrates the Function<T, R> functional interface. We implement a formatting pipeline that doubles a numerical value and prepends a standard prefix. This illustrates the core functional concept of "mapping" — converting an input of one type (Integer) into a result of another type (String).
Task 367 Absolute Power Ranking: Custom Comparators V0.1 — Standard sorting algorithms typically follow the natural ordering of data types. However, specific business logic often requires custom comparison rules. This project demonstrates the power of the Comparator<T> functional interface combined with lambda expressions. We implement a sorting mechanism for athlete results where the "power of the blow" is measured by its absolute value, regardless of direction (sign). This approach allows for flexible data organization without modifying the original data structure.
Task 366 User Data Processing: Standard Consumers V0.1 — Consistency in data storage often requires pre-processing of user inputs. This project demonstrates the application of the Consumer<T> functional interface. Unlike other functional interfaces, a Consumer is designed to perform an operation on a given argument without returning a result (side-effect only). We implement a text handler that accepts a string, normalizes it by converting it to uppercase, and outputs it to the console. This pattern is widely used in stream processing and reactive programming to handle data elements.
Task 365 Announcement System: Parameterless Lambdas V0.1 — Functional programming in Java isn't always about processing data; sometimes it's simply about encapsulating a block of code to be executed later. This project demonstrates Parameterless Lambda Expressions using the standard Runnable interface. Since the run() method in Runnable takes no arguments and returns void, the lambda syntax is stripped down to its most basic form: () -> { logic }. This approach is fundamental for task scheduling and defining simple executable actions within an application.

👉 Interfaces.

Interfaces in Java architecture, design patterns.

Task 364 Battle Arena System: OOP & Polymorphism V0.1 — This project simulates a simple Battle Arena where different types of characters interact through combat mechanics. It demonstrates core Object-Oriented Programming principles such as inheritance, polymorphism, abstraction, and interface-based design. All characters share common behavior (health, attack capability), while specific roles (Warrior, Mage, Robot) define their unique combat styles. The system is designed to be extensible and flexible, allowing new character types and abilities to be added without modifying existing logic.
Task 363 News Distribution: Observer Pattern V0.1 — Maintaining consistency between related objects without tight coupling is a common challenge. This project implements the Observer Design Pattern, creating a subscription mechanism to notify multiple objects about any events that happen to the object they’re observing. The NewsPublisher maintains a dynamic list of Subscriber interfaces, ensuring that whenever news is released, every registered Person is updated simultaneously. This architecture is the foundation for event-driven systems and UI frameworks.
Task 362 Dynamic Greeter: Strategy Pattern V0.1 — Static behavior limits the adaptability of software. This project implements the Strategy Design Pattern, which enables an object's behavior to be selected at runtime. By encapsulating different greeting styles into separate classes (FriendlyGreeting, FormalGreeting) that implement a common GreetingStrategy interface, the Greeter class can switch its personality dynamically. This promotes the Open/Closed Principle, as new greeting strategies can be added without modifying the existing Greeter code.
Task 361 Notification Service: Dependency Injection V0.1 — Hard-coding dependencies makes software rigid and difficult to test. This project demonstrates Decoupling through the Dependency Injection pattern. By creating a Notification class that accepts a MessageSender interface, we ensure that the notification logic is agnostic of the delivery method. Whether the system sends an Email, SMS, or Push notification, the Notification class remains unchanged. This is a fundamental principle used in enterprise frameworks to build scalable and maintainable systems.
Task 360 Event Logging System: Strategy Pattern V0.1 — In mission-critical applications, the ability to switch output destinations without altering core logic is vital. This project implements a Flexible Logging System using interface-based polymorphism. By defining a universal Logger contract, the system can treat ConsoleLogger and FileLogger as interchangeable components. This architectural approach follows the Dependency Inversion Principle, where high-level modules depend on abstractions (interfaces) rather than concrete implementations.

Functional interfaces: @FunctionalInterface.

Task 359 Text Processing Utility: Default Methods V0.1 — Prior to Java 8, interfaces could only contain abstract methods, forcing every implementation to duplicate common logic. This project explores Interface Default Methods, a feature that allows developers to add concrete functionality to an interface without breaking its contract. By defining a transform method and a printTransformed default method, we create a template that not only dictates a rule but also provides a built-in utility to execute and display that rule. This pattern is widely used in Java's Standard Library to provide convenient shorthand operations.
Task 358 Input Validation: Standard Predicates V0.1 — Instead of reinventing the wheel by creating custom functional interfaces, Java provides a robust library of built-in functional interfaces in the java.util.function package. This project explores the Predicate<T> interface, which is the industry standard for representing a boolean-valued function of one argument. We implement a string length validator that classifies text as "long" if it exceeds 5 characters. This demonstrates how standard library tools can simplify code and improve interoperability across different Java modules.
Task 357 Score Achievement System: Predicate Logic V0.1 — In game mechanics, verifying thresholds (like reaching a high score) is a repetitive task that benefits from a flexible design. This project implements a Number Checker using a functional approach. By defining the NumberChecker interface, we create a contract for boolean evaluation. The implementation uses a Lambda Expression to define the specific rule: "Is the score greater than 100?". This pattern allows developers to swap checking rules (e.g., checking for even numbers or negative values) without changing the underlying architecture.
Task 356 Notification System: Functional Interfaces V0.1 — Modern Java development prioritizes conciseness and readability. This project introduces Functional Interfaces and Lambda Expressions. By using the @FunctionalInterface annotation, we explicitly define a contract with exactly one abstract method. Instead of writing verbose concrete classes for every notification type, we use lambdas to implement the MessagePrinter logic inline. This approach is essential for event-driven programming and functional data processing in Java.

Multiple implementation of interfaces.

Task 355 Universal Media Center: Behavioral Roles V0.1 — In sophisticated media systems, a single physical component often fulfills multiple logical roles. This project explores Role-Based Polymorphism. By defining Player and Recorder interfaces, we establish distinct behavioral expectations. The MediaDevice class implements both, allowing a single instance to be treated as a playback unit in one context and a recording unit in another. The testDevice static method demonstrates this flexibility by accepting interface types, proving that the system cares about "what an object can do" rather than "what an object is."
Task 354 Universal Control Panel: Interface Collision V0.1 — In modular systems, different interfaces may occasionally define methods with identical signatures. This project explores how Java handles Interface Method Collisions. By implementing both InterfaceA and InterfaceB, which both declare a doAction() method, the MultiAction class provides a single unified implementation that satisfies both contracts simultaneously. This demonstrates the efficiency of Java's type system in resolving overlapping behavioral requirements.
Task 353 User Management: Custom & Standard Interfaces V0.1 — In real-world Java applications, objects often need to satisfy both domain-specific requirements and platform-level standards. This project implements a User Profile System that integrates a custom Nameable contract with the standard java.io.Serializable interface. While Nameable defines explicit behavior (retrieving a name), Serializable acts as a Marker Interface, signaling to the Java Virtual Machine that the object's state can be persisted or transmitted. This dual-interface approach ensures that user data is both accessible and compatible with Java's native serialization mechanisms.
Task 352 Graphics Editor: Multi-Contract Design V0.1 — Advanced graphics systems require objects to support various lifecycle actions beyond simple rendering. This project implements a Multi-Contract Architectural Pattern. By defining Drawable and Erasable as distinct interfaces, we follow the Interface Segregation Principle, ensuring that components only implement the behaviors they actually need. The Sketch class acts as a versatile canvas element that integrates both capabilities, allowing it to be managed by rendering engines and cleanup utilities alike.

The difference between interfaces and abstract classes.

Task 351 Smart Home: Hybrid Architecture V0.1 — Designing a smart home ecosystem requires a balance between general standards and specialized features. This project demonstrates a Hybrid Architectural Model. The Appliance abstract class provides a common foundation for all home devices, including shared logic for powering on. The Chargeable interface acts as a specific protocol for battery-powered equipment. The SmartPhone class integrates both, inheriting the general characteristics of an appliance while fulfilling the specific charging contract.
Task 350 Multi-Function Device: Multiple Interface Implementation V0.1 — Modern office hardware often combines several distinct functionalities into a single physical unit. This project models such a Multi-Function Device (MFD) by leveraging Java's ability to implement multiple interfaces. By separating the Printable and Scannable capabilities into individual protocols, we adhere to the Interface Segregation Principle. The MultiFunctionDevice class then integrates these separate behaviors, proving that a single Java class can satisfy multiple behavioral contracts simultaneously.
Task 349 University Management: Abstraction vs Interfaces V0.1 — In sophisticated systems like university management, it is crucial to distinguish between shared behaviors and shared state. This project explores the Hybrid Inheritance model. By using an abstract Person class, we manage mutable state (the student's name), while the Identifiable interface provides a global, immutable contract (the universal ID). This task highlights why interface fields are implicitly constants and why abstract classes are better suited for individual object properties.
Task 348 Fleet Management: Protocol Abstraction V0.1 — In industrial-grade software, uniformity is the key to scalability. This project implements a Standardized Movement Protocol using the Movable interface. By defining a single move() method, we establish a contract that all transport modules must follow. The Car class serves as a concrete implementation of this protocol. This architectural pattern allows the fleet management system to control diverse vehicle types through a single, unified interface, promoting loose coupling and high modularity.

The concept of an interface, declaration syntax.

Task 347 Virtual Pet Simulation: Interface Polymorphism V0.1 — In game development, handling diverse entities with shared behaviors is a fundamental challenge. This project implements a Virtual Pet Simulation core using the Soundable interface. By defining a common "sound ability," we can manage different animals like Dog and Cat within a single unified collection. This project highlights how interfaces allow for the creation of a "zoo" (an array of interface types) where each object responds to the same command with its own unique implementation.
Task 346 Scientific Calculator: Immutable Constants V0.1 — In scientific computing, the integrity of fundamental constants is paramount. This project demonstrates how to use Java Interfaces as Constant Repositories. By defining PI within the MathConstants interface, we ensure that the value is globally accessible, immutable, and consistent across all modules of the calculator. The Calculator class implements this interface to "inherit" these mathematical truths, providing a clean and type-safe way to access shared data without the need for magic numbers.
Task 345 Interactive Drawing: Behavior Abstraction V0.1 — In drawing applications, the ability to process various shapes through a unified mechanism is a core requirement. This project implements a Universal Drawing Contract using the Drawable interface. By separating the "what to do" (the draw() method) from the "how to do it" (the specific shape logic), the application achieves high flexibility. Any new shape created in the future can be integrated into the existing drawing logic simply by implementing the Drawable interface.
Task 344 Smart Home Assistant: Interface Definition V0.1 — Creating a smart assistant requires a standardized way to handle interactions across different types of entities. This project introduces the concept of Interfaces in Java. By declaring the Greetable interface, we define a common contract or "ability" that any class can implement. The Person class serves as the first module to adopt this ability. This approach demonstrates how interfaces separate the declaration of behavior from its actual implementation, allowing for highly decoupled and modular code.

👉 Abstraction and abstract classes.

Simplifying complex systems with abstractions.

Task 343 Universal Task Manager: Advanced Polymorphism V0.1 — A truly extensible system must handle specialized data without sacrificing architectural simplicity. This project evolves the Task Manager by introducing specialized task types: WorkTask (with deadlines) and HomeTask (with locations). Despite their different attributes, both are managed as a unified collection of Task objects. The TaskService and TaskRepository operate strictly on high-level abstractions, demonstrating how polymorphism allows a system to remain open for extension but closed for modification.
Task 342 Modular Task Manager: Layered Architecture V0.1 — Building scalable software requires strict separation of concerns. This project demonstrates a Three-Tier Architecture coupled with Constructor Dependency Injection.
Task 341 Task Management: Service Layer & Abstraction V0.1 — As applications grow in complexity, separating business logic from data access becomes essential. This project implements the Service Layer pattern within the Task Manager. The TaskService acts as the "brain" of the system, coordinating high-level operations like adding and completing tasks. By depending on the TaskRepository abstraction rather than a concrete implementation, the service remains decoupled from storage details, adhering to the Dependency Inversion Principle.
Task 340 Task Management Core: Abstraction V0.1 — Efficient team productivity relies on a structured way to manage various activities. This project implements a Task Management Core using an abstract Task class. It manages a common title field for all task types and establishes a mandatory complete() contract. The SimpleTask implementation provides a basic realization of this contract, demonstrating how subclasses can utilize parent state (title) to provide meaningful feedback upon task execution.

Examples of constructing abstractions in real-world problems.

Task 339 Order Management System: Retail Abstraction V0.1 — Large-scale retail systems must handle diverse transaction types while maintaining a unified processing pipeline. This project implements an Order Management System using an abstract Order class. By encapsulating the order amount in the base class and defining a mandatory process() contract, we separate the common data from the specific processing logic required for online and offline environments. This architecture demonstrates the Open/Closed Principle, where the system is open for new order types but closed for modification of the processing loop.
Task 338 Fleet Management: Dynamic Polymorphism V0.1 — Managing a diverse fleet of transport units requires both a unified interface and a flexible data structure. This project implements a Fleet Management System utilizing an abstract Vehicle class and a dynamic ArrayList. By encapsulating the model state in the base class, we ensure consistency across all transport types. The Car and Bicycle implementations demonstrate specialized movement logic, while the use of a generic list allows the system to process any number of vehicles polymorphically.
Task 337 Notification System: Delivery Abstraction V0.1 — In modern applications, communication with users happens through various channels. This project implements a Universal Notification System using an abstract Message class. By encapsulating the common message content (text) in the base class and defining a mandatory send() contract, we decouple the content from its delivery mechanism. The EmailMessage and SmsMessage classes provide the specific implementation details for their respective communication protocols.
Task 336 Universal Graphics Module: Shape Abstraction V0.1 — In graphics applications, treating different geometric objects through a unified interface is essential for scalability. This project establishes a basic Shape Abstraction model. By defining an abstract Shape class, we create a mandatory requirement for any geometric entity to provide its area. The Circle class serves as the first concrete implementation, encapsulating the specific mathematical logic required to calculate the area of a circular object based on its radius.

Implementation of abstractions and hierarchies.

Task 335 Universal Payment System: Polymorphic Processing V0.1 — Modern retail requires the ability to process multiple payment methods seamlessly. This project implements a Flexible Payment System leveraging Java's polymorphic capabilities. By defining an abstract Payment class, we establish a common contract for all financial transactions. The CashPayment and OnlinePayment subclasses provide specific implementations of the process() method. The project highlights the use of a base-type array to store and iterate through different payment objects, triggering their unique behaviors through a single unified loop.
Task 334 HR System Core: Employee Abstraction V0.1 — In corporate software, managing employee data requires a clear distinction between common identity and role-specific attributes. This project implements a Fundamental HR Module using an abstract Employee class. The base class manages shared state (the name field) and provides a concrete getName() method. Meanwhile, it enforces a getSalary() contract that must be fulfilled by concrete subclasses. The Manager class demonstrates how to implement this contract by returning a fixed compensation value while reusing the name-handling logic of the parent.
Task 333 Geometry Library: Polymorphic Area Calculation V0.1 — In computational geometry, abstraction allows us to treat distinct shapes as a unified collection of figures. This project implements a Geometry Library foundation using an abstract Figure class. By defining a mandatory area() contract, we ensure that every shape added to the library—whether it is a Square or a Circle—can provide its area on demand. This approach encapsulates the unique mathematical formulas ($side^2$ and $pi r^2$) within their respective classes while providing a consistent interface for the application.
Task 332 Traffic Simulator: Basic Movement Model V0.1 — In simulation systems, abstraction allows us to manage complex behaviors through simplified interfaces. This project establishes a basic Traffic Simulator Model. By defining an abstract Vehicle class, we set a universal rule for any transport unit: it must be capable of movement. The Car class provides the first concrete realization of this rule. This task demonstrates the core of Polymorphism, where a variable of a general base type can successfully trigger specific subclass behavior.

Abstract classes and methods: syntax, examples.

Task 331 IT HR System: Polymorphic Payroll V0.1 — Calculating payroll in a diverse organization requires a flexible architectural approach. This project implements a Polymorphic Salary System. By using an abstract Employee class, we define a common interface for all staff members while allowing specific roles like Manager and Developer to encapsulate their unique financial logic. Whether it's a fixed monthly rate or an hourly-based compensation, the system processes all employees through a unified loop, adhering to the Open/Closed Principle.
Task 330 Graphics Editor: Area Calculation V0.1 — In advanced graphics systems, shapes are treated as abstract entities that share common properties like names but possess unique mathematical behaviors. This project demonstrates how to use an Abstract Class to manage shared state (the name field) and enforce a specific behavioral contract (the area() method). The Circle subclass shows the practical application of Constructor Chaining to pass data to the parent class and the implementation of geometric formulas using Java's Math library.
Task 329 Smart Home System: Device Control Logic V0.1 — A well-designed smart home system requires a balance between specialized behavior and universal standards. This project implements a Smart Device Framework using an abstract Device class. It demonstrates how to combine abstract methods (for device-specific "turn on" procedures) with concrete methods (for a standardized "turn off" algorithm). By inheriting from this base, the Phone class provides its own unique startup sequence while automatically gaining the standard shutdown functionality provided by the parent class.
Task 328 Digital Zoo: Foundation and Implementation V0.1 — The core of Object-Oriented Programming lies in the ability to define general rules for specific entities. This project establishes the Digital Zoo Foundation. By utilizing an Abstract Class, we create a blueprint for all animals. The abstract method makeSound() serves as a mandatory requirement for any concrete species added to the system. The implementation of the Dog class shows how a specific entity fulfills this requirement, providing its own "voice" while remaining compatible with the general Animal type.

Abstraction in OOP: Why and How to Use It.

Task 327 Payment Processing: Hybrid Abstraction V0.1 — In commercial applications, payment flows often share common steps while maintaining unique execution logic for different providers. This project demonstrates a Hybrid Abstract Class approach. The Payment class provides a concrete printInfo() method to handle universal notification logic, ensuring consistency across the module. Simultaneously, it defines an abstract process() method, forcing specific implementations like PaypalPayment to define their own transaction security and logic. This structure reduces code duplication while maintaining strict architectural requirements.
Task 326 City Transportation System: Abstract Movement V0.1 — In urban planning and software engineering, it is essential to treat different entities through a unified interface. This project implements a City Transportation System using an abstract Vehicle class. By defining a mandatory move() contract, we ensure that every transport type—be it a car or a bicycle—can be "animated" by the system. This project also demonstrates the use of Polymorphic Collections (ArrayList<Vehicle>), showing how a single list can manage diverse objects and trigger their specialized behaviors during iteration.
Task 325 Zoo Simulator: Concrete Implementation V0.1 — An abstract class remains an empty idea until a concrete subclass brings it to life. This project demonstrates the Implementation of Abstract Methods. By creating the Dog class as a descendant of Animal, we are forced to provide a body for the makeSound() method. This step illustrates the transition from a general concept (all animals make sound) to a specific reality (a dog barks). Using a polymorphic reference (Animal dog = new Dog()) further emphasizes how we can treat specific objects through their general interface.
Task 324 Zoo Simulator: The Pure Blueprint V0.1 — In the early stages of system design, it is often more important to define what an object should do rather than how it does it. This project focuses on creating a minimal Abstract Class structure. The Animal class acts as a baseline contract for the entire zoo simulator. By declaring makeSound() as an abstract method without an implementation, we create a strict requirement: any biological entity added to the zoo in the future MUST define its own vocalization, or the code will not compile. This ensures architectural consistency and prevents the existence of silent or "generic" animals.

👉 Polymorphism and overloading.

The relationship between polymorphism and abstract classes.

Task 323 Digital Farm: Abstract State and Behavior V0.1 — An Abstract Class is more than just a list of required methods; it can also hold shared data. This project demonstrates how to combine an abstract contract (makeSound()) with common state (name). By defining the name field in the Animal base class, we ensure that every inhabitant of our digital farm has an identity. Subclasses like Cat and Cow leverage the parent constructor to initialize this identity while providing their own unique implementation of the sound logic. This approach highlights how inheritance reduces redundancy by centralizing shared attributes.
Task 322 Team Management: Abstract Arrays and Polymorphism V0.1 — In a professional environment, complex systems are managed through layers of abstraction. This project demonstrates how an Abstract Class can be used as a common type for an array, allowing the storage of diverse objects like Manager and Developer. The abstract work() method ensures that every member added to the Employee array has a defined behavior. During iteration, Java's dynamic binding ensures that the correct, specialized work activity is displayed, proving that a unified interface can effectively manage specific implementations.
Task 321 Pet Simulator: Fulfilling Abstract Contracts V0.1 — In software design, an Abstract Class acts as a blueprint that cannot be instantiated on its own. It defines what a group of objects should do, but not necessarily how they do it. This project demonstrates the transition from an abstract concept to a concrete implementation. The Animal class defines a mandatory makeSound() contract, which the Dog class must implement. This ensures that every specific animal added to the simulator will have its own "voice," maintaining architectural integrity through enforced polymorphism.
Task 320 Graphics Editor: The Power of Abstraction V0.1 — Abstraction is the process of hiding the implementation details and showing only the functionality to the user. This project demonstrates the use of Abstract Classes and Abstract Methods. By marking the Shape class as abstract, we prevent the instantiation of a generic shape, as a "shape" without a specific form cannot be drawn. The abstract draw() method acts as a mandatory contract: every concrete subclass (like Circle or Square) must provide its own implementation of this method to be valid.

Using polymorphism in practice.

Task 319 Task Management System: Scalable Architecture V0.1 — The primary goal of a senior developer is to write code that doesn't need to be rewritten every time requirements change. This project demonstrates Advanced Polymorphism and the Open/Closed Principle. By encapsulating the iteration logic in a universal method printWorkForAll(Employee[]), we create a system where adding a new type of worker (like an Intern) requires zero changes to the processing logic. This decoupling ensures that the system remains stable and maintainable even as the organization expands.
Task 318 Scalable HR System: Seamless Integration V0.1 — The true test of a software architecture is its response to change. This project demonstrates the Scalability of Polymorphism. By adding a Tester role to our existing Employee hierarchy, we show that the system's core logic—the team iteration loop—requires zero modifications to handle new types of employees. This follows the Open/Closed Principle: the system is open for extension (adding new roles) but closed for modification (the processing logic remains stable).
Task 317 Intelligent HR System: Polymorphic Team Management V0.1 — Efficient resource management requires treating different entities through a unified abstraction. This project explores Polymorphic Arrays in an HR context. By utilizing a base Employee type to store diverse roles like Manager and Developer, we demonstrate how a single loop can trigger context-specific behaviors. This "Team" management approach highlights the power of dynamic binding, allowing the system to scale—new roles can be added to the company without modifying the core logic of the team activity tracker.
Task 316 Digital Encyclopedia: Polymorphic Voices V0.1 — A well-structured system allows different entities to be handled through a single, unified interface. This project demonstrates Polymorphism within a "Digital Encyclopedia" context. By defining a generic Animal reference for both Dog and Cat objects, we show how Java determines which method to call based on the actual object type at runtime. This ensures that even when stored as generic animals, dogs "bark" and cats "meow," maintaining their unique characteristics within a standardized system.

Method overriding: different from overloading.

Task 315 Virtual Pet Care: Extending Behavior with 'super' V0.1 — Inheritance allows us to reuse code, but sometimes we need to execute both the parent's logic and the child's logic. This project explores the super keyword. By calling super.makeSound() within the overridden method of the Cat class, we ensure that the foundational behavior of the Animal class is preserved before the specific "Meow!" is added. This technique is essential for building "additive" behavior where each layer of the inheritance hierarchy contributes its own part to the final result.
Task 314 Graphics Editor: Safe Overriding V0.1 — In robust software development, ensuring that methods are correctly overridden is vital for predictable behavior. This project demonstrates the use of the @Override annotation in a Graphics Editor scenario. By applying this annotation to the draw() method in the Circle subclass, we provide a clear instruction to the compiler to verify the existence of a matching method in the Shape base class. This prevents common errors such as typos in method names and reinforces the principles of polymorphism, where a Shape reference correctly invokes the specialized Circle logic.
Task 313 Advanced Printing System: Overloading vs Overriding V0.1 — Understanding the distinction between Overloading and Overriding is fundamental to mastering Java. This project implements an Advanced Printing System where a ColorPrinter utilizes both concepts. The base Printer class provides overloaded methods to handle different data types (int and String). The ColorPrinter subclass then overrides the specific print(String) method to provide specialized "colored" output. This demonstrates how subclasses can inherit certain behaviors while selectively modifying others to suit specific requirements.
Task 312 Virtual Zoo: Basic Method Overriding V0.1 — In object-oriented programming, a subclass can provide a specific implementation of a method that is already defined in its superclass. This project demonstrates Method Overriding. By defining a makeSound() method in the Animal class and then redefining it in the Dog class, we ensure that when we call this method on a Dog object, the more specific "Woof!" is executed instead of the generic "Animal makes sound." This allows for specialized behavior while maintaining a consistent interface.

Method overloading.

Task 311 Graphic Design Tool: Constructor Overloading V0.1 — Efficiency in object creation is a hallmark of well-designed software. This project demonstrates Constructor Overloading within a Rectangle class. By providing multiple constructors, we allow the class to handle different initialization scenarios: creating a perfect square with a single dimension or a custom rectangle with specific width and height. This technique reduces boilerplate code and makes the class more intuitive to use, as the object itself "knows" how to set its internal state based on the provided arguments.
Task 310 Receptionist Robot: Flexible Greetings V0.1 — User experience is often determined by how well a system handles varying levels of input data. This project demonstrates Method Overloading by Parameter Count through a "Receptionist Robot" simulation. The Greetings class provides two versions of the sayHello method: one for casual interactions (first name only) and one for formal settings (full name). This architectural approach allows the robot to remain polite and functional regardless of how much information is available about a guest, maintaining a clean and intuitive API.
Task 309 Math Engine: Numeric Overloading V0.1 — Precision and flexibility are key in computational software. This project demonstrates Method Overloading applied to arithmetic operations. The Multiplier class provides a unified interface for multiplication, supporting both int and double data types. By overloading the multiply method, we allow the compiler to distinguish between integer arithmetic and floating-point precision at compile-time. This ensures that the caller gets the most appropriate return type and precision without needing to manage multiple method names.
Task 308 Smart Printer: Method Overloading V0.1 — In software development, providing a clean and intuitive API is crucial. This project explores Static Polymorphism (Method Overloading) using a MessagePrinter utility. Method overloading allows multiple methods in the same class to share the same name, provided their parameter lists are unique. This enables the printMessage method to behave differently based on whether it receives a String or two int values, simplifying the class interface for the end-user and improving code readability.

The concept of polymorphism and why it is needed.

Task 307 City Fleet: Scalable Polymorphism V0.1 — The true power of Object-Oriented Programming lies in its ability to handle growth. This project simulates a city fleet "parade" to demonstrate how Polymorphism simplifies system maintenance. By treating diverse transport types (Car, Bicycle, Scooter) as a unified Vehicle array, we can trigger their unique movements through a single, consistent loop. Adding a new mode of transport—like the Scooter—requires zero changes to the parade's execution logic, illustrating high architectural flexibility and low coupling.
Task 306 HR System: Polymorphic Employee Roles V0.1 — In large enterprise systems, it is essential to manage various entities through a unified interface. This project demonstrates Polymorphism using an HR management scenario. By defining a generic Employee class and a specialized Developer subclass, we show how Java's runtime environment correctly identifies and executes specialized behavior. Even when a developer is treated as a generic employee in the code, their specific "work" (writing code) is correctly invoked, ensuring that the system remains both flexible and accurate.
Task 305 Virtual Farm: Polymorphic Iteration V0.1 — In large-scale systems, we often need to process collections of different objects that share a common behavior. This project demonstrates Polymorphic Iteration using a virtual farm scenario. By storing Cat and Cow objects in an Animal[] array, we can treat the entire "pen" as a single collection of animals. During iteration, Java's dynamic binding mechanism ensures that the correct makeSound() implementation is triggered for each specific species. This approach allows the system to scale easily—new animals can be added to the farm without changing the core iteration logic.
Task 304 Virtual Zoo: Polymorphism & Upcasting V0.1 — Polymorphism allows objects of different classes to be treated as objects of a common superclass. This project demonstrates Upcasting by treating a Dog instance as a generic Animal. Even though the reference variable is of type Animal, the Java Virtual Machine (JVM) correctly identifies the underlying object at runtime and executes the overridden makeSound() method. This decoupling of the reference type from the actual object type is the foundation of extensible software architecture.

👉 Inheritance and hierarchy.

Problems and limitations of inheritance.

Task 303 Animal Simulation: Dynamic Binding V0.1 — Polymorphism is one of the pillars of OOP, allowing a single interface to represent different underlying forms. This project explores Dynamic Binding. When a method is called on a reference of a superclass (Animal), Java determines which implementation to execute based on the actual object type at runtime (Cat). Even if the call happens inside a superclass method (sleep()), the overridden version in the subclass takes precedence. This enables highly flexible and extensible code architectures.
Task 302 Admissions Office: Constructor Execution Order V0.1 — In Java, object initialization follows a strict "top-down" approach within an inheritance hierarchy. This project demonstrates this mechanism through a University Admissions scenario. When a Student object is instantiated, the super() call ensures that the Person constructor finishes its execution before the Student constructor proceeds. This guarantees that all inherited state is properly established before the subclass adds its own logic, maintaining architectural integrity.
Task 301 Family Finances: Encapsulation & Private Access V0.1 — Encapsulation is the practice of hiding the internal state of an object and requiring all interaction to be performed through a well-defined interface. This project explores the private access modifier. By declaring familySecret as private in the Parent class, we ensure that no other class—not even a subclass like Child—can access it directly. This experiment demonstrates how Java enforces data security and prevents tight coupling between classes, forcing subclasses to use public or protected methods to interact with parent data.
Task 300 Advanced Pets: The Single Inheritance Limit V0.1 — In software engineering, we often want objects to inherit traits from multiple sources. This project explores why Java strictly forbids multiple inheritance for classes. By attempting to create a RoboDog that extends both Animal and Robot within the same domain package as a regular Dog, we observe a compilation error. This demonstrates the "Diamond Problem" prevention in Java: a class can only have one direct superclass, ensuring a clear and unambiguous method resolution path.

Creating a class hierarchy: real-life examples.

Task 299 Zoological Encyclopedia: Complex Hierarchies V0.1 — In biological and technical modeling, objects often belong to nested categories. This project demonstrates a Three-Tier Inheritance Hierarchy: Animal (Base) → Mammal (Intermediate) → Cat (Leaf). Each level adds or refines logic. The Mammal class introduces traits common to all mammals, while the Cat class provides specialized implementations (overriding eat()) and unique behaviors (purr()). This demonstrates how Java handles a chain of responsibility and state across multiple generations of classes.
Task 298 Educational System: Multilevel Inheritance V0.1 — In complex organizational structures, entities often follow a multi-layered classification. This project demonstrates Multilevel Inheritance, where a subclass acts as a superclass for another class. We establish a chain: Person (Grandparent) → Student (Parent) → SchoolStudent (Child). This architecture shows how behavior can be passed down through multiple generations and how the most specific implementation in the chain takes precedence when a method like introduce() is overridden.
Task 297 Driving School Simulator: Extended Behavior V0.1 — In modular software design, specialized objects often possess unique capabilities that their general counterparts do not. This project demonstrates Functional Extension through inheritance. The Vehicle superclass defines the essential move() behavior, while the Car subclass "extends" this by introducing a beep() method. This architecture proves that a subclass is a specialized version of its parent, inheriting existing logic while offering additional features specific to its role.
Task 296 Virtual Pet: Inheritance Fundamentals V0.1 — The core of Object-Oriented Programming is the ability to build specific objects based on general templates. This project demonstrates Basic Inheritance by modeling a virtual pet. The Animal class provides the foundational structure—a name and a feeding action—while the Dog class inherits these capabilities. This ensures that any Dog object is automatically an Animal, possessing all its data and logic without redundant declarations.

Using super: Calling the base class constructor and methods.

Task 295 University System: Hierarchical Registration V0.1 — In enterprise identity management systems, objects are often defined by their roles. This project demonstrates Constructor Chaining within a University Registration context. When a Student is registered, the system must first initialize them as a Person. By explicitly calling super(studentName), we ensure that the base attributes are set before adding student-specific data like the course number (class). This ensures that the object is fully formed according to its inheritance contract.
Task 294 Genealogy Tree: Field Shadowing V0.1 — In Java inheritance, when a subclass declares a field with the same name as a field in its superclass, the subclass field shadows the parent field. This project explores how to navigate this conflict using the super keyword. While the Cat class has its own name, the original name from the Animal class remains part of the object's state. Understanding shadowing is crucial for debugging complex hierarchies where variable names might overlap across different levels of inheritance.
Task 293 Vehicle Factory: Constructor Chaining V0.1 — In robust object-oriented systems, objects are built layer by layer. This project demonstrates Constructor Chaining using the super() keyword. When a Car is instantiated, it must first satisfy the requirements of its parent Vehicle. By passing the brand name to the super-constructor, we ensure that the foundational state of the object is established before the subclass adds its specific details (the manufacturing year). This reflects the architectural principle that a specialized entity is always a valid instance of its more general form.
Task 292 Animal Simulator: The 'super' Keyword V0.1 — In advanced inheritance scenarios, a subclass often needs to extend the behavior of its superclass rather than completely replacing it. This project demonstrates the use of the super keyword within an overridden method. By calling super.makeSound(), the Dog class triggers the original logic defined in Animal before executing its own specific "barking" code. This ensures consistency across the hierarchy and follows the principle of incremental refinement.

Method override, @Override annotation.

Task 291 Covariant Return Types: Fruit Harvest V0.1 — In Java, Covariant Return Types allow an overriding method to return a subtype of the type returned by the original method in the superclass. This project illustrates this using a "Basket" hierarchy. While a generic Basket provides a generic Fruit, a specialized AppleBasket is guaranteed to provide an Apple. This feature reduces the need for explicit type casting and makes the API of specialized classes much more intuitive and type-safe.
Task 290 Family Greetings: Dynamic Polymorphism V0.1 — This project demonstrates one of the most powerful features of Java: Dynamic Polymorphism. By declaring a variable of type Parent and assigning it an instance of Child, we show how the Java Virtual Machine (JVM) determines which method to execute at runtime. Even though the reference is generic (Parent), the actual behavior is specific to the object (Child). This "late binding" allows developers to write flexible code that can handle new subclasses without changing the existing logic.
Task 289 Zoo Simulator: Specialized Sounds V0.1 — In a dynamic simulation environment, different entities must react to the same trigger with unique behaviors. This project demonstrates Method Overriding using a Zoo Simulator example. While the base Animal class provides a generic makeSound() implementation, the Dog subclass redefines this behavior to produce a specific "Woof!". By using the @Override annotation, we ensure the compiler validates that the method signature exactly matches the one in the superclass, preventing subtle bugs during development.
Task 288 Drawing App: Method Overriding V0.1 — In sophisticated graphical systems, different objects must respond to the same command in unique ways. This project demonstrates Method Overriding, where the Circle subclass provides its own specific implementation of the draw() method originally defined in the Shape superclass. This is the foundation of Runtime Polymorphism: the ability of the Java Virtual Machine (JVM) to call the correct version of a method based on the actual object type, even if it's treated as its parent type.

The concept of inheritance, the extends syntax.

Task 287 Fruit Shop: Hierarchical Inheritance V0.1 — In cataloging systems, objects are grouped by shared characteristics. This project demonstrates Hierarchical Inheritance by establishing a base Fruit class. Both Apple and Banana subclasses inherit the fruitColor field and the printColor() method. This design allows for a unified way to handle different fruit types while maintaining the flexibility to add unique properties to specific fruits in the future without duplicating the core logic of the superclass.
Task 286 Fleet Management: Vehicle Inheritance V0.1 — In logistics and enterprise systems, objects often share common attributes and behaviors. This project demonstrates Inheritance by modeling a vehicle fleet. The Vehicle superclass defines the general state (vehicleModel) and behavior (start()), while the Car subclass inherits these properties. This architecture ensures that any new type of transport added to the system (e.g., Truck or Motorcycle) will automatically possess the ability to store a model name and start its engine without redundant code.
Task 285 Virtual Pets: Multiple Subclasses V0.1 — The power of Inheritance lies in its ability to create a scalable architecture. This project builds upon the virtual pet world by introducing a Dog class that inherits from the same Animal base class as the previous Cat implementation. This demonstrates Hierarchical Inheritance, where multiple subclasses share a single superclass. Both dogs and cats can sleep, but only dogs can bark, illustrating how specific behaviors are encapsulated within their respective subclasses while sharing common traits.
Task 284 Virtual Pets: Basic Inheritance V0.1 — In Object-Oriented Programming, Inheritance allows a new class to acquire the properties and behaviors of an existing class. This project demonstrates this core concept by creating a base class Animal and a specialized subclass Cat. The Cat class automatically receives the petName field and the eat() method from Animal, proving the power of code reuse. Additionally, the subclass introduces its own specific behavior, meow(), illustrating how hierarchies evolve from general to specific.

👉 Nested and inner classes.

Introduction to generics.

Task 283 Developer Utilities: Generic Methods V0.1 — In large-scale systems, utility classes often provide helper functions that must remain agnostic of the data types they process. This project demonstrates Generic Static Methods. By declaring the type parameter <T> before the return type of a method, we enable the printTwice function to accept any reference type. This approach eliminates the need for method overloading (writing separate versions for String, Integer, etc.), significantly reducing code duplication and adhering to the DRY (Don't Repeat Yourself) principle.
Task 282 Universal Pair: Multi-Field Generics V0.1 — In data processing, we often work with coupled information, such as coordinates, key-value pairs, or ranges. This project demonstrates a Generic Pair pattern using the DataPair<T> class. By utilizing the same type parameter T for both fields, the class enforces a strict relationship: both elements in the pair must belong to the same type. This further solidifies the concept of compile-time type safety and shows how generic types integrate with class constructors.
Task 281 Smart Container: Introduction to Generics V0.1 — Generic types are a powerful feature in Java that allows classes and methods to operate on objects of various types while providing compile-time type safety. This project evolves the previous "Universal Storage" into a SmartBox. By using the placeholder <T>, we define a container that locks into a specific type upon instantiation. This eliminates the need for manual type casting and prevents ClassCastException at runtime, which is a core principle in modern Java development and framework design (like Spring Data JPA).
Task 280 Universal Storage: The Object Root V0.1 — In the Java type system, every class implicitly inherits from java.lang.Object. This project demonstrates a Universal Container pattern. By using a field of type Object, the StorageBox class can store any data type (Strings, Integers, or custom objects). This highlights both the flexibility of the Java class hierarchy and the limitations of losing specific type information, which is a foundational concept before exploring Polymorphism and Generics.

Local classes: declaration inside methods.

Task 279 Text Analyzer: Local Class State V0.1 — In data processing applications, we often need temporary objects to hold intermediate results and provide specific formatting. This project demonstrates a Local Class (NameStatistics) with its own internal fields and multiple methods. By defining this class inside the generateNameReport method, we create a specialized reporting tool that encapsulates string transformation logic (uppercase conversion and length calculation) without exposing these temporary operations to the global scope of TextAnalyzer.
Task 278 Special Calculator: Method Parameter Access V0.1 — In high-precision or specialized computing modules, certain operations require temporary data structures that exist only during a specific calculation. This project demonstrates Local Classes accessing method-level parameters. By defining SumResultPrinter inside the calculateAndDisplaySum method, we create a specialized unit that can directly utilize the input arguments numA and numB. This pattern ensures that the logic for displaying the result is tightly coupled with the calculation itself and hidden from the rest of the application.
Task 277 Secret Keeper: Local Class Member Access V0.1 — In secure application development, strictly controlling access to sensitive data is paramount. This project demonstrates how a Local Class (TruthRevealer) can be used as a temporary agent to access and display a private field (hiddenSecret) of its outer class (SecretKeeper). By defining the class within the revealSecret method, we create a specialized tool that exists only for the duration of the method's execution, maintaining high levels of encapsulation while performing necessary data operations.
Task 276 Interactive Board: Local Class Scope V0.1 — In advanced software design, encapsulation is key. Sometimes a helper class is so specific to a single operation that it shouldn't exist anywhere else. This project demonstrates Local Classes in Java. By defining GreetingDisplay inside the showTemporaryMessage method, we ensure that the class remains private to that specific logic block. This prevents namespace pollution and guarantees that the temporary message logic cannot be misused by other parts of the system.

Anonymous classes.

Task 275 Secret Laboratory: Private Data Access V0.1 — In secure software architectures, it is often necessary to encapsulate sensitive data while providing a strictly controlled mechanism for its retrieval. This project illustrates how an Anonymous Inner Class can access private instance fields of its Outer Class. By implementing the Runnable interface inside the revealSecret method, we create a temporary access bridge to the classifiedSecret field, demonstrating the deep integration between nested implementations and their parent contexts.
Task 274 Production Line: Runnable Anonymous Implementation V0.1 — In industrial automation systems, certain tasks are executed once during a specific lifecycle event. This project demonstrates using an Anonymous Inner Class to implement the standard Java Runnable interface. By defining the logic directly within the startCountOperation method, we create a specialized, short-lived task. While this approach is functionally correct, it serves as a stepping stone toward understanding more modern functional programming patterns in Java.
Task 273 Universal Translator: Interface Implementation V0.1 — In intergalactic travel and software engineering, speed is often essential. This project demonstrates how to use an Anonymous Inner Class to implement an interface (Communicator) without declaring a formal named class. This technique allows for the immediate creation of functional objects that adhere to a specific contract, providing a "Hello World!" greeting for any life form encountered.
Task 272 Magical Farm: Anonymous Inner Classes V0.1 — In software development, we often encounter situations where we need to modify the behavior of a single object without creating a whole new class hierarchy. This project demonstrates Anonymous Inner Classes. We take a base class MagicalCreature and override its makeSound() method during instantiation. This approach is highly efficient for "one-off" logic, keeping the codebase clean and localized.

Static nested classes.

Task 271 Book Publishing: Builder Pattern V0.1 — Constructing complex objects with multiple optional or required fields often leads to "telescoping constructors," which are hard to maintain. This project demonstrates the Builder Pattern implemented via a Static Nested Class. The Builder allows for step-by-step configuration of a Book object using a fluent API (method chaining). The final object is instantiated only when the build() method is called, ensuring that the Book remains immutable once created.
Task 270 Artifact Chain: Linked Structures V0.1 — In low-level programming and algorithm design, linked structures are essential for dynamic data management. This project demonstrates how to build a simple Linked List using a Static Nested Class (Link). By making the Link class static and private, we encapsulate the internal mechanics of the chain, ensuring that the outside world only interacts with the ArtifactChain while the nodes themselves remain lightweight and independent of the parent object's instance state.
Task 269 Security Vault: Static Member Access V0.1 — In secure system design, certain global parameters must be hidden from the outside world but accessible to internal monitoring modules. This project demonstrates how a Static Nested Class (SecurityDisplayUnit) can access a private static field (securityLevel) of its outer class (Vault). This pattern allows for clean logical grouping of utility or display components that depend on the global state of the parent class without requiring an instance of that parent.
Task 268 Wizard Toolkit: Static Nested Classes V0.1 — In large systems, some components are logically related to a parent entity but do not require its state to function. This project demonstrates Static Nested Classes in Java. By declaring BasicCharm as static within Spellbook, we decouple the two. This allows the instantiation of BasicCharm without creating a Spellbook object, saving memory and simplifying the architecture when instance-specific data is not required.

Inner classes (non-static inner).

Task 267 Smart Home: Hierarchical Data Access V0.1 — In nested object structures, an inner class often needs to reference the state of its parent instance. This project demonstrates the use of a Non-static Inner Class (Room) within an outer class (House). It highlights the Outer.this syntax, which allows the inner class to explicitly access the outer class's private fields. This is essential for distinguishing between local instance data and the broader context provided by the parent object.
Task 266 Magic Library: Inner Class Composition V0.1 — In software modeling, some objects are logically and physically inseparable from their parent container. This project demonstrates Inner Class Composition using a Library and its Scrolls. The Scroll class is nested within Library to show that a scroll's existence is defined by the library it belongs to. This structure allows the inner class to maintain its own state (scrollTitle) while remaining part of the outer class's domain.
Task 265 AI Assistant: Inner Class Data Access V0.1 — In advanced Java applications, inner classes provide a unique way to organize code while maintaining strict encapsulation. This project demonstrates how a non-static inner class can directly access the private fields of its outer class. The Greeting class, nested within Person, retrieves the private userName variable without requiring public getters. This ensures that sensitive user data remains hidden from the rest of the application while remaining fully functional for internal components.
Task 264 Warehouse Automation: Inner Classes V0.1 — In object-oriented design, some entities are so closely related that one cannot exist without the other. This project demonstrates the use of Non-static Inner Classes in Java. By nesting the Label class inside the Box class, we create a strong logical bond. An instance of Label is always tied to a specific instance of Box, reflecting real-world scenarios where a label is a physical part of a specific package.

👉 Encapsulation.

Initialization blocks.

Task 263 User Profile: Shared Instance Initialization V0.1 — In systems with multiple ways to create an object (overloaded constructors), maintaining consistent initial state can be challenging. This project demonstrates how a non-static initialization block serves as a common entry point for all constructors. Regardless of whether a user chooses "Fast Registration" or "Full Profile," the system automatically assigns a default identifier before the specific constructor logic executes. This pattern promotes the "Don't Repeat Yourself" (DRY) principle and ensures mandatory setup tasks are never skipped.
Task 262 System Component: Full Initialization Audit V0.1 — This project demonstrates the Execution Hierarchy within a Java class. It tracks the exact sequence of static initialization blocks (class-level) and instance initialization blocks (object-level) relative to the constructor. Understanding this order is vital for managing global state and ensuring that object-specific data is correctly prepared before the constructor finishes execution.
Task 261 Pet Shelter: Instance Initialization Lifecycle V0.1 — When creating objects in Java, there is a specific sequence of events. This project demonstrates the Non-Static Initialization Block. Unlike static blocks (which run once per class), non-static blocks run every time a new instance is created. Crucially, they execute after the parent constructor (if any) but before the current class's constructor logic. This is useful for shared initialization logic that must run regardless of which constructor is called.
Task 260 Module Initialization: Static Lifecycle V0.1 — In large-scale applications, some operations must occur exactly once when a component is first introduced to the system. This project explores the Static Initialization Block. Unlike constructors, which run every time an object is created, the static block runs only once — when the Java Virtual Machine (JVM) loads the class into memory. This mechanism ensures that the global state, such as moduleStatusMessage, is prepared before any instance-level logic begins.

Initialization of static and final fields.

Task 259 Global Constants: Static Immutable Storage V0.1 — In application development, certain values like mathematical PI or the number of days in a year remain constant throughout the entire execution. This project demonstrates the creation of a Utility Class for global constants. By combining public, static, and final modifiers, we make these values globally accessible, shared across the JVM, and protected from any modification.
Task 258 Application Configuration: Static Initialization V0.1 — Global constants often depend on the environment where the application is running. This project demonstrates how to use a static initialization block to calculate the value of a public static final field. By querying the system environment variable APP_LANG, the application dynamically chooses its default language at startup. This approach ensures that configuration remains immutable once set, while still being flexible enough to adapt to different system environments.
Task 257 Student Identity Card: Data Immutability V0.1 — In security-sensitive systems, certain information must remain constant throughout the object's lifecycle. This project demonstrates Immutability using the final keyword in Java. By declaring the studentName field as final, we ensure that once the value is assigned in the constructor, it cannot be modified by any other part of the program. This pattern provides a high level of thread safety and data integrity.
Task 256 Application Metrics: Static State V0.1 — In software architecture, some data belongs to the system as a whole rather than individual users or objects. This project introduces the static keyword. By declaring activeUserCount as a static field, we ensure that it is shared across the entire application. This variable exists independently of any object instances, allowing us to access and manage global metrics directly through the class name.

Getters and Setters: Syntax and Best Practices.

Task 255 School Records: Data Integrity Guard V0.1 — Ensuring that a system contains valid data is a core responsibility of an object. This project demonstrates Defensive Programming through encapsulation. By making the currentAge field private and providing a "Smart Setter", we prevent the student's age from ever becoming negative. The object acts as a gatekeeper, rejecting invalid inputs and providing feedback while maintaining its internal consistency.
Task 254 Smart Home: Boolean State Management V0.1 — In IoT and Smart Home systems, binary states (on/off, true/false) are fundamental. This project demonstrates Boolean Encapsulation. A key takeaway here is the Java naming convention: while numeric types use get, boolean fields use the is prefix for their getters. By encapsulating the isCurrentlyOn field, we provide a clean interface for the SmartLamp object, allowing the system to toggle and query its status securely.
Task 253 Student Records: Dynamic Age Management V0.1 — In educational management systems, student data like age must be both initialized and periodically updated. This project demonstrates the complete Encapsulation Cycle. By using a private field studentAge, we prevent direct external tampering. Access is strictly mediated through a Parameterized Constructor for birth-state, a Getter for reading, and a Setter for updates. This ensures the object remains the "single source of truth" for its own data.
Task 252 Warehouse System: State Mutation V0.1 — In dynamic inventory systems, data must be updatable. This project demonstrates State Mutation using the Setter Pattern. While the productName field remains private to prevent unauthorized external access, we provide a public setProductName() method. This controlled entry point allows the application to modify the object's state safely, maintaining a clear interface between the object's internal data and the external business logic.

Access modifiers.

Task 251 Digital Library Manager: Access Control Matrix V0.1 — Security and modularity in Java are managed through access modifiers. This project simulates a library management system where different operations require different clearance levels. By implementing four methods with distinct modifiers, we visualize the accessibility hierarchy. The project demonstrates that while most operations are available to classes within the same package, strictly private tasks remain locked within the managing class itself.
Task 250 Module Internal Collaboration: Package-Private Access V0.1 — In modular programming, certain functionalities should be shared among related classes but hidden from the rest of the application. This project explores Package-Private (Default) Access. By omitting access modifiers, we allow ModuleMain to interact with ModuleHelper's internal methods because they reside in the same package (com.yurii.pavlenko). This level of encapsulation creates a "trusted zone" where classes can collaborate without exposing their internal machinery to external packages.
Task 249 Magic Calculator: Method Encapsulation V0.1 — Encapsulation applies to actions just as much as it does to data. This project explores Private Methods. While the addNumbers method is public and serves as the calculator's interface, the displayInternalResult method is a "hidden" helper. By making it private, we prevent other parts of the program from triggering internal logging or display mechanisms directly, ensuring that the class maintains strict control over its internal processes.
Task 248 Digital Business Cards: Basic Encapsulation V0.1 — A business card is a record of identity that shouldn't be altered by third parties. This project models this concept using Encapsulation. By declaring the userName field as private and only providing a public getter, we create a secure object. The only way to set the name is at the moment of the object's creation via a constructor, making the card "read-only" for the rest of its lifecycle in the program.

Principles of encapsulation and why it is needed.

Task 247 Warehouse Inventory: Immutable Identity V0.1 — In data-sensitive systems, some attributes must remain constant throughout an object's life. This project demonstrates the creation of Read-Only Objects. By combining private fields with a parameterized constructor and providing only Getters, we create a "locked" entity. Once a Product is instantiated, its productID and productName are set forever, mimicking a physical non-erasable tag on a warehouse item.
Task 246 Exclusive Club: The Smart Setter V0.1 — Raw data access is dangerous. This project demonstrates the ultimate goal of Encapsulation: protecting the object's state from invalid data. By implementing Setters with Validation, we ensure that a Person can never have a negative age. The object now possesses "self-awareness" and "self-protection" logic, rejecting incorrect inputs and maintaining data integrity throughout its lifecycle.
Task 245 Exclusive Club: The Getter Pattern V0.1 — Encapsulation is not just about hiding data, but about managing access to it. In this project, we implement Getters—special methods that act as safe bridges to our private fields. We also introduce a Parameterized Constructor, which allows us to set the initial state of the Person object at the moment of birth. This design pattern ensures that once a club member is registered, their data is protected from accidental external modification while remaining accessible for reading.
Task 244 Exclusive Club: The Walls of Encapsulation V0.1 — Data integrity is the foundation of secure software. This project introduces the private access modifier, the first step towards Encapsulation. By marking the memberName and memberAge fields as private, we hide the internal state of the Person object from the outside world. This exercise demonstrates that even if an object exists, its "private" parts are inaccessible to other classes, ensuring that the object has full control over its data.

👉 Classes and constructors.

Object Initialization: Initialization Order.

Task 243 Admission Process: Grade Tracking V0.1 — The object lifecycle in Java is not an instantaneous event but a sequence of steps. This project explores Sequential Instance Initialization. By using multiple initialization blocks, we simulate a multi-stage review process for a student's grade. We observe how Java executes these blocks in the order they appear in the source code, allowing us to track the transformation of state from the initial field assignment to the final object preparation.
Task 242 Factory Automation: Initialization Sensors V0.1 — In advanced manufacturing, sensors must trigger as soon as a process begins. This project demonstrates Instance Initialization Blocks in Java. These blocks run every time an instance of the class is created, execution-wise placed between field initialization and the constructor. We use this mechanism to simulate a factory notification system that alerts the operator the moment a new Car object starts its "assembly" in memory.
Task 241 Publishing House: Explicit Initialization V0.1 — In professional software, relying on system defaults like null or 0 can lead to errors. This project demonstrates Explicit Field Initialization. By assigning values directly at the point of declaration, we ensure that every Book object starts its lifecycle with valid, domain-specific data ("Untitled" and 100 pages). This provides a fallback mechanism that guarantees object consistency even when a default constructor is used.
Task 240 Virtual Zoo: Default Characteristics V0.1 — What happens when an object is created without specific instructions? This project explores Default Field Initialization in Java. When we instantiate the Animal class without a constructor or manual assignment, Java automatically assigns "safe" values: 0 for numeric primitives (int) and null for object references (String). Understanding these defaults is crucial for avoiding NullPointerException and ensuring predictable program behavior.

Constructor overloading.

Task 239 Student Admission: Ultimate Flexibility V0.1 — An educational system must be resilient to incomplete data. This project implements a high-flexibility Student model using 4-level Constructor Chaining. Whether a student provides full dossiers or just a name, the system uses the this() keyword to delegate initialization logic up the chain. This architectural pattern eliminates code duplication and ensures that default values ("Unknown", 0) are applied consistently across all entry points.
Task 238 Car Factory: Smart Assembly Line V0.1 — In industrial software design, DRY (Don't Repeat Yourself) is a critical principle. This project demonstrates Constructor Chaining in Java. By using the this() keyword, we link multiple constructors together. The "simple" constructors delegate their work to more "complex" ones, passing default values along the chain. This ensures that the core initialization logic resides in a single location, making the code robust and easy to maintain.
Task 237 Online Service: User Profile Initialization V0.1 — In modern web services, user onboarding must be seamless. This project models a User entity with flexible registration paths. By using Constructor Overloading, we handle two common scenarios: anonymous "quick" registration and basic "named" registration. The system ensures that even without user input, every profile is initialized with safe default values ("Unknown" and age 0), maintaining data consistency across the platform.
Task 236 Publishing House: Flexible Book Registration V0.1 — In the publishing industry, data arrives in stages. This project models a Book entity that can be registered even if its physical properties (like page count) are not yet finalized. By using Constructor Overloading, the system provides two entry points for data: one for early-stage titles and another for completed manuscripts. This approach ensures that every book in the database is properly initialized, maintaining a high level of data consistency.

Creating objects with object creation operator - new.

Task 235 Digital Library: Flexible Book Records V0.1 — A robust library system must handle books even when their full details are not yet known. This project demonstrates Constructor Overloading in Java. We provide two ways to instantiate a Book object: one that uses default placeholder values ("Без названия", 0) and another that accepts specific data upon creation. This ensures every book object in our system is consistently initialized, avoiding null pointers or uninitialized states.
Task 234 Virtual Showroom: Independent Objects V0.1 — The power of OOP lies in the ability to create multiple instances from a single blueprint. This project demonstrates object independence. We define a Car class and then create two separate objects: a 2020 Toyota and a 2010 BMW. Each object maintains its own memory space, proving that while they share the same structure, their data remains distinct and isolated.
Task 233 Digital Shelter: Instant Registration V0.1 — In a professional system, objects should not exist in an invalid state. This project models a digital dog shelter where every Dog is registered using a constructor. This ensures that the dog's name and age are assigned exactly at the moment of "arrival" (instantiation), preventing the creation of empty or anonymous records.
Task 232 Virtual Pets: The Birth of Barsik V0.1 — The transition from a class (blueprint) to an object (instance) is the core of Java programming. This project demonstrates the "lifecycle" of a virtual pet. We declare a Cat template, allocate memory using the new keyword, and then manually define its unique characteristics: "Barsik", aged 3. This process, known as object instantiation, creates a concrete entity in the JVM's Heap memory.

Class structure: fields, methods, constructors.

Task 231 Digital Bank: Flexible Account Management V0.1 — Modern banking systems require flexibility during customer onboarding. This project demonstrates Constructor Overloading, allowing a BankAccount to be initialized in multiple ways: with a starting balance or as an empty account. Additionally, it implements dynamic state updates through a parameterized deposit method, ensuring that the account balance accurately reflects financial transactions.
Task 230 Game Mechanics: Digital Counter V0.1 — In gaming and interactive systems, tracking state changes (like score, clicks, or coins) is a fundamental task. This project implements a Counter object that maintains an internal state which changes over time. By calling the increment() method, the application modifies the object's data, demonstrating how objects encapsulate both their current status and the logic to transform that status.
Task 229 Online School: Mandatory Initialization V0.1 — Manually setting fields after object creation is error-prone and tedious. This project introduces Constructors—special methods that run at the moment of "birth" (instantiation). By defining a parameterized constructor in the Student class, we guarantee that no student can exist in the system without a name and a grade, enforcing data integrity from the very start.
Task 228 Virtual Showroom: Car Inventory V0.1 — In a professional automotive system, objects must be self-describing. This project models a Car entity that encapsulates both its specifications (brand and production year) and its presentation logic. By moving the display logic into the Car class itself, we ensure that every vehicle "knows" how to present its details to a potential customer, maintaining high cohesion within the object.

The concept of class and object.

Task 227 University Admin: Student Registration V0.1 — In a multi-user system, a single class must support many independent objects. This project demonstrates how to use the Student blueprint to register two distinct individuals. By creating separate instances for "Hana" and "Greg," we illustrate how Java manages unique data for each object in the heap memory, ensuring that updating one student's information does not affect the other.
Task 226 Digital Library: Book Template V0.1 — In this project, we move beyond simple object creation to defining object behavior. We model a Book as a digital entity that not only stores data (title and pages) but also possesses the ability to describe itself through a dedicated method. This encapsulates both the state and the functionality within a single class structure.
Task 225 Virtual Pets: Materializing a Cat V0.1 — An object-oriented program consists of classes and objects. While a class is just a template, an object is a specific "living" instance of that template. This project demonstrates how to declare a Cat class and then "summon" it into existence within the main method. This process allocates memory for the cat, allowing us to interact with it via the reference variable myCat.
Task 224 Virtual Pets: Dog Blueprint V0.1 — Object-Oriented Programming (OOP) begins with defining structures. This project marks the first step in creating a virtual pet system by declaring a Dog class. This class acts as a template or "blueprint" that defines what a dog is in our digital world. While currently empty, it serves as the foundational container for future attributes (like name or breed) and behaviors (like barking or running).

👉 Date, time, time zones.

Calculations and comparison of dates. Duration, Period.

Task 223 Real Estate: Building Age Calculator V0.1 — Calculating the age of an asset is a common requirement in commercial applications. This project demonstrates how to use the java.time.Period class to determine the exact duration between two dates. Unlike simple day counting, the Period class provides a multi-unit breakdown, allowing the system to report age in human-readable terms: years, months, and days.
Task 222 Project Manager: Deadline Countdown V0.1 — In project management, tracking the remaining time until a milestone is critical for resource allocation. This project demonstrates how to calculate the distance between two LocalDate objects. By using the ChronoUnit utility, the application determines exactly how many days are left from the current system date to a predefined project deadline (May 15, 2027).
Task 221 Time Machine: Date Comparison V0.1 — In timeline-sensitive applications, it is crucial to determine if a specific event has already occurred or is still in the future. This project simulates a simple time machine check. It compares a historical or future milestone (January 1, 2025) against the current system date to provide a status update on the timeline.
Task 220 Holiday Countdown: Date Arithmetic V0.1 — Planning for future events requires precise calendar calculations. This project demonstrates how to project a future date starting from the current system time. By utilizing the built-in arithmetic methods of the LocalDate class, the application calculates exactly which day will occur 10 days from today, serving as the starting point for a holiday countdown.

Date Formatting and Parsing: DateTimeFormatter.

Task 219 Order Management: Custom Timestamp Parsing V0.1 — In real-world applications, timestamps are frequently received in non-standard formats. This project demonstrates how to parse a complex string containing both date and time ("01.06.2025 14:30") into a functional LocalDateTime object. By defining a specific pattern that matches the input string, the application can accurately extract chronological data for order tracking and processing.
Task 218 Organizer App: Localized Date Display V0.1 — User experience is highly dependent on how data is presented. This project demonstrates how to move away from technical ISO standards toward user-friendly date formats. By using a custom pattern string, the application transforms a LocalDate object into a human-readable string that follows common European and regional date conventions (Day.Month.Year).
Task 217 Data Ingestion: ISO Date Parsing V0.1 — In many real-world scenarios, dates are received as plain text strings. This project demonstrates how to "rehydrate" such strings into rich LocalDate objects. By using the parse() method combined with the ISO_LOCAL_DATE formatter, we transform a static piece of text into an object capable of date arithmetic, comparison, and validation.
Task 216 Daily Report System: ISO Formatting V0.1 — Uniformity in data presentation is critical for enterprise reporting systems. This project demonstrates how to transform a LocalDate object into a standardized string format using DateTimeFormatter. By utilizing the pre-defined ISO_LOCAL_DATE constant, the application ensures that every report generated adheres to the international ISO-8601 standard (YYYY-MM-DD).

ZonedDateTime, Instant, working with time zones.

Task 215 Universal Chronicle: Absolute Time Tracking V0.1 — This project demonstrates the workflow of a professional global logging system. It focuses on the transition between zoned time and absolute time (Instant). By converting a specific event in Kyiv to a universal instant and then back to Tokyo time, the application showcases how a single moment remains synchronized regardless of regional timezone rules.
Task 214 Global Teleportation: Timezone Synchronization V0.1 — This project simulates a high-precision synchronization task for a global teleportation system. It demonstrates how to take a specific event scheduled in one timezone (Minsk) and calculate exactly what time it will be in another part of the world (New York) at that very same moment. This ensures all participants, regardless of their location, are synchronized to the same absolute instant.
Task 213 International Conference: Zoned Start Time V0.1 — When organizing international events, local time is insufficient for global coordination. This project demonstrates how to anchor a floating LocalDateTime to a specific geographical region. By applying the "Europe/Minsk" timezone to a scheduled conference start, we create a precise ZonedDateTime that can be accurately translated across all global regions.
Task 212 Global Command Center: Timezone Display V0.1 — This project simulates a global time monitoring system. It utilizes the ZonedDateTime class to capture the current instant in three specific geographical regions: Minsk, New York, and Tokyo. This ensures that operators in the Command Center are aware of the precise local time in strategic locations across different continents.

LocalDate, LocalTime, LocalDateTime.

Task 211 Secret Operation: Time Adjustment V0.1 — In mission planning, precision is paramount. This project demonstrates how to adjust a pre-defined point in time using the Java Time API. Starting with an initial briefing timestamp, the application applies sequential modifications—adding hours and subtracting minutes—to calculate the final operational start time.
Task 210 Secretary's Scheduler: Meeting Comparison V0.1 — This project implements a fundamental scheduling logic for time-sensitive applications. It compares two specific time objects—a morning meeting and an afternoon presentation—to verify their chronological sequence. By utilizing the modern Java Time API, the application ensures that the earlier event is correctly identified and displayed to the user.
Task 209 Astrology App: Birth Day Finder V0.1 — This project focuses on extracting chronological properties from a specific date. By initializing a LocalDate object for a given birth date (March 25, 1969), the application retrieves the corresponding day of the week. This is a fundamental feature for applications providing astrological insights, historical context, or scheduling.
Task 208 Clockmaster: Time Components V0.1 — This project demonstrates how to deconstruct a time object into its fundamental components. Using the LocalTime class, the application captures the current system time and extracts specific integer values for hours, minutes, and seconds. This granular control is essential for building custom clocks, timers, and scheduling logic.

Overview of the java.time API, differences from older APIs.

Task 207 Historical Event Logger V0.1 — This project demonstrates how to initialize a specific point in time using the Java Time API. Unlike retrieving the current system time, this task focus on creating an immutable LocalDateTime instance for a pre-defined historical moment (February 24, 2022, at 04:00 AM). This is essential for applications managing logs, archives, or schedules.
Task 206 Futuristic Event Planner: Tomorrow V0.1 — This project focuses on forward-looking date manipulation within the Java Time API. It demonstrates how to accurately calculate the next calendar day based on the current system time. This functionality is a fundamental building block for scheduling systems, reminders, and future-oriented applications.
Task 205 Historical Date Tracker: Yesterday V0.1 — This project focuses on date manipulation within the Java Time API. It demonstrates how to perform basic date arithmetic by moving the current system date one step into the past. This functionality is a core requirement for applications dealing with historical records, logs, or daily reports.
Task 204 Digital Calendar: Date Tracker V0.1 — This project marks the beginning of a digital calendar module. Its primary function is to retrieve the current date from the local system and display it to the user. This is achieved using the LocalDate class from the modern java.time package, which provides a clean and thread-safe way to handle date information.

👉 Bonus level.

Learning to work with APIs and monitoring the ISS.

Task 203 ISS Tracker: Manual JSON Parser V0.1 — This project focuses on extracting specific data from a JSON response without using third-party parsing libraries. By sending a request to the ISS Current Location API, the application retrieves a raw JSON string and manually identifies the positions of coordinates using String methods. This exercise strengthens foundational knowledge of text processing in Java.
Task 202 Cat Fact Generator V0.1 — This project implements a simple client for the "CatFact Ninja" API. It demonstrates how to fetch random, dynamic data from a public REST API and display the raw JSON response. Each execution provides a new interesting fact about cats, making it a perfect starting point for entertainment-based applications.
Task 201 ISS API Health Checker V0.1 — In space monitoring systems, verifying API availability is a critical task. This project implements a lightweight "ping" logic to check the International Space Station (ISS) location service. By using an optimized response handler, we extract only the HTTP status code without consuming bandwidth for the response body.
Task 200 Weather API Integrator V0.1 — This project demonstrates how to interact with a real-world REST API to fetch weather data. It focuses on sending a GET request to the Open-Meteo service and retrieving the response as a raw JSON string. This is a foundational step for any application that consumes web services.

Downloading images from the Internet.

Task 199 Image Metadata Downloader V0.1 — This project focuses on retrieving and processing HTTP response headers. It demonstrates how to use the java.net.http.HttpClient to extract metadata such as Content-Type and Content-Length before saving the actual binary content. This is essential for building smart downloaders that need to validate file types and sizes.
Task 198 Smart Image Downloader V0.1 — This project demonstrates a robust approach to web resource retrieval using the java.net.http.HttpClient API. Unlike simpler methods, this implementation includes error handling by validating the HTTP response status code before attempting to save data to the local disk.
Task 197 Streamlined Image Downloader V0.1 — This project demonstrates the most modern and efficient way to transfer data between streams in Java. By using the transferTo() method, we can pipe data from a network InputStream directly into a file OutputStream without manual buffer management or intermediate byte arrays.
Task 196 Image Downloader Module V0.1 — This project demonstrates how to download binary content (an image) from a remote web server using Java's networking capabilities. It combines the java.net.URL class for establishing a connection with the java.nio.file.Files utility for streamlined file saving.

Getting to know files and images.

Task 195 File Backup Utility V0.2 — This project demonstrates the process of creating a file backup. It involves reading the raw byte content of an existing binary file and writing that exact data into a new destination file. This ensures a 1:1 replica of the original data using modern Java 11+ syntax.
Task 195 File Backup Utility V0.1 — This project demonstrates the process of creating a file backup. It involves reading the raw byte content of an existing binary file and writing that exact data into a new destination file. This ensures a 1:1 replica of the original data.
Task 194 Binary Message Encryptor V0.1 — This project demonstrates how to work with binary data in Java. Instead of writing plain text, we manipulate raw bytes (ASCII values) and store them in a .bin file. This is a fundamental step in understanding encryption, image processing, and network protocols.
Task 193 Digital Diary Reader V0.1 — This project focuses on the retrieval aspect of file management. It demonstrates how to use the java.nio.file package to read the contents of an existing text file. This is a critical skill for any application that needs to load settings, user data, or saved logs.
Task 192 Digital Diary Note V0.1 — This project demonstrates the modern way to interact with the file system in Java using the java.nio.file package. The goal is to create a text file named note.txt and write a specific inspirational string to it. This approach is more robust and efficient than the legacy java.io.File methods.

"Your dictionary" — HashMap<K,V> and its methods.

Task 191 Word Frequency Analyst V0.1 — This project focuses on basic text analysis using the HashMap collection. It demonstrates how to parse a string into individual words and count their occurrences. This algorithm is the foundation for search engines and data processing tools where frequency analysis is required.
Task 190 User Registry Manager V0.1 — This project demonstrates how to manage a simple user database using HashMap. It specifically focuses on the remove() method, which is essential for deleting data based on a unique key. The program confirms successful deletion by attempting to retrieve the removed record and verifying it returns null.
Task 189 Digital Gradebook V0.1 — This project simulates a teacher's digital gradebook. It demonstrates how to use the containsKey() method in a HashMap to verify if a specific entry exists before attempting to retrieve and process its value. This approach prevents potential null pointer issues and ensures data integrity.
Task 188 Pocket Travel Translator V0.1 — This project introduces the HashMap collection in Java. Unlike lists that use numeric indexes, a HashMap allows storing data pairs where a unique "key" is mapped to a specific "value". This simulation demonstrates the basic operations of a travel phrasebook: storing a translation and retrieving it using the original word.

"Infinite array" - ArrayList and its methods.

Task 187 Interactive Task Assistant V0.1 — This project simulates an interactive assistant that records user tasks until an empty input is received. It demonstrates how to dynamically populate an ArrayList using the Scanner class and how to iterate through a collection in reverse order (LIFO - Last In, First Out logic).
Task 186 Exclusive Club Guest List V0.1 — This project demonstrates how to check for the existence of an element within a dynamic list. Using a guest list scenario, it showcases the efficiency of the contains() method in ArrayList, which returns a boolean value based on whether the specified object is present in the collection.
Task 185 Chef's Ingredient Manager V0.1 — This project simulates a chef managing a dynamic list of ingredients. It demonstrates essential ArrayList operations such as replacing an existing element, removing elements by index, and iterating through the collection to display its contents.
Task 184 Digital Artifact Archive V0.1 — This project introduces the use of dynamic lists in Java. Unlike standard arrays, dynamic lists can grow in size as needed. In this simulation, we manage a digital archive where new artifact identifiers are stored and retrieved using the ArrayList collection.

👉 Exceptions.

Stack Trace.

Task 183 Deep Call Trace Debugger V0.1 — This project simulates a multi-layered system architecture where requests pass through several processing stages. By intentionally triggering an ArrayIndexOutOfBoundsException at the deepest level of the call stack, we practice tracing the program's execution flow from the entry point (main) to the specific failure point.
Task 182 Report System Detective V0.1 — This project demonstrates how to trace an error through multiple layers of method calls. By creating a chain of methods (main -> calculateReportData -> processRawNumbers), we simulate a complex system where a low-level mathematical error causes the entire application to crash. The focus is on reading the Stack Trace to understand the path the program took before the failure.
Task 181 Inventory Debugger V0.1 — This project focuses on identifying and analyzing memory-related errors in Java. By attempting to access a non-existent array index (index 5 in a 3-slot array), we trigger an ArrayIndexOutOfBoundsException. The goal is to study the Stack Trace to find the specific line number where the boundary violation occurred.
Task 180 Culinary Proportion Calculator V0.1 — This project is designed to help developers understand the Java Stack Trace. By intentionally causing a division by zero error, we simulate a critical bug in a culinary calculation module. The goal is to identify the exception type and the exact line of code responsible for the crash by analyzing the console output.

Throws exceptions.

Task 179 Gold Amount Converter V0.1 — This project demonstrates the propagation and handling of NumberFormatException. It simulates an RPG game where a player's string input is converted into a numeric gold amount. The utility method delegates the error handling to the caller, ensuring that invalid text input does not crash the game.
Task 178 Data Extraction Utility V0.1 — This project demonstrates the propagation of multiple related exceptions using the throws keyword. It simulates a data pipeline component that reads the first line of a file, delegating both FileNotFoundException and IOException handling to the calling environment.
Task 177 System Log Analyzer V0.1 — This project demonstrates the handling of IOException during file operations in Java. It simulates a log analysis utility that delegates the responsibility of handling input/output errors to the caller using the throws keyword.
Task 176 Secret Document Access V0.1 — This project demonstrates the use of the throws keyword in Java to delegate exception handling. Instead of catching a FileNotFoundException locally, the method declares it in its signature, passing the responsibility of error management to the calling method.

The finally `block` and the `throw` statement: Termination and exception throwing.

Task 175 User Registration Validator V0.1 — This project demonstrates the combined use of manual exception throwing and the finally block. It simulates a user registration system where the username must not be empty. The finally block is used to ensure that the validation status is reported regardless of whether the registration was successful or failed due to an exception.
Task 174 Critical Resource Manager V0.1 — This project illustrates the behavior of the finally block when an exception occurs but is not caught by a catch block. It proves that the Java Virtual Machine guarantees the execution of the finally block before the program terminates due to a fatal error, which is essential for resource cleanup.
Task 173 Game Score Validator V0.1 — This project demonstrates how to manually throw exceptions in Java using the throw keyword. It ensures that game scores remain positive by triggering an IllegalArgumentException when an invalid value is processed.
Task 172 Cleaning Robot Manager V0.1 — This project demonstrates the usage of the finally block in Java. In software development, certain actions (like closing a database connection or sending a final status report) must occur regardless of whether an error occurred. This simulation uses a cleaning robot to show how the finally block guarantees execution of completion messages.

Try-catch syntax.

Task 171 Mission Control System V0.1 — This project demonstrates the resilience of a Java application when facing critical runtime errors. In a mission-critical system, an error like division by zero should not halt the entire process. By using a try-catch block, we ensure that the exception is handled gracefully, allowing the program to proceed to its final logical conclusion.
Task 170 Team Score Calculator V0.1 — This project focuses on retrieving detailed exception information in Java. When a system error results in an empty player list (numberOfPlayers = 0), dividing the total score by zero triggers an ArithmeticException. Instead of a generic message, this task demonstrates how to use the e.getMessage() method to obtain the exact technical reason for the failure as defined by the Java Virtual Machine.
Task 169 RPG Inventory System V0.1 — This project demonstrates the ArrayIndexOutOfBoundsException in Java. It simulates an RPG inventory where a player attempts to access an item slot that does not exist. This helps in understanding how to handle errors when working with fixed-size data structures like arrays.
Task 168 Smart Robot Explorer V0.1 — This project demonstrates how to handle one of the most common runtime exception in Java: the ArithmeticException. It occurs when the application attempts to divide an integer by zero. This simulation helps understand how try-catch blocks ensure the reliability of software in unpredictable environments, such as a robot with failing sensors.

Introduction to Exception Handling.

Task 167 Secret Agent Database V0.1 — This project demonstrates one of the most common runtime errors in Java: the NullPointerException. It occurs when the application attempts to use an object reference that has not been initialized (contains null). This simulation helps understand why null-checks are essential in production code.
Task 166 Registration Input Validator V0.1 — This project simulates a common data-entry error where a user provides non-numeric text in a field expected to contain an integer (e.g., age). It focuses on Java's response to invalid format conversion through the Integer.parseInt() method.
Task 165 Gem Collector Inventory V0.1 — This project explores how Java manages memory and array boundaries. In many programming languages, accessing an index outside an array's range might return garbage data, but Java's strict type safety and runtime checks prevent this by throwing a specific exception.
Task 164 Galactic Energy Divider V0.1 — This project explores Java's behavior when encountering illegal mathematical operations. Specifically, it demonstrates what happens when an integer is divided by zero. This is a crucial lesson in exception handling and defensive programming for any Java developer.

👉 Constants, enum, switch.

Advanced Switch Expressions.

Task 163 Student Grading System V0.1 — This project showcases the advanced capabilities of Switch Expressions introduced in Java 14. Specifically, it demonstrates how to group multiple constants within a single case label using a comma-separated list. This approach significantly simplifies the logic when several inputs should result in the same output.
Task 162 Modern Task Planner V0.1 — This project demonstrates the transition from legacy switch statements to modern Switch Expressions. By using the arrow syntax, we reduce boilerplate code and ensure that each case returns a value directly to a variable, which is a key pattern in functional-style Java programming.
Task 161 Drone Control System V0.1 — This project demonstrates the use of Switch Expressions with String objects. It simulates a drone's command processing unit where incoming text commands are mapped to specific operational statuses. The modern arrow (->) syntax is used to ensure code conciseness and safety.
Task 160 HTTP Response Handler V0.1 — This project demonstrates the use of the modern Switch Expression (introduced in Java 14). Unlike the traditional switch statement, the expression form is more concise, eliminates the risk of "fall-through" bugs by removing the need for break, and allows for direct variable assignment.

Enumeration: enum.

Task 159 Celestial Navigation System V0.1 — This project simulates a spacecraft navigation module. It demonstrates the use of built-in Java enum methods to handle constant data. We explore how to retrieve the string name of a constant, its position (index) in the declaration list, and how to dynamically convert a string back into an enum constant.
Task 158 Weekday Iterator V0.1 — This project demonstrates how to retrieve and iterate through all constants defined in a Java enum. By using the built-in values() method, we can programmatically access the entire set of days in a week, which is a fundamental requirement for building task schedulers and calendar applications.
Task 157 Seasonal Message Generator V0.1 — This project demonstrates the synergy between Java enum types and the switch statement. By using an enum as the switch selector, we create a highly readable and type-safe branching logic that delivers personalized messages based on the current season.
Task 156 Traffic Signal State Model V0.1 — This project demonstrates the use of Java enum to model a real-world system: a traffic light. Enums provide a type-safe way to represent a fixed set of constants, making the code more readable and preventing invalid values from being assigned to state variables.

Classic Switch: Syntax and Examples.

Task 155 Smartwatch Calculator V0.1 — This project implements a lightweight calculator designed for a smartwatch interface. It processes two integer inputs and a mathematical operator, demonstrating how to use the switch statement with the char data type to branch logic based on symbols.
Task 154 Seasonal Activity Planner V0.1 — This project demonstrates how to group multiple case statements in a switch block to execute the same logic for different inputs. The application identifies the season based on a numeric month input (1-12), showcasing efficient multi-condition handling.
Task 153 Robot Control Interface V0.1 — This project demonstrates the application of the switch statement for string comparisons. It simulates a basic command-line interface for a robot, where specific text inputs trigger corresponding actions, showcasing how to handle multiple logical branches efficiently.
Task 152 Office Day Navigator V0.1 — This project demonstrates the use of the switch statement in Java. It serves as an efficient alternative to multiple if-else-if conditions when dealing with a single variable that can take several discrete values. The application maps numeric input to the corresponding day of the week.

Type inference and constants in Java.

Task 151 Constant Protection Mechanism V0.1 — This project demonstrates the strict enforcement of the final modifier in Java. By attempting to reassign a value to a constant, we observe how the Java compiler prevents modifications, ensuring that critical parameters like server capacity remain fixed.
Task 150 Global Constants and Static Access V0.1 — This project demonstrates how to create a globally accessible constant in Java. By combining public, static, and final modifiers, we create a value that belongs to the class itself, remains immutable, and can be accessed from any other part of the application without instantiating the class.
Task 149 Constants in Java V0.1 — This project demonstrates how to define immutable values in Java using the final modifier. By declaring a variable as final, we ensure that its value remains constant throughout the execution of the program, which is critical for system-wide parameters like calendar rules.
Task 148 Local Variable Type Inference V0.1 — This project explores the var keyword introduced in Java 10. While it allows the compiler to infer the data type based on the assigned value, its use is a subject of debate regarding code clarity and long-term maintenance.

Wrapper types in Java.

Task 147 Sensor Data NaN Validator V0.1 — An educational project focused on handling special floating-point values in Java. It demonstrates how to parse a "NaN" string into a double and verify it using built-in utility methods, which is crucial for processing telemetry and sensor data where invalid readings may occur.
Task 146 Price Wrapper Logic V0.1 — An educational project exploring the transition between primitive types and their corresponding wrapper classes. It focuses on Autoboxing and Unboxing, which are essential when working with Java Collections or APIs that require objects instead of primitives.
Task 145 Character Type Validator V0.1 — An educational project demonstrating character validation techniques in Java. It specifically focuses on identifying whether a given character belongs to the numeric digit category using the built-in utility methods of the Character wrapper class.
Task 144 Player Score Converter V0.1 — An educational project focused on parsing numerical data from strings. This is a common task when handling user input or reading data from text files where numeric values are initially represented as text.

👉 Working with strings.

StringBuilder and StringBuffer.

Task 143 Advanced Text Editor V0.1 — This project demonstrates professional-grade text editing using StringBuilder. It covers the removal of specific fragments and the replacement of key terms, showcasing how to modify content efficiently without reallocating memory for new string objects.
Task 142 Cryptographic Text Reverser V0.1 — An educational project demonstrating the power of the StringBuilder.reverse() method. This tool is essential for tasks requiring character order inversion, such as palindrome checking or simple cryptographic decoding.
Task 141 Precision Text Inserter V0.1 — This project focuses on the mutable nature of StringBuilder, specifically utilizing the insert() method. This technique allows for adding content at any specific index within a string buffer, which is highly efficient for dynamic text generation like personalized chat-bot greetings.
Task 140 Dynamic String Builder V0.1 — An educational project focused on efficient string manipulation using the StringBuilder class. This approach is highly optimized for scenarios where strings are built incrementally, preventing unnecessary memory allocation.

String comparison: equals, equalsIgnoreCase, compareTo.

Task 139 Registration Validator V0.1 — This project simulates a registration validation system. It demonstrates how to verify if two email addresses are identical regardless of casing and how to check if a specific domain or keyword exists within a registration message.
Task 138 Lexicographical String Comparator V0.1 — An educational project that explores how Java compares strings alphabetically (lexicographically). By using the compareTo() method, we can determine the relative order of strings, which is essential for sorting algorithms and data organization.
Task 137 Case-Insensitive Comparison V0.1 — An educational project demonstrating how to identify file types and extensions by analyzing string prefixes and suffixes. This technique is commonly used in file management systems and data processing pipelines.
Task 136 Case-Insensitive Comparison V0.1 — A fundamental educational project demonstrating how to compare two strings in Java while ignoring their case (uppercase vs. lowercase). This is essential for creating user-friendly interfaces where "Admin" and "admin" should be treated as the same identity.
Task 135 Secure Login Validator V0.1 — An educational project demonstrating the difference between case-sensitive and case-insensitive string comparison in Java. This simulation mirrors real-world login procedures where emails are flexible but passwords are strict.

Basic String methods.

Task 134 Product Filter System V0.1 — An educational project demonstrating conditional string processing. It checks if a product name meets specific criteria (starts with 'E') and generates a 3-character abbreviation if the condition is met.
Task 133 Dynamic String Surgeon V0.1 — An advanced look at substring extraction. Instead of hardcoding indices, this project demonstrates how to programmatically find the start and end positions of a fragment, making the code resilient to changes in the source string.
Task 132 Substring Search Locator V0.1 — An educational project demonstrating how to find the position of a specific word within a string using the indexOf() method. This is a fundamental operation for search engines and text processing applications.
Task 131 Secret Character Extraction V0.1 — An educational project focused on string manipulation. It demonstrates how to retrieve a specific character from a string using its index, highlighting that Java uses zero-based indexing.

String formatting.

Task 130 Localized Result Formatter V0.1 — An educational project demonstrating how to handle internationalization (i18n) in Java. It specifically focuses on using Locale with String.format() to display decimal numbers according to regional standards (using a comma instead of a dot).
Task 129 Warehouse Inventory Reporter V0.1 — This project demonstrates advanced string formatting techniques in Java to create structured, table-like console output. It focuses on field width specification and text alignment for professional reporting.
Task 128 Financial Price Formatter V0.1 — An educational project focused on the precision of financial data display. It demonstrates how to use Java's formatting tools to round and display floating-point numbers with exactly two decimal places.
Task 127 User Dossier Formatter V0.1 — An educational project demonstrating the power of String.format() for creating uniform and readable data strings in Java. This approach is essential for administrative panels and reporting systems.

Character escaping.

Task 126 Unicode Emoji Output V0.1 — This project demonstrates how to output special characters and emojis using their exact Unicode sequences (\uXXXX). This ensures consistent rendering across different environments and systems.
Task 125 Formatted Slogan Output V0.1 — An educational project focused on complex string formatting using escape sequences. It demonstrates how to include double quotes within a string and how to use tabs for visual alignment.
Task 124 Multi-line Text Output V0.1 — An educational project demonstrating how to use the newline escape sequence (\n) to output multiple lines of text using a single output command, adhering to code conventions.
Task 123 Java Path Escaping Demo V0.1 — A simple educational project illustrating how to handle backslashes in Java strings. Backslashes are special characters used for escaping, so to print a literal backslash, it must be escaped with another backslash.

👉 Methods.

Access modifiers, variable scope.

Task 122 School Student Registry V0.1 — This project illustrates the core OOP principle of Encapsulation. It demonstrates how to protect sensitive data using access modifiers while providing controlled ways to interact with it.
Task 121 Box Factory Management V0.1 — This project demonstrates the use of the this keyword in Java to resolve naming conflicts between instance variables and method parameters. The implementation follows a strict decoupled architecture with meaningful class naming to ensure that each component's purpose is clear.
Task 120 Secure Bank Account Demo V0.1 — This project demonstrates strict encapsulation — one of the core principles of object-oriented programming. The account balance is completely hidden from external code (private field). Any modification of the balance is possible only through a controlled public method.
Task 119 Football Village Registry System V0.1 — This project simulates an open village registry. It serves as a demonstration of Public Field Access within a professional N-Tier architecture. The system allows direct modification of a model's data while maintaining a strict pipeline for validation and formatting.

Passing parameters by value and by reference.

Task 118 Football Magical Container Enchantment V0.1 — This project demonstrates the nuances of Java's "Pass-by-Value" mechanism for object references. It proves that while a method can successfully modify the fields of a passed object, it cannot reassign the original caller's reference to a new object instance.
Task 117 Football Team Lineup Manager V0.1 — This project simulates a real-time team`s lineup management tool for a football manager. It demonstrates the fundamental algorithm for swapping two values within an array reference, ensuring that positional changes made in the logic layer persist throughout the application's lifecycle.
Task 116 Bonus List Swap Experiment V0.1 — This project explores Java's memory model, specifically focusing on how object references are passed to methods. It demonstrates that while method calls can modify the internal state of an object (like an array's elements), reassigning the reference itself inside the method has no effect on the original caller's reference.
Task 115 Robot Trajectory Reset V0.1 — This project simulates a robot control system that manages movement trajectories. It specifically demonstrates how Java handles array references, allowing a method to permanently modify the state of an array defined in a different layer of the application.

Return values.

Task 114 Student Grade Calculator V0.1 — This project simulates an automated teacher's assistant tool. It processes an array of exam results, calculates the total sum of grades using an iterative approach, and displays the result through a decoupled architectural pipeline.
Task 113 Sports Results Analyzer V0.1 — This project implements a professional sports score analysis tool. It utilizes a layered architecture to determine the highest score among participants while maintaining strict separation between data entry, comparison logic, and output formatting.
Task 112 Quiz Show Application V0.1 — This project demonstrates a strict unidirectional data pipeline. It ensures absolute separation of concerns: the data layer only provides data, the logic layer only performs calculations, and the formatting layer only manages visual appearance.
Task 111 AI Assistant Greeting V0.1 — This project implements the core logic for an intelligent assistant's personalized greeting feature. It focuses on the effective use of return values to transfer processed data between architectural layers, allowing for flexible message handling.

Declaration and invocation of methods, parameters.

Task 110 Shape Designer Tool V0.1 — This project provides a professional tool for engineers and designers to quickly verify rectangular object parameters. It demonstrates the reuse of static methods with different arguments and showcases clean architectural separation into specialized packages.
Task 109 HR Profile Manager V0.1 — This project simulates an automated system for managing employee records in an HR department. It demonstrates advanced code organization by separating responsibilities into different packages and classes, following the Single Responsibility Principle.
Task 108 Store Cashier Automation V0.1 V0.2 — This project demonstrates two evolutionary steps of a store cashier automation system. Version 1 provides a quick, direct calculation, while Version 2 introduces functional decomposition by separating data calculation from the presentation layer.
Task 107 Personal Greeter V0.1 — This project simulates a personal greeting feature for an interactive application. It focuses on creating a specialized function that addresses users by their name, demonstrating how to implement static methods with parameters to enhance user interaction.

👉 Arrays.

Array of counters and totalizers.

Task 106 Random Number Distribution V0.1 — This project simulates a statistical analysis of a random number generator. It generates 50 integers in the range of 1 to 10 and calculates how many times each specific digit appears. This demonstrates the use of frequency arrays to visualize data distribution and probability patterns.
Task 105 Student Grade Analysis System V0.1 — This project simulates an academic grading system that processes scores across four different subjects for a group of students. It calculates the aggregate score for each individual and identifies the top performer using search algorithms, providing a clear and readable statistical report.
Task 104 Number Classification System V0.1 — This project implements a numerical analysis tool that classifies integers into three categories: positive, negative, and zero. It processes a raw data sequence and generates a statistical summary using a mapped integer array, demonstrating basic data filtering and aggregation techniques.
Task 103 Customer Purchase Aggregator V0.1 — This project automates the calculation of total expenditures for a group of 4 clients. It processes a complex 2D data structure representing daily transactions and aggregates them into a consolidated report. This simulation mirrors real-world billing systems where multiple entries must be summed per user account.
Task 102 Letter Frequency Counter V0.1 — This project implements a frequency analysis tool for a specific set of characters ('a', 'b', 'c'). It processes a character array and uses a separate integer array to track how many times each character appears, demonstrating efficient data categorization logic.

Arrays class: sort, fill, copyOf, equals.

Task 101 Game Security Access Validator V0.1 — This project simulates a security validation system for a gaming environment. It compares two separate integer sequences (main and backup access codes) to ensure they are perfectly identical. The implementation highlights the importance of deep equality checks in Java to verify array contents rather than memory addresses.
Task 100 Meteorological Data Extraction V0.1 — This project simulates a weather station data processing unit. It handles a sequence of daily temperature readings and extracts a specific "mid-day" subset for reporting purposes. The implementation demonstrates how to isolate data ranges within arrays efficiently using standard Java utility methods.
Task 99 Warehouse Management System V0.1 — This project simulates the initialization of a warehouse storage grid. Instead of manual entry, it uses automated batch processing to set the initial state of all storage cells to "Empty". This ensures that the system starts with a clean and verified configuration before any inventory is added.
Task 98 Athletic Race Results V0.1 — This project automates the organization of athletic competition results. It takes raw timing data from participants and sorts them from the fastest (lowest number) to the slowest (highest number) using Java's standard utility methods, ensuring official results are presented in a clear, ascending sequence.

Two-dimensional arrays.

Task 97 Environmental Sensor Grid V0.1 — This project simulates an ecological monitoring system. It organizes sensor readings into a $2 \times 5$ matrix and implements a specific formatting logic to present the data as a clean, readable table. The primary technical focus is on managing whitespace and line breaks during 2D array traversal.
Task 96 Warehouse Inventory Automation V0.1 — This project automates the population of an inventory grid for a warehouse system. It utilizes nested for loops to iterate through a 3x4 matrix, filling it with sequential numbers from 1 to 12. It also includes a visualization module to display the resulting grid in the console.
Task 95 Digital Billboard Grid V0.1 — This project simulates a digital information board represented by a 3x2 grid. The objective is to place a specific message in the final panel (bottom-right corner) and verify its coordinates by rendering the entire grid structure to the console.
Task 94 Theater Seating System V0.1 — This project simulates a seat-numbering system for a small theater hall with 2 rows and 3 seats per row. It introduces the concept of two-dimensional arrays, where data is organized into rows and columns, requiring two indices for access.

Basic operations with one-dimensional arrays.

Task 93 Edge-to-Center Palindrome Check V0.2 — This project implements the "Two Pointers" algorithm to verify if a character array is a palindrome. It avoids creating additional memory structures by comparing elements from the start and end of the array, progressively moving toward the center.
Task 93 Palindrome Checker V0.1 — This project implements a palindrome check for character arrays. A palindrome is a sequence that reads the same forwards and backwards. This specific task demonstrates the Array Reversal and Comparison strategy.
Task 92 Array Fill Demonstration V0.1 — This project demonstrates the process of initializing an array and populating all its elements with a single constant value. It highlights the efficiency of using loops for bulk data assignment compared to manual entry.
Task 91 Smart Home Temperature Analysis V0.1 — This project simulates a data processing module for a "Smart Home" system. It implements an algorithm to find the maximum value within a set of temperature readings. This pattern is fundamental for monitoring peak loads, overheating, or any threshold-based alerts.
Task 90 Shopping Cart Calculator V0.1 — This project simulates a basic checkout system for an online store. It focuses on initializing an array with predefined item prices and performing a mathematical summation of its contents to determine the total cost.
Task 89 Movie Reverser V0.1 — This project demonstrates how to collect user-provided strings into an array and retrieve them in reverse order. It highlights the use of the Scanner class for interactive input and the logic of accessing array elements from the highest index down to the lowest.
Task 88 Galactic Defender Leaderboard V0.1 — This project simulates a high score table for the "Galactic Defender" game. It focuses on Array Literals, a concise way to initialize and populate an array simultaneously, and demonstrates how to output data line-by-line for a leaderboard format.

Introduction to Arrays.

Task 87 Quarterly Array Mapping V0.1 — This project explores advanced indexing techniques by dividing a 120-element array into four logical checkpoints. It demonstrates how to perform arithmetic operations using values stored at specific calculated offsets within the array structure.
Task 86 Array Tail Operations V0.1 — This project focuses on manipulating elements at the end of a large array using dynamic indexing. It demonstrates how to reference positions relative to the array length ($n-1$, $n-2$, etc.) and perform arithmetic operations between these elements.
Task 85 Array Boundaries & Midpoint V0.1 — This project focuses on accessing specific strategic points within an array: the beginning, the end, and the mathematical middle. It demonstrates how to use the array size variable $n$ to calculate indices dynamically, which is essential for algorithms like binary search.
Task 84 Array Basics V0.1 — This project introduces the fundamental concepts of arrays in Java. It demonstrates how to allocate memory for a fixed-size collection, assign values to specific positions using indices, and retrieve data from the start and end of the array.
Task 83 Tournament Scoreboard V0.1 — This project simulates a tournament management system where scores are pre-calculated for each round. It focuses on using a for loop to automate data entry (sequential numbers 1 through 10) and simultaneous data display, mimicking a real-time scoreboard.
Task 82 Weather Station Update Languages List V0.1 — This project simulates a weather station data management system. It focuses on the default initialization of floating-point arrays and the precise manipulation of data at a specific index. The task reinforces the concept of zero-based indexing and manual array traversal.
Task 81 Fantasy Favorite Languages List V0.1 — This project simulates a simple blog entry preparation where a list of favorite programming languages is stored in a fixed-size array. The primary focus is understanding how to retrieve the total capacity of an array using the built-in length property.
Task 80 Fantasy Inventory System V0.1 — This project simulates a basic inventory system for a fantasy game. It illustrates the fundamental concepts of array declaration, memory allocation for a specific capacity, and the use of zero-based indexing to store and retrieve data.

👉 Real numbers and char.

Explicit and Implicit Type Casting in Java.

Task 79 Academic Performance V0.1 — This project focuses on calculating a student's average score from mixed numeric sources. It demonstrates how to maintain precision during division by using double literals and how to truncate the final result for administrative reporting.
Task 78 Weather Sensor V0.1 — This project simulates a data overflow scenario in a legacy weather sensor. It investigates the behavior of narrowing primitive conversion when an int value exceeds the 8-bit capacity of a byte, leading to unexpected results due to bit truncation and the two's complement representation.
Task 77 Spy Cryptography V0.1 — This project simulates a cryptographic mission where characters are encoded into numbers and decoded back. It demonstrates the internal representation of the char data type in Java as a 16-bit Unicode integer and explores both implicit (automatic) and explicit type casting.
Task 76 Warehouse Inventory V0.1 — This project simulates a warehouse calculation where raw material weight must be converted into a count of finished goods. It highlights the use of explicit type casting in Java to perform truncation, effectively discarding fractional data to find the number of whole units available.

Rounding and formatting numbers.

Task 75 Global Sales Reporting V0.1 — This project simulates the reporting system of a global corporate leader. It focuses on presenting massive financial figures in a human-readable format by utilizing the DecimalFormat grouping separator to distinguish thousands and maintain precise decimal alignment.
Task 74 Financial Report V0.1 — This project simulates the preparation of a quarterly financial report for investors. It demonstrates how to use the DecimalFormat class in Java to maintain a consistent professional appearance by ensuring all monetary values are displayed with exactly two decimal places.
Task 73 Magic Shop V0.1 — This project simulates a currency formatting system for a magical shop. It highlights a common task in software development: rounding a double value to exactly two decimal places for financial displays using the scaling and rounding technique.
Task 72 Laser Calibration V0.1 — This project simulates resource management for space colonization. It focuses on converting high-precision engineering estimates into actionable logistics data by using the Math.round method to determine the nearest whole number of materials needed.

Accuracy issues and special values.

Task 71 Laser Calibration V0.1 — This project simulates the calibration process of a high-precision laser system. It demonstrates a critical engineering practice in software development: using a tolerance (epsilon) to compare floating-point values, ensuring that minor numerical fluctuations do not cause logic errors.
Task 70 Mystic Numbers V0.1 — This project simulates an exploration into undefined mathematical territories. It demonstrates how Java's double type handles operations that do not result in a real number, specifically the square root of a negative value, resulting in the NaN (Not a Number) constant.
Task 69 Cosmic Boundary V0.1 — This project simulates an exploration into the limits of numerical calculations. It investigates how Java's double type handles division by zero, representing states like Infinity that exist beyond standard arithmetic results.
Task 68 Chemical Experiment V0.1 V0.2 V0.3 — This project simulates a laboratory experiment in which a scientist mixes two precisely measured components (0.1 and 0.2) to achieve a target concentration of 0.3. It demonstrates the inherent precision issues of the double data type when performing floating-point operations in Java and offers a professional solution, as well as a creative hack for simple calculations.

Introduction to Fractional Numbers and the Double Type.

Task 67 Magic Apples V0.1 — This project simulates the distribution of magical items where fractional parts are required. It highlights a common pitfall in Java: integer division, and demonstrates how to use type casting to obtain a precise double result from int operands.
Task 66 Price Formatter V0.1 — This project demonstrates the critical difference between visual formatting and mathematical rounding. It ensures financial integrity by synchronizing the stored variable value with the displayed price, preventing discrepancies between customer receipts and internal accounting records.
Task 65 Vending Machine V0.1 — This project simulates the payment processing unit of a smart vending machine. It introduces interactive user input using the Scanner class, allowing the system to capture real-time payment data in a floating-point format.
Task 64 Space Navigation V0.1 — This project simulates a navigation calculation for a spacecraft. It demonstrates how to perform division using the double data type to ensure high precision in mission-critical calculations.

Numbers and Symbols in Java.

Task 63 Cyrillic Rune V0.1 — This project concludes the series of character studies by exploring a Cyrillic symbol. It demonstrates that Java's char type natively supports a wide range of global characters through the Unicode standard.
Task 62 Rune Decryptor V0.1 — This project simulates the decryption of an ancient rune. It focuses on the relationship between the char data type and its underlying ASCII numeric representation, demonstrating how Java handles character encoding.
Task 61 Dragon Hoard V0.1 — This project focuses on handling numeric data that exceeds the 32-bit limit of the standard int type. It demonstrates how to correctly declare a 64-bit long variable for massive values, such as a dragon's hoard, using underscores for readability and the mandatory suffix.
Task 60 Hero Inventory V0.1 — This project simulates the creation of a base inventory for an RPG (Role-Playing Game) hero. It demonstrates how to choose and declare appropriate numeric primitive types in Java based on the nature and range of the data being stored.

👉 Cycles.

The "do-while" loop: introduction and nuances of work.

Task 56 Daily Sales Tracker V1.1 — An enhanced version of the sales tracking utility. This iteration introduces advanced flow control using an infinite loop (while(true)), demonstrating how to selectively process data using continue to skip insignificant entries (zeros) and break to terminate the sequence.
Task 56 Daily Sales Tracker V0.1 — This application simulates a point-of-sale system that records daily transactions. It aggregates multiple sales entries into a single total. The program utilizes a sentinel-controlled loop where a negative value serves as the termination signal for the workday.
Task 55 Password Validator V0.1 — This project simulates a secure registration form component. It focuses on string validation using a Do-While Loop, ensuring that the user provides a password that meets specific security requirements (minimum length of 6 characters).
Task 54 Console Menu V0.1 — This project implements a basic interactive command-line menu using a Do-While Loop. It allows users to perform specific actions (like printing a greeting) repeatedly without restarting the application. The program maintains an active state until the user explicitly chooses to exit.
Task 53 ATM PIN Validator V0.1 — This project simulates an ATM user interface for PIN-code validation. It utilizes the Do-While Loop to repeatedly request input from the user until a valid four-digit positive integer (between 1000 and 9999) is provided.
Task 52 Game Bootstrapper V0.1 — This project demonstrates the unique behavior of the Do-While Loop in Java. Unlike a standard while loop, the do-while structure ensures that the code block is executed at least once because the exit condition is checked only after the iteration is complete.

The "for" loop: introduction and nuances of work.

🧩 Nested for-loops: working with 2D grids.

Task 59 Password Finder V0.1 — This project simulates a brute-force search for a "perfect password" consisting of two numbers. It employs nested for-loops to iterate through possible combinations and utilizes an early exit strategy once the target condition (sum equals 13) is met.
Task 58 Asteroid Field Visualization V0.1 — This program simulates a space shuttle's radar view of an asteroid field. It uses nested for-loops to generate a precise 5x7 grid of star symbols (⭐). The project demonstrates basic 2-dimensional rendering in a console environment.
Task 57 Radar Coordinate System V0.1 — This project simulates a radar scanning grid by generating a 3x4 coordinate table. It utilizes nested for-loops to iterate through rows (i) and columns (j), outputting the precise position of each cell in an i,j format.

🧩 Single-level Iterations: flow control and sequence management.

Task 51 Coordinate Tracker V0.1 — This project simulates the tracking of two objects moving in opposite directions. It utilizes an advanced For Loop structure where two variables are initialized, updated, and evaluated simultaneously within a single loop header.
Task 50 Product Cost Calculator V0.1 — This project implements a calculation engine for a dynamic pricing model. In this scenario, the price of an item is directly proportional to its position in the sequence (e.g., the 1st item costs 1, the 2nd costs 2, etc.). It utilizes a For Loop to aggregate the total cost for a set number of products (N).
Task 49 Train Seating V0.1 — This project simulates the identification of even-numbered seats in a train carriage. It utilizes a For Loop to iterate through a range of numbers (0 to 10) and incorporates an If Statement with the Modulo Operator (%) to filter and display only even values.
Task 48 New Year Countdown V0.1 — This project simulates a festive New Year's Eve countdown. It utilizes a For Loop to iterate backwards from 5 to 1, demonstrating precise control over loop initialization, termination conditions, and decrementing steps.

The "while" loop: introduction and nuances of its operation.

Task 47 Coffee Expense Tracker V0.1 — This project implements a budget-tracking utility specifically for coffee expenses. It utilizes a While Loop to continuously collect user input for beverage costs. The sequence is terminated when a negative value is detected, acting as a sentinel signal.
Task 46 Cinema Seats V0.1 — This project simulates the display of available seating in a cinema row. It utilizes a While Loop to iterate through seat numbers starting from 2, incrementing by 2, until reaching the limit of 10.
Task 45 Smartphone Unlock V0.1 — This project simulates a smartphone security interface. It employs a While Loop integrated with the Scanner class to continuously prompt the user for a password until the predefined correct value ("java") is entered.
Task 44 Spaceship Launch V0.1 — This project simulates a spaceship ignition sequence. It utilizes a While Loop to perform a controlled reverse countdown from a starting value to one, followed by a launch signal.

👉 Conditional operator.

Ternary operator in Java: concise conditions and nuances regarding Clean Code.

Task 43 Amusement Park Ticketing System V0.1 — This project implements a multi-tier age categorization logic for an amusement park. It utilizes Nested Ternary Operators to evaluate four distinct age groups within a single expression.
Task 42 Dynamic Greeting System V0.1 — This project implements a simple time-aware greeting mechanism. It utilizes the Ternary Operator to evaluate the current hour and select between two different greeting strings ("Good morning" or "Good day").
Task 41 Online Store Order Parity Checker V0.1 — This project simulates a basic order sorting mechanism for an e-commerce platform. It utilizes the Ternary Operator to perform a parity check on order numbers, classifying them as either "Even" or "Odd".
Task 40 Sports Performance Analysis V0.1 — This project simulates a sports timing system. It focuses on the Ternary Operator, a concise alternative to the standard if-else statement for simple value assignments based on a condition.

Operator precedence and parentheses in conditions.

Task 39 Bank Loan Approval Logic V0.1 — This project simulates a banking decision system using two distinct sets of evaluation rules. It focuses on Complex Logical Expressions and the strategic use of parentheses to enforce specific business requirements using the same applicant data.
Task 38 Party Access Logic V0.1 — This project explores the Associativity of Logical Operators. It tests the admission logic for a private event by evaluating three mandatory conditions using the logical AND (&&) operator with different grouping strategies.
Task 37 Concert Ticket Purchase Logic V0.1 — This project analyzes the impact of Operator Grouping on logical expressions. It compares standard Java precedence rules with custom-defined logic using parentheses to determine concert ticket eligibility.
Task 36 Vacation Planner Logic V0.1 — This project simulates a vacation feasibility check. It focuses on the Precedence of Logical Operators, demonstrating how Java evaluates complex boolean expressions containing both || (OR) and && (AND) without explicit parentheses.

Boolean logical type and logical operations.

Task 35 Smart Thermostat Logic V0.1 — This project simulates the core logic of a smart thermostat. It focuses on Range Validation, using logical operators to check if a numeric value resides between defined inclusive boundaries (20°C to 25°C).
Task 34 Picnic Planner Logic V0.1 — This project simulates a decision-making algorithm for weekend planning. It focuses on Advanced Logical Operators to evaluate multiple boolean conditions simultaneously.
Task 33 Football Match Result Recorder V0.1 — This project simulates a basic sports scoring system. It demonstrates how to use Relational Operators to compare two numeric values and store the resulting truth value in a boolean variable.
Task 32 Boolean Fundamentals V0.1 — This project introduces the Boolean Primitive Type in Java. It demonstrates how to store and display logical truth values, which serve as the foundation for conditional execution and decision-making in programming.

Nested "if", multi-level logic.

Task 31 Loyalty Program Discount Calculator V0.1 — This project simulates a loyalty program logic. It utilizes Nested Conditional Logic to calculate specific discount percentages based on user demographics (age) and membership status (club card).
Task 30 Conference Access Management V0.1 — This project simulates a conference registration system. It utilizes Complex Nested Conditionals to perform high-level visitor filtering based on age and specialized invitation categories (VIP vs. GUEST).
Task 29 Exclusive Club Entry System V0.1 — This project simulates an entry control system for an exclusive club. It utilizes Nested Conditional Logic to validate a user's eligibility based on two factors: minimum age and specific residency (Prague).
Task 28 Secure Access System V0.1 — This project simulates a two-factor security gate. It utilizes Nested Conditional Logic to perform a hierarchical check of user credentials: age verification followed by a secret code validation.

Conditional operator "if-else".

Task 27 Time-based Greeting System V0.1 — This project simulates an adaptive greeting system. It utilizes Multi-Branch Conditional Logic to analyze time-of-day data and return a context-specific greeting.
Task 26 Simple Login System V0.1 — This project simulates a basic security gate. It focuses on the Single-Branch Conditional structure (if without else) and introduces the concept of string value comparison.
Task 25 Clothing Advisor V0.1 — This project simulates a simple weather assistant. It uses conditional branching to analyze temperature data and provide appropriate clothing recommendations.
Task 24 Cinema Access Control V0.1 — This project simulates a cinema ticketing system. It introduces the fundamental concept of Conditional Logic, where the program executes different blocks of code based on a boolean condition (age verification).

👉 Java intro.

Keyboard input.

Task 23 Digital Business Card V0.1 — This project simulates a digital business card generator. It focuses on handling mixed data types (String and int) and demonstrates professional string manipulation.
Task 22 Cashier System V0.1 — This project simulates a simple cashier terminal. It focuses on basic arithmetic operations and handling multiple integer inputs sequentially.
Task 21 Player Registration System V1.1 — This project is a transitional milestone in Java learning journey. While the base task requires simple console input/output, this implementation elevates the solution into an enterprise-ready architecture.
Task 21 Player Registration System V0.2 — This project represents the basic foundation of a Player Registration System. Added console queries for user input.
Task 21 Player Registration System V0.1 — This project represents the basic foundation of a Player Registration System.
Task 20 Login System — This project demonstrates how to handle user input in Java using the Scanner class to read and display a password from the keyboard.

Conversion between data types.

Task 19 Game Score Calculator — This project demonstrates how to parse string-based numeric data (including negative values) into integers and perform arithmetic operations on the resulting data.
Task 18 Movie Year Extractor — This project demonstrates how to convert numeric data stored as a String into a primitive int type to enable mathematical operations.
Task 17 Flight Tracker — This project demonstrates string concatenation in Java by combining numeric flight data with destination text to create a complete status message.
Task 16 Access Code Formatter — This project demonstrates how to convert primitive numeric data types into string representations for data transmission or messaging purposes.

Strings and text: String type, working with strings.

Task 15.1 Anagram Encoder V0.1 — An advanced continuation of string manipulation topics. This is project implements a complex algorithm to reverse only letters within words while preserving the exact positions of all non-letter characters. It demonstrates professional-grade coding with JUnit 5 testing, Maven lifecycle management, and efficient use of StringBuilder.
Task 15 String data cleaning and manipulation — This project focuses on data normalization using the String class. It simulates a real-world scenario where user-provided data (like a city name) contains unnecessary spaces and needs to be formatted.
Task 14 Escaping a quote by Yurii Gagarin — This project demonstrates the use of escaping characters in Java strings. It shows how to include special characters, such as double quotes, inside a String object literal without breaking the code structure.
Task 13 User Profile Creation — This project demonstrates string concatenation in Java. It shows how to combine multiple object types (String) into a single output using the + operator.
Task 12 Message from the future — This project focuses on the String class in Java. It demonstrates how to declare a variable of an object type, initialize it with a string literal containing a message "from the future", and print the stored character sequence to the console.

Integers: int type, operations with int type. Determining the remainder after division "%". Increment and decrement.

Task 11 Hero Health Tracking — This project simulates tracking a character's health in a game environment. It demonstrates the practical use of unary operators: increment (++) and decrement (--).
Task 10 Prize Distribution Logic — This project demonstrates the use of integer division and the modulo operator (%) in Java. It simulates a scenario where a set number of prizes must be distributed equally among teams, and the remainder is calculated.
Task 09 Single-Line Variable Management — This project demonstrates Java's ability to declare and initialize multiple variables of the same type in a single statement. While this approach increases compactness, it is explored here primarily for syntax understanding.

Memory addressing and variables. How to declare a variable and assign a value to it.

Task 08 Bank Account Transactions — This project simulates basic banking operations using integer variables. It demonstrates how to perform balance transfers between accounts and apply bonuses using fundamental arithmetic operations in Java.
Task 07 Memory Allocation & Concatenation — This project focuses on understanding the memory footprint of different primitive data types in Java. It demonstrates how to combine descriptive text with actual variable values using string concatenation.
Task 06 String Manipulation & Immutability — This project demonstrates how Java handles String variables and references. It explores the concept of object assignment and string immutability by creating a copy of a variable and modifying it independently.
Task 05 Game Character Profile — This project demonstrates the use of various Java primitive and reference data types. The goal was to create a profile for a game character by storing different types of information (level, gold, rating, and name) and displaying them in the console.

How to make comments in code.

Task 04 Compilation Error Analysis & Clean Code — This project focuses on debugging a non-compilable Java program. The objective was to identify, analyze, and comment out lines that cause compilation errors or violate task constraints, ensuring the program runs without.
Task 03 Code Blocking & Shortcuts — This project focuses on the use of single-line comments (//) to control code execution. The primary goal was to demonstrate how to block the execution of all commands in a Java program so that it produces no output, as per the task requirements.

Console output

Task 02 Phrase Assembly with Console Output — This project demonstrates the difference between System.out.print() and System.out.println() methods in Java. The goal is to assemble phrases from individual words by controlling the cursor position on the console, ensuring that words appear on the same line or move to a new one as required.
Task 01 Console Output Basics — This is a foundational Java project designed to demonstrate basic console output operations. The goal of the task is to correctly use standard output streams to display mixed data types (integers and Unicode characters) on separate lines.

======================================

💾 Databases and Backend (Course 2)

PostgreSQL integration (in progress).
...
Multithreading and GitLab tasks (Petro).

🎨 Credits

Social preview illustration found via open sources.

Name		Name	Last commit message	Last commit date
Latest commit History 437 Commits
README.md		README.md

Folders and files

Latest commit

History

Repository files navigation