1. Quelle est la différence entre == et equals() en Java ?
L'opérateur == compare les références (adresses mémoire) pour les objets et les valeurs pour les types primitifs. La méthode equals() compare le contenu logique des objets. Exemple : new String("hello") == new String("hello") retourne false (références différentes), mais new String("hello").equals(new String("hello")) retourne true. Attention au String Pool : les littéraux String ("hello") sont internes et partagent la même référence. Quand vous créez une classe, surchargez equals() et hashCode() ensemble (contrat : si a.equals(b) est true, a.hashCode() == b.hashCode() doit être true). Objects.equals() gere les cas null.
2. Expliquez les concepts fondamentaux de la POO en Java.
Quatre piliers : Encapsulation (cacher les détails internes avec les modificateurs d'accès private/protected/public, exposer via getters/setters). Héritage (une classe étend une autre avec extends, Java supporte l'héritage simple uniquement). Polymorphisme (une même méthode se comporte differemment selon le type : surcharge au compile-time, redefinition au runtime). Abstraction (classes abstraites et interfaces pour définir des contrats sans implémentation). Les interfaces en Java peuvent avoir des méthodes default (depuis Java 8) et des méthodes statiques. Préférer la composition à l'héritage quand la relation n'est pas un vrai "est-un".
3. Comment fonctionne la gestion de la mémoire et le garbage collector en Java ?
La mémoire Java est divisee en Heap (objets) et Stack (variables locales, références, frames de méthodes). Le heap est divise en Young Génération (Eden + Survivor spaces) et Old Génération (Tenured). Les nouveaux objets vont dans Eden. Les GC mineurs nettoient la Young Génération fréquemment. Les objets survivants migrent vers l'Old Génération. Un GC majeur (Full GC) nettoie tout le heap, causant des pauses. Algorithmes : G1GC (par défaut depuis Java 9, divise le heap en régions), ZGC et Shenandoah (très faibles pauses, adaptées aux gros heaps). Éviter les fuites mémoire : fermer les ressources, attention aux collections statiques qui grandissent indefiniment.
4. Qu'est-ce que les exceptions en Java et comment les gérer ?
Hiérarchie : Throwable -> Error (ne pas capturer : OutOfMemoryError, StackOverflowError) et Exception. Les exceptions se divisent en checked (doivent être declarees ou capturees : IOException, SQLException) et unchecked (RuntimeException : NullPointerException, IllegalArgumentException). Try-catch-finally pour la gestion, try-with-resources (Java 7+) pour les ressources AutoCloseable. Bonnes pratiques : ne jamais capturer Exception générique, ne jamais avaler une exception (catch vide), utiliser des exceptions spécifiques, documenter les exceptions dans la Javadoc. Le multi-catch (catch (IOException | SQLException e)) simplifie le code.
5. Expliquez les collections en Java (List, Set, Map).
List (ordonnee, doublons autorisés) : ArrayList (accès rapide par index, O(1) get, O(n) insertion au milieu), LinkedList (insertion/suppression rapide, O(1), accès par index O(n)). Set (pas de doublons) : HashSet (O(1) opérations, pas d'ordre), LinkedHashSet (ordre d'insertion), TreeSet (trie, O(log n)). Map (paires cle-valeur) : HashMap (O(1), pas d'ordre), LinkedHashMap (ordre d'insertion), TreeMap (trie par cle, O(log n)), ConcurrentHashMap (thread-safe). Choisir la bonne implémentation selon les besoins : fréquence d'accès vs insertion, besoin d'ordre, concurrence. Toujours spécifier la capacité initiale pour les grandes collections.
6. Qu'est-ce que les Streams en Java 8+ ?
Les Streams permettent le traitement fonctionnel des collections. Pipeline : source -> opérations intermédiaires (map, filter, flatMap, sorted, distinct) -> opération terminale (collect, forEach, reduce, count). Les streams sont lazy : les opérations intermédiaires ne s'exécutent qu'a l'appel d'une opération terminale. Les parallel streams (.parallelStream()) repartissent le traitement sur plusieurs threads. Collectors courants : toList(), toSet(), toMap(), groupingBy(), joining(). Optional
7. Expliquez les concepts de multithreading en Java.
Création de threads : étendre Thread ou implémenter Runnable (préfère). synchronized protege l'accès concurrent (sur méthode ou bloc). volatile garantit la visibilité des changements entre threads. Le package java.util.concurrent offre : ExecutorService (pool de threads), Future/CompletableFuture (résultats asynchrones), CountDownLatch (attente de N événements), CyclicBarrier (synchronisation de threads), Semaphore (contrôle d'accès). Les collections thread-safe : ConcurrentHashMap, CopyOnWriteArrayList. CompletableFuture (Java 8) : chaîne de traitements asynchrones avec thenApply, thenCompose, thenCombine. Les virtual threads (Java 21) simplifient la concurrence massive.
8. Qu'est-ce que Spring Boot et ses avantages ?
Spring Boot est un framework opinione qui simplifie la création d'applications Spring. Avantages : auto-configuration (detecte les dépendances et configure automatiquement), starters (spring-boot-starter-web, starter-data-jpa pour les dépendances groupees), serveur embarque (Tomcat/Jetty integre, pas de WAR), Actuator (monitoring, health checks). Architecture typique : Contrôleurs (@RestController), Services (@Service), Repositories (@Repository), Entities (@Entity). Spring Data JPA genere les requêtes automatiquement depuis les noms de méthodes. Profiles (application-dev.yml, application-prod.yml) pour la configuration par environnement. Spring Boot 3 supporte GraalVM Native Image pour des demarrages ultra-rapides.
9. Comment fonctionne l'injection de dépendances dans Spring ?
Spring gere les objets (beans) via l'IoC Container. Trois modes d'injection : constructeur (recommande, immutable, testable), setter (optionnel), champ (@Autowired sur le champ, deconseille car non testable). Les annotations : @Component (bean générique), @Service (couche métier), @Repository (couche données, traduit les exceptions), @Controller/@RestController (couche web). @Configuration avec @Bean pour la configuration programmatique. Scopes : singleton (défaut), prototype, request, session. @Qualifier pour distinguer plusieurs implémentations d'une même interface. @Primary pour définir une implémentation par défaut.
10. Quels sont les principes SOLID et pourquoi sont-ils importants ?
S - Single Responsibility : une classe à une seule raison de changer. O - Open/Closed : ouvert à l'extension, ferme à la modification (utiliser l'héritage/interfaces). L - Liskov Substitution : un objet enfant doit pouvoir remplacer son parent sans casser le programme. I - Interface Segregation : préférer plusieurs petites interfaces à une grosse (ne pas forcer l'implémentation de méthodes inutiles). D - Dependency Inversion : dépendre des abstractions (interfaces), pas des implémentations concrètes. Ces principes produisent du code maintenable, testable et extensible. Exemple concret : au lieu d'un service qui envoie des emails directement, injecter une interface NotificationService qui peut être email, SMS, ou push.