- Variables and identifiers. - Primitive data types - Literals. - Type conversions. Type inference with `var` - Type casting: widening (implicit) and narrowing (explicit). - Overflow

- Defining arithmetic operators - Implementing Arithmetic Operators in Java - Chaining and precedence

- Logical, relational and assignment operators - Compound assignment operators - Unary increment/decrement - Logical operators. Truth tables - The ternary operator

- Defining Strings concept. String vs. char sequence - Reading input with `Scanner` - The String class. Basic methods - Working with Strings. Concatenation with other data types - Converting `String` to numbers with parse methods. Common errors

- Breakpoints and variable inspection at runtime - Step over, Step into, Step out. Call stack. Watch expressions - Errors: Compile-Time, Runtime

- Decision Structures in Java. Definition. Syntax - The `if` statement. Code blocks - Nesting. `if`-`else` with multiple branches - Ternary operator - Modern `switch` with arrow syntax `->` and `yield` (Java 14+)

- The `while` statement. The `do-while` statement - Classic `for`. known vs. unknown number of iterations - `break` and `continue`

- Basic Algorithms with conditional structures - Basic Algorithms with iterative structures

- Methods role in any Programming Languages - Methods definition and invocation - The `void` type. Parameters and return values - Variable scope. Local variables - Stack trace debugging

- Method signature. Uniqueness vs. different signatures - Method overloading mechanism. - Parameter passing

- Introduction to recursion principle - Call stack visualization. Stack overflow - Examples of popular series: Factorial, Fibonacci series - Iterative vs. recursive approaches. Strengths and weeknesses

- Real-world modeling vs. OOP concepts - Defining classes. Class vs. object. - Creating objects. the `new` keyword. - Default initialization of state variables

- Instance attributes and methods - `this` keyword. Manipulating object state - The dot (`.`) operator. Chaining - Object lifecycle. Method calling between objects - Flow of an OOP program

- Getters and Setters. IDE auto-generation - Access modifiers in Java. Visibility - Metaspace - `static` keyword. Class fields vs. instance fields. Class-level methods

- Constructors. Definition. Role - Constructor overloading. Default constructor. visibility. - Chaining constructors - The `final` keyword. Immutable Objects. Example

- Object references. References vs. Primitives - References and aliasing - Comparing objects. `equals()` vs `==`

- Stack vs. Heap. Default initialization. - The `null` reference. `NullPointerException` console message - Memory management. Garbage Collector - Object lifetime in Java. Automatic Garbage Collection. Detecting unused objects

- Classic vs. modern `instanceof` operator (Java 16+) - Practical usage in conditional structures and switch - Scope of the pattern variable

- Wrapper classes for primitives. Popular methods - Constants: `MIN_VALUE`, `MAX_VALUE` - Autoboxing and Unboxing. Common pitfalls

- Declaration, initialization and traversal. `ArrayIndexOutOfBoundsException` - Enhanced `for` (for-each). Usage with arrays - Arrays storage. Contiguous memory. Index calculation. Caching and access patterns - Multidimensional arrays. Matrices. Basic Computation with Matrices

- Linear and binary search - Filtering. Min, max, sum, average - Basic sorting algorithms. Comparison with defacto. `Arrays.sort()`

- Reading the Java Documentation. Working with String class - Comparing strings: `equals`, `compareTo`. - Regular expressions and `matches` (with regex) - Strings immutability. Advantages vs. limitations - StringBuilder definition and usage. Constructors and capacity management - String pool

- Processing and transforming character sequences - Interview code challenges with Strings