1. Quelle est la difference entre == et equals() en Java ?
L'operateur == compare les references (adresses memoire) pour les objets et les valeurs pour les types primitifs. La methode equals() compare le contenu logique des objets. Exemple : new String("hello") == new String("hello") retourne false (references differentes), mais new String("hello").equals(new String("hello")) retourne true. Attention au String Pool : les litteraux String ("hello") sont internes et partagent la meme reference. Quand vous creez une classe, surchargez equals() et hashCode() ensemble (contrat : si a.equals(b) est true, a.hashCode() == b.hashCode() doit etre true). Objects.equals() gere les cas null.
2. Expliquez les concepts fondamentaux de la POO en Java.
Quatre piliers : Encapsulation (cacher les details internes avec les modificateurs d'acces private/protected/public, exposer via getters/setters). Heritage (une classe etend une autre avec extends, Java supporte l'heritage simple uniquement). Polymorphisme (une meme methode se comporte differemment selon le type : surcharge au compile-time, redefinition au runtime). Abstraction (classes abstraites et interfaces pour definir des contrats sans implementation). Les interfaces en Java peuvent avoir des methodes default (depuis Java 8) et des methodes statiques. Preferer la composition a l'heritage quand la relation n'est pas un vrai "est-un".
3. Comment fonctionne la gestion de la memoire et le garbage collector en Java ?
La memoire Java est divisee en Heap (objets) et Stack (variables locales, references, frames de methodes). Le heap est divise en Young Generation (Eden + Survivor spaces) et Old Generation (Tenured). Les nouveaux objets vont dans Eden. Les GC mineurs nettoient la Young Generation frequemment. Les objets survivants migrent vers l'Old Generation. Un GC majeur (Full GC) nettoie tout le heap, causant des pauses. Algorithmes : G1GC (par defaut depuis Java 9, divise le heap en regions), ZGC et Shenandoah (tres faibles pauses, adaptees aux gros heaps). Eviter les fuites memoire : fermer les ressources, attention aux collections statiques qui grandissent indefiniment.
4. Qu'est-ce que les exceptions en Java et comment les gerer ?
Hierarchie : Throwable -> Error (ne pas capturer : OutOfMemoryError, StackOverflowError) et Exception. Les exceptions se divisent en checked (doivent etre 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 generique, ne jamais avaler une exception (catch vide), utiliser des exceptions specifiques, 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 autorises) : ArrayList (acces rapide par index, O(1) get, O(n) insertion au milieu), LinkedList (insertion/suppression rapide, O(1), acces par index O(n)). Set (pas de doublons) : HashSet (O(1) operations, 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 implementation selon les besoins : frequence d'acces vs insertion, besoin d'ordre, concurrence. Toujours specifier la capacite 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 -> operations intermediaires (map, filter, flatMap, sorted, distinct) -> operation terminale (collect, forEach, reduce, count). Les streams sont lazy : les operations intermediaires ne s'executent qu'a l'appel d'une operation 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.
Creation de threads : etendre Thread ou implementer Runnable (prefere). synchronized protege l'acces concurrent (sur methode ou bloc). volatile garantit la visibilite des changements entre threads. Le package java.util.concurrent offre : ExecutorService (pool de threads), Future/CompletableFuture (resultats asynchrones), CountDownLatch (attente de N evenements), CyclicBarrier (synchronisation de threads), Semaphore (controle d'acces). Les collections thread-safe : ConcurrentHashMap, CopyOnWriteArrayList. CompletableFuture (Java 8) : chaine 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 creation d'applications Spring. Avantages : auto-configuration (detecte les dependances et configure automatiquement), starters (spring-boot-starter-web, starter-data-jpa pour les dependances groupees), serveur embarque (Tomcat/Jetty integre, pas de WAR), Actuator (monitoring, health checks). Architecture typique : Controleurs (@RestController), Services (@Service), Repositories (@Repository), Entities (@Entity). Spring Data JPA genere les requetes automatiquement depuis les noms de methodes. 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 dependances 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 generique), @Service (couche metier), @Repository (couche donnees, traduit les exceptions), @Controller/@RestController (couche web). @Configuration avec @Bean pour la configuration programmatique. Scopes : singleton (defaut), prototype, request, session. @Qualifier pour distinguer plusieurs implementations d'une meme interface. @Primary pour definir une implementation par defaut.
10. Quels sont les principes SOLID et pourquoi sont-ils importants ?
S - Single Responsibility : une classe a une seule raison de changer. O - Open/Closed : ouvert a l'extension, ferme a la modification (utiliser l'heritage/interfaces). L - Liskov Substitution : un objet enfant doit pouvoir remplacer son parent sans casser le programme. I - Interface Segregation : preferer plusieurs petites interfaces a une grosse (ne pas forcer l'implementation de methodes inutiles). D - Dependency Inversion : dependre des abstractions (interfaces), pas des implementations concretes. 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 etre email, SMS, ou push.