Backend Engineering

360 ore de studiu

42 ședințe live

6 luni

Interview Questions from Java 1 Course

Core algorithms and OOP Basics

- Fundamental algorithms: searching, sorting, recursion patterns - Popular coding challenges with arrays and strings - Core OOP Concepts: classes, objects, constructors, `static`, `record` - Core OOP Usage: Access modifiers. References. Modern pattern matching
Git: Industry Standard

Core Commands and Setup

- `init`, `clone`, `add`, `commit`, `push`, `pull`, `status`, `log` - Global configuration. .gitignore - [Extra] Git Clients. Sourcetree, IntelliJ Git integration

Branching and Merging

- Branches: `git branch`, `git checkout`, `git switch`, `git merge` - Branching strategies: trunk-based, github flow, gitflow - Resolving conflicts. `git rebase` vs. `git merge`. Interactive rebase

Git in practice

- Git workflows for teams - Git vs. GitHub. Pull Requests. Code review - [Extra] Squash and merge
OOP Principles

Inheritance. Building Class Hierarchies

- The inheritance concept - The `extends` keyword - Constructor chaining. `super()` - Method overriding with `@Override`. `final` keyword role - Single inheritance in Java - Inheritance rules. What is inherited vs what is not

Upcasting. Downcasting. The Object Class

- Upcasting and Downcasting principles in OOP. implicit vs. explicit - Usage of `instanceof`. `ClassCastException` - The `Object` superclass. Special methods: `equals(Object)`, `hashCode()`, `toString()`, `getClass()` - The `equals` / `hashCode` contract

Composition. Aggregation. Polymorphism

- Composition vs. Inheritance - Aggregation. "has-a" relationships - Static polymorphism. Dynamic polymorphism. Differences

Abstract Classes. Interfaces

- The `abstract` keyword. Abstract methods. Abstract classes. - Interfaces. `interface` keyword. `implements` keyword. - Multiple interface implementation. `default` and `static` methods in interfaces - Abstract classes vs. Interfaces. Usecases

Class Types. Inner Classes. Specialized Classes. Sealed Classes

Class Types. Nested Class Patterns

- Static and non-static inner classes - Local classes - Anonymous classes

Specialized Class Types

- Practical use of inner classes

Enums

- `enum` keyword. Defining constants. - `values()`, `valueOf()`, `name()`, `ordinal()` methods - Fields, constructors, and abstract methods in Enums

Sealed Classes (Java 17+)

- Motivation: controlled inheritance - The `sealed` keyword. The `permits` clause - Subclass modifiers: `final`, `sealed`, `non-sealed` - Usage with `switch` pattern matching (Java 21+) - Comparison with Enum

Clean Code Principles

- Writing Maintainable Code importance - SOLID principle - DRY principle - KISS principle

Java Reflection

- Reflection use cases - Performance and security disadvantages - Inspecting classes at runtime via `Class` - Altering objects. `setAccessible`. Reading and modifying private fields

Modern Data Classes with `record` (Java 16+)

- The `record` keyword. Concise data classes - Automatic getters, `equals()`, `hashCode()`, `toString()` - Comparison with classic classes. When to use records vs. classes

Fundamental Design Patterns

Creational Patterns

- Singleton Pattern - Factory Pattern - Builder Pattern

Structural Patterns

- Adapter Pattern

Behavioral Patterns

- Strategy Pattern - Observer Pattern

Exceptions

Intro to Exceptions

- Exception hierarchy. `Throwable`, `Error`, `Exception`, `RuntimeException` - Checked exceptions vs. unchecked exceptions

Handling Runtime Failures with Exceptions

- `try-catch-finally` blocks. The `try-with-resources` statement. - `throw` and `throws` - Defining custom exceptions
Java Generics

Compile-Time Type Safety with Java Generics

- Generic classes and methods - Bounded type parameters. The diamond operator `` - Wildcards: `?`, upper-bounded ``, lower-bounded ``. - Type erasure - Using Generics with `Collection`

Common Data Structures and their corresponding Java Collections

Introduction to Collections. ArrayList

- Java Collections Framework - ArrayList Collection. Operations. Dynamic resizing. Arrays vs. ArrayList - Traversal with enhanced `for` (for-each). Traversal with `Iterator` and `hasNext()` / `next()`

LinkedList

- LinkedList Data Structure. Types of linked lists in Computer Science - Doubly-linked list implementation. Singly-linked vs. doubly-linked lists - Common list operations. Time complexity. - Performance comparison and use cases: LinkedList vs. ArrayList

Stack

- Stack properties and implementation. LIFO - The legacy `Stack` class vs `ArrayDeque`

Queue

- Queue properties and implementation. FIFO - `ArrayDeque` vs `LinkedList` for Stack implementation - The `Deque` interface for double-ended queues

Map

- Map definition and usage. The `Map` interface - Common methods: `put(K key, V value)`, `get`, `remove`, `containsKey` - Implementations: `HashMap`, `TreeMap`, `LinkedHashMap` - When to use. Trade-offs in lookup time vs. memory usage

Set

- Set definition and usage. The `Set` interface - Implementations: `HashSet`, `TreeSet`, `LinkedHashSet` - Maps and Sets in practice. Use cases and differentiators

Comparable, Comparator and PriorityQueue

- The `Comparable` interface. Natural ordering - The `Comparator` interface. Custom ordering - Sorting in Java. `Collections.sort`. `List.sort()`. `Arrays.sort` - Lambda-based comparators - PriorityQueue. Advanced sorting with custom comparators

Complex Data Structures

Hierarchical Data Structures

- Trees - Binary Trees - Binary Search Trees (BST)

Prefix-Based String Storage

- Trie

Tree and Graph Traversal

- Depth-First Search (DFS) algorithm. Pre-order, in-order, post-order for trees - DFS implementation using a stack - Breadth-First Search (BFS) algorithm - BFS implementation with a queue - BFS use case example: shortest path
Algorithms and Complexity

Algorithm Complexity Analysis

- Reasoning About Performance. Big-O notation - Time complexity vs. space complexity - Comparing algorithms empirically. Best/worst/average cases

Advanced Search and Sorting Algorithms

- Binary search - Merge sort - Quick sort - Choosing the right algorithm

Complex Problem-Solving Techniques

- Sliding Window - Greedy algorithms - Dynamic Programming
Streams, Lambda, Optional

Functional Programming in Java

- From anonymous classes to lambda expressions - Lambda syntax. Method references - Built-in functional interfaces: `Predicate`, `Function`, `Consumer`, `Supplier` - The `@FunctionalInterface` annotation - Functional interfaces in the context of lambda expressions. Using lambdas with `Collections.sort` and `Comparator`

Stream API

- Creating streams - Intermediate operations: `filter`, `map`, `flatMap` - Terminal operations: `collect`, `reduce`, `forEach` - Parallel streams. Pitfalls of shared state

`Optional` and Handling Absent Values

- The `null` problem and `NullPointerException` - Creating and using `Optional` - Functional methods: `map`, `flatMap`, `orElse`, `orElseThrow` - Anti-patterns

Code Practice

- Streams API Hands-on. Use Cases
I/O

I/O. Reading and Writing from Disk

- I/O streams - Buffered I/O: `BufferedReader` and `BufferedWriter` - Java NIO: `Files` API

Working with Text Files

- Modern read and write - Handling I/O exceptions - Automatic file closing. `try-with-resources`

Serialization

Serialization with Jackson. Working with JSON

- `ObjectMapper`. Serialization and deserialization. Pretty-printing - Jackson annotations: `@JsonProperty`, `@JsonIgnore`, `@JsonFormat`, `@JsonInclude`, `@JsonCreator` - Working with `List`, `Map`, nested objects, polymorphic types

Relational Databases. SQL

SQL Fundamentals

- The relational model: tables, rows, columns, primary keys, foreign keys - CRUD with `SELECT`, `INSERT`, `UPDATE`, `DELETE`. The `WHERE` clause - `JOIN` between tables - Grouping with `GROUP BY`. Ordering with `ORDER BY`

JDBC: Connecting Java to Databases

- The JDBC driver. The JDBC API - `Connection`, `Statement`, `PreparedStatement` - Working with `ResultSet`. Transactions - JDBC limitations: why we need ORMs (JPA / Hibernate)

Code Practice

- SQL Queries in real-world scenarios - Creating a JDBC application from scratch
Unit Testing

Unit Testing with JUnit

- The anatomy of a test. Arrange-Act-Assert pattern. The `@Test` annotation - Assertions: : `assertEquals`, `assertTrue`, `assertNotNull`, `assertThrows`, `assertAll` - Lifecycle: `@BeforeEach`, `@AfterEach`, `@BeforeAll`, `@AfterAll` - Parameterized tests. Organizing test suites. Test naming conventions

Testing with Mocks: Mockito

- Mockito basics: `@Mock`, `@InjectMocks`. `when().thenReturn()` - Verifying interactions: `verify()`. Testing methods that throw exceptions
Concurrency and Parallelism in Java

Concurrency Programming Foundations

- Threads. extending `Thread` vs. implementing `Runnable`. `Callable` - Thread lifecycle: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED - Concurrency hazards: race conditions, deadlocks. `synchronized` blocks and methods - Atomic classes. `AtomicInteger`. - Thread-safe collections: `ConcurrentHashMap`, `CopyOnWriteArrayList` - Modern concurrency: Virtual Threads (Java 21+). `ExecutorService`. Thread pools

Code Practice on Concurrency in Java

- Concurrency in practice: producer-consumer, parallel computation