Backend Engineering
360 ore de studiu
42 ședințe live
6 luni
-
- Interview Questions from Java 1 CourseCore 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 StandardCore Commands and Setup- `init`, `clone`, `add`, `commit`, `push`, `pull`, `status`, `log` - Global configuration. .gitignore - [Extra] Git Clients. Sourcetree, IntelliJ Git integrationBranching 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 rebaseGit in practice- Git workflows for teams - Git vs. GitHub. Pull Requests. Code review - [Extra] Squash and merge
-
-
- OOP PrinciplesInheritance. 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 notUpcasting. 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` contractComposition. Aggregation. Polymorphism- Composition vs. Inheritance - Aggregation. "has-a" relationships - Static polymorphism. Dynamic polymorphism. DifferencesAbstract 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 ClassesClass Types. Nested Class Patterns- Static and non-static inner classes - Local classes - Anonymous classesSpecialized Class Types- Practical use of inner classesEnums- `enum` keyword. Defining constants. - `values()`, `valueOf()`, `name()`, `ordinal()` methods - Fields, constructors, and abstract methods in EnumsSealed 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 EnumClean Code Principles- Writing Maintainable Code importance - SOLID principle - DRY principle - KISS principleJava Reflection- Reflection use cases - Performance and security disadvantages - Inspecting classes at runtime via `Class` - Altering objects. `setAccessible`. Reading and modifying private fieldsModern 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 PatternsCreational Patterns- Singleton Pattern - Factory Pattern - Builder PatternStructural Patterns- Adapter PatternBehavioral Patterns- Strategy Pattern - Observer Pattern
- ExceptionsIntro to Exceptions- Exception hierarchy. `Throwable`, `Error`, `Exception`, `RuntimeException` - Checked exceptions vs. unchecked exceptionsHandling Runtime Failures with Exceptions- `try-catch-finally` blocks. The `try-with-resources` statement. - `throw` and `throws` - Defining custom exceptions
-
-
- Java GenericsCompile-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 CollectionsIntroduction 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. ArrayListStack- 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 queuesMap- 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 usageSet- Set definition and usage. The `Set` interface - Implementations: `HashSet`, `TreeSet`, `LinkedHashSet` - Maps and Sets in practice. Use cases and differentiatorsComparable, 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 StructuresHierarchical Data Structures- Trees - Binary Trees - Binary Search Trees (BST)Prefix-Based String Storage- TrieTree 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 ComplexityAlgorithm Complexity Analysis- Reasoning About Performance. Big-O notation - Time complexity vs. space complexity - Comparing algorithms empirically. Best/worst/average casesAdvanced Search and Sorting Algorithms- Binary search - Merge sort - Quick sort - Choosing the right algorithmComplex Problem-Solving Techniques- Sliding Window - Greedy algorithms - Dynamic Programming
-
-
- Streams, Lambda, OptionalFunctional 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-patternsCode Practice- Streams API Hands-on. Use Cases
-
-
- I/OI/O. Reading and Writing from Disk- I/O streams - Buffered I/O: `BufferedReader` and `BufferedWriter` - Java NIO: `Files` APIWorking with Text Files- Modern read and write - Handling I/O exceptions - Automatic file closing. `try-with-resources`
- SerializationSerialization 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. SQLSQL 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 TestingUnit 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 conventionsTesting with Mocks: Mockito- Mockito basics: `@Mock`, `@InjectMocks`. `when().thenReturn()` - Verifying interactions: `verify()`. Testing methods that throw exceptions
-
-
- Concurrency and Parallelism in JavaConcurrency 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 poolsCode Practice on Concurrency in Java- Concurrency in practice: producer-consumer, parallel computation
-
Tehnologii studiate
Backend
-
Java (LTS)
Collaboration Tools & IDE
-
Git -
GitHub -
IntelliJ IDEA
Database
-
SQL -
PostgreSQL -
JDBC
Testing
-
JUnit 5 - Mockito
Nivel
- Utilizare
- Intermediar
- Avansat