← Toutes les matières

R3.02 · R3.03 Interactive

Développement efficace + Analyse · BUT informatique, semestre 3 · examen QCM, 2 parties, 2 notes

Ou lis d'abord le cours ci-dessous : le bouton du parcours t'attend à la fin.

1. Écoinformatique (slides 9-29)

Chaque octet se matérialise dans le monde réel : consommation d'énergie, de ressources physiques (métaux, silice, eau), émissions de gaz à effet de serre (eGES) et déchets. Matériel et logiciel ont un cycle de vie qui impacte l'environnement de leur création à leur destruction. Phénomène d'obésiciel (logiciel obèse).

ChiffreValeur à connaître
Empreinte carbone du numérique mondial≈ 4 % des eGES = ×1,5 l'aérien mondial (GIEC 2022)
Prévision GIEC 2030numérique = 20 % de la consommation d'énergie mondiale
Transistors par processeur2 300 (1971) → 19+ milliards (2017) : ×10⁷
Personnes connectées2 Md (2010) → 5 Md (2020) → 6 Md (2025)
Objets connectés1 Md (2010) → 75 Md (2025)
Poids d'une page web14 Ko (1995) → 2 200 Ko (2022) : ×155, inflation non justifiée

Définition · jour de dépassement

Jour de l'année à partir duquel toutes les ressources naturelles renouvelables en 1 an ont été consommées. J = (B / E) × 365, B = biocapacité, E = empreinte écologique, tous deux en hectares globaux.
Monde 2026 : 30 juillet · France 2026 : 24 avril (2023 : 5 mai). Conso : 170 % du rythme mondial (≈ 1,7 planète), 300 % au rythme français. Qatar le plus tôt (6 fév. 2025), Uruguay le plus tard (17 déc.).

Limites planétaires

9 limites : climat · biosphère · azote et phosphore · usage des sols · eau douce · acidification des océans · ozone · aérosols · nouvelles entités. 6/9 dépassées en 2023, 7/9 en 2026 ; la plus récente : l'acidification des océans (2025). Cause n°1 côté numérique : l'obsolescence par obésité logicielle.

Équipements (Arcep/ADEME) : plus de 800 M d'équipements en France (2020), dont 245 M d'objets connectés ; smartphones ≈ 14 %, téléviseurs ≈ 13,7 %, datacenters + réseaux ≈ 21,6 %. Scénarios 2050 : Génération frugale ÷2 (le seul qui baisse) · Coopérations territoriales ×1,6 · Technologies vertes ×5 · Pari réparateur ×14. Web (GreenIT) : 1 500 Mt éq. CO₂/an ; par Européen, 39 % du budget GES soutenable.

L'écoconception

Écoconcevoir un service en ligne, c'est, à niveau de qualité constant, réduire la quantité de moyens informatiques nécessaires (son empreinte matérielle), à chaque étape du cycle de vie. 4 leviers : type de terminal, durée de vie du terminal, temps passé, type de connexion. Le gros des économies vient de l'allongement de la durée de vie des équipements ; la conception en amont pèse plus que l'optimisation des lignes de code.

Simplicité (qualitative) : chaque besoin couvert par un ensemble cohérent de fonctionnalités, une interface homogène. Frugalité (quantitative) : couverture et profondeur fonctionnelles au strict minimum.

Piège QCM

Pertinence = utilité × rapidité × accessibilité : un produit, pas une somme. Un facteur faible ⇒ l'utilisateur change de service ⇒ 100 % d'impacts inutiles.

2. Analyse des exigences (slides 30-52)

Exigences logicielles : description des propriétés et fonctionnalités du système cible, reflet des besoins de l'utilisateur. Ingénierie des exigences (IE) : collecter, analyser, puis présenter les exigences dans la SRS (System Requirements Specification). Référence : Sommerville.

FonctionnellesNon-fonctionnelles
Services que le système doit fournir, comment il réagit à des entrées, comment il se comporte dans certaines situations. Utilisateur = énoncés de haut niveau ; système = services décrits dans le détail. Contraintes sur les services : propriétés (fiabilité, temps de réponse, stockage), contraintes (E/S, représentations), processus (AGL, langage, méthode). Peuvent être plus critiques : non satisfaites ⇒ système inutile.

BIBSYS : « visionneuses adaptées » est ambigu (une par type de document ? une seule visionneuse texte ?). Une exigence ambiguë est interprétée différemment. Complètes = couvrent tout ; consistantes = sans contradiction ; les deux à la fois : impossible en pratique.

PropriétéMesures
Vitessetransactions/s, temps de réponse, rafraîchissement écran
TailleMo, nombre de puces ROM
Facilité d'utilisationtemps de formation, nombre d'écrans d'aide
Fiabilitétemps moyen d'échec, probabilité de non-disponibilité, taux d'échec, disponibilité
Robustessetemps de redémarrage après échec, % d'événements cause d'échec, probabilité de corruption de données
Portabilité% d'exigences dépendantes de la cible, nombre de systèmes cibles

Piège QCM

Fiabilité = avant l'échec (temps moyen, disponibilité). Robustesse = après l'échec (redémarrage, corruption).

Processus d'ingénierie des exigences

Démarre si l'étude de faisabilité est concluante. 4 activités génériques : élicitation · analyse · validation · gestion. Éliciter ≈ recueillir, découvrir, avec les parties prenantes (stakeholders : pour un DAB, clients, managers, guichet, sécurité, maintenance, régulateurs…). Cycle d'élicitation-analyse : 1. découverte → 2. classification & organisation → 3. priorisation & négociation → 4. spécification.

Cas d'utilisation et scénarios

Technique à base de scénarios en UML qui identifie les acteurs (personne ou composant à l'origine d'une interaction) et décrit l'interaction. Un cas d'utilisation = objectif du système motivé par le besoin d'un ou plusieurs acteurs. Diagramme : package (rectangle = le système), acteurs (bonshommes), cas (ellipses), associations (traits), notes (coin corné).

Définition · scénario (5 éléments)

1. situation de départ · 2. flux normal · 3. ce qui peut mal se passer · 4. activités parallèles · 5. état final.

Diagramme de séquence

Participants « objet : Classe » soulignés, ligne de vie verticale pointillée, appel = flèche pleine, retour = flèche pointillée, exécution = barre d'activation. Un message reçu par un objet devient une méthode de sa classe. Modélisations de système (§8.4) : contextuelles, comportementales, orientées données, orientées objet.

Dans ton TP

Contrôle d'accès : clavier 4 chiffres, voyants rouge/vert (multiplicité 2), minuteur 5 s / 20 s, porte, alarme, base de codes. saisirChiffre → chiffreSaisi → verifierCode → deverrouiller → ouvrir. Pas de message entre deux acteurs.

3. Modélisation objet & UML (slides 52-61)

Les modèles objet décrivent le système en classes (abstraction d'objets aux attributs et services communs) et associations. Ils reflètent naturellement le monde réel ; les entités abstraites sont plus difficiles. Identifier les classes est difficile et demande une connaissance profonde du domaine ; les classes du domaine sont réutilisables.

Héritage : hiérarchies où le sommet porte les propriétés communes. Héritage multiple : 2 risques, conflits sémantiques (même nom, sens différent) et réorganisation plus complexe. Java l'interdit pour les classes : une classe implémente plusieurs interfaces. Agrégation : classes-collections composées d'autres classes (losange côté ensemble). Modèle comportemental : diagrammes de séquence ou de collaboration.

ÉlémentNotation (cheatsheet)
Visibilité+ public · - private · # protected · ~ package
Classe abstraite / interfacenom en italique / «interface» IFoo
Inheritance (is-a)trait plein + triangle vide
Implémentationpointillés + triangle vide (la slide 60 l'appelle « Generalization »)
Association / two-waytrait ou flèche ouverte (A peut appeler B) / <——>
Dependencyflèche ouverte pointillée : « uses but is not a field »
Aggregation / Compositionlosange vide (B survit) / losange plein (B ne peut exister sans A)
Cardinality / Note1..* / rectangle à coin plié

Piège QCM

En UML standard, généralisation = héritage = trait plein ; la flèche pointillée s'appelle réalisation. Retiens : plein = extends, pointillé = implements.

4. ⭐ Toutes les associations UML

Une relation exprime qu'un objet connaît, contient, est une sorte de ou utilise un autre. De la plus faible à la plus forte :

RelationSymboleSe litEn Java
Dépendanceutilise temporairementparamètre, variable locale, appel statique
Associationconnaîtattribut référence
Navigableconnaît, dans un sensseul A a un attribut vers B
Agrégationa / regroupe (partagé)collection d'objets qui vivent sans le tout
Compositionest composé de (exclusif)le tout crée et détruit ses parties
Généralisationest unextends
Réalisationrespecte le contratimplements

À retenir

Le losange est toujours côté TOUT. Le triangle (vide) pointe vers le plus général. La flèche ouverte = sens de navigabilité. Pointillés = dépendance et réalisation.

Multiplicités, rôles, nom

1 exactement un · 0..1 optionnel · * = 0..* · 1..* au moins un · n..m · 2 (2 voyants). La multiplicité se lit à l'autre bout (« une Personne travaille pour 0..1 Entreprise » : on lit le 0..1 côté Entreprise). Le rôle nomme l'extrémité (souvent le nom de l'attribut Java). Le nom d'association est un verbe avec ▶. En Java : 0..1 → référence (null possible), * → collection.

Les 11 types, un par un

TypeQuand l'utiliserExemple
1. Association simplerelation durable entre objets « égaux », parcourue dans les deux sensProfesseur ↔ Cours
2. Navigableun seul sens utile : moins de couplage (× côté source = non navigable)Commande → Client
3. Réflexiveclasse liée à elle-même, rôles indispensableschef / subordonné, DNode next/prev
4. Classe d'associationla donnée appartient au lien (souvent * — *)Inscription (note) entre Etudiant et Module
5. Qualifiéeune clé sélectionne un objet, réduit * à 0..1 ; en Java une MapBanque [numero] → Compte
6. N-airelosange vide central (≠ agrégation), rareProfesseur + Salle + Classe
7. Agrégation ◇tout/partie faible : la partie survit, peut être partagée, reçue de l'extérieurÉquipe ◇ Joueur
8. Composition ◆tout/partie forte : un seul tout (côté tout ≤ 1), créée par le tout, meurt avec luiMaison ◆ Pièce, Commande ◆ LigneCommande
9. Généralisation« B est une sorte de A » dans tous les cas (Liskov) ; sinon compositionLutin → Personnage
10. Réalisationcapacité transversale ; lollipop ○— possibleLutin ⇢ Travailleur
11. Dépendancecouplage ponctuel (stéréotypes «use», «create», «call»)Imprimante ⇢ Document
class Banque  { private Map<String, Compte> comptes = new HashMap<>(); } // qualifiée
class Maison  { private final List<Piece> pieces = new ArrayList<>();
                Maison() { pieces.add(new Piece(20)); } }                 // composition : créées PAR le tout
class Equipe  { private List<Joueur> joueurs = new ArrayList<>();
                void ajouter(Joueur j) { joueurs.add(j); } }                // agrégation : reçu de l'extérieur
class Lutin extends Humanoide implements Travailleur, Divertissable { }    // 1 généralisation + 2 réalisations
Trancher viteAssociationAgrégation ◇Composition ◆
Tout / partie ?NonOui (faible)Oui (forte)
Partie partageable ?—OuiNon
Partie survit au tout ?OuiOuiNon
Multiplicité côté toutlibrelibre1 ou 0..1
Qui crée la partie ?n'importe quil'extérieurle tout
ExemplePersonne — VoitureUniversité ◇ ÉtudiantUniversité ◆ Département

Piège QCM

Losange vide à 3 branches = n-aire. En composition, multiplicité côté composite ≤ 1. Héritage et réalisation : ni multiplicité ni rôle. Le triangle plein n'existe pas.

5. Complexité algorithmique (slides 62-76)

« Ce qui ne se mesure pas ne s'améliore pas. » Exemple du trafic aérien : distances entre toutes les paires d'avions, deux boucles imbriquées, n(n−1) calculs ⇒ O(n²). Mesures : 4 000 → 190 ms, 8 000 → 664 ms, 16 000 → 2 647 ms : taille ×2 ⇒ temps ×4.

Définition · Grand O

Une abstraction de la performance, indépendante du matériel et du langage ; pas une mesure en unité de temps ; un ordre de grandeur du nombre de calculs élémentaires ; une limite asymptotique, 3 cas : favorable (limite basse), pire (limite haute), moyen ; seulement pour un très grand nombre d'entrées.

Pourquoi pas chronométrer ? Dépendance au matériel, à la mémoire occupée, chargement de la JVM, comparaison et prédiction difficiles.

Grand ONomReconnaître
O(1)constanteaccès direct
O(log n)logarithmiqueentrée divisée par 2 à chaque étape (recherche binaire)
O(n)linéaireune passe (countChars, recherche linéaire : n/2 tours en moyenne)
O(n log n)log-linéairebons tris (quicksort moyen)
O(n²) / O(n³)quadratique / cubique2 / 3 boucles imbriquées (intersection naïve)
O(2ⁿ) / O(n!)exponentielle / factoriellevoyageur de commerce, force brute, factorisation

Piège QCM

Quand n double : O(n) ×2 · O(n²) ×4 · O(n³) ×8 · O(log n) +1 étape · O(n log n) un peu plus que ×2. On garde le terme dominant : 3n² + 5n + 2 ⇒ O(n²) ; n/2 ⇒ O(n). La cryptographie repose sur l'absence d'algorithme polynomial connu de factorisation.

Dans ton TP

TP6 : System.nanoTime() avant/après, ÷ 1 000 000 pour des ms (sert à mesurer une durée, pas l'heure). Taille ×10 ⇒ temps un peu plus que ×10 ⇒ n log n. Petites tailles peu fiables (JVM pas encore « chauffée »).

6. Structures de données (slides 77-106)

Structure de données abstraite (TAD) : ce que la structure doit faire, pas comment. Tableaux, structures chaînées (listes, arbres, graphes), piles LIFO, files FIFO, tables associatives.

Liste simplement chaînée

Nœuds (élément + next) dans un ordre linéaire ; tête, queue ; queue.next == null ; taille indéfinie ; position non indexée. Insertion en tête : v.next = head; head = v; size++ (O(1)). Insertion en queue : v.setNext(null); tail.setNext(v); tail = v. Suppression en tête : head = head.getNext(). Suppression en queue : parcours pour trouver l'avant-dernier, O(n). Toujours se demander « et si la liste est vide ? ».

Liste doublement chaînée & sentinelles

Chaque DNode a next et prev. Sentinelles header/trailer : nœuds factices sans élément (header.prev == null, trailer.next == null, non comptés dans size) qui simplifient la programmation (plus de cas particuliers). Insertion de v entre u et w : 4 pointeurs (u.next, v.prev, v.next, w.prev). Suppression : on court-circuite (prev.next = next, next.prev = prev).

private void addAfter(DNode u, String e) {      // ton TP
  DNode w = u.getNext();
  DNode v = new DNode(e, u, w);
  u.setNext(v); w.setPrev(v); size++;
}

Arbres et parcours

Structure hiérarchique, racine en haut ; frères = même parent ; externe = feuille (aucun enfant), interne = au moins un enfant. Formel : racine sans parent, tout autre nœud a un parent unique. Récursif : un arbre est vide ou une racine + des sous-arbres ⇒ il peut être vide. TAD : element(), root(), parent(v), children(v).

Parcours de F(B(A, D(C, E)), G(-, I(H, -)))RègleRésultat
Préfixeracine d'abord (R, G, D)F B A D C E G I H
Infixeracine au milieu (G, R, D), binaire seulementA B C D E F G H I
Postfixeracine en dernier (G, D, R)A C E D B H I G F

Infixe d'un arbre binaire de recherche ⇒ ordre croissant. Exemple du cours (postfixe) : 10 → (20, 30 → (40, 50)) donne 20 40 50 30 10.

Tables associatives et hachage

Map : paires (clé, valeur), clés uniques, valeurs répétables. Avec une liste : chaque opération en O(n). Table de hachage = tableau d'alvéoles + fonction de hachage : valeurs indexées par la valeur de hachage (pas par la clé), O(1) en moyenne, risque de collision (2 clés distinctes, même valeur). En Java, 2 temps : hashCode puis compression modulo N. Bonne fonction = uniformité + rapidité + taille. Taille première (évite les diviseurs communs) ou puissance de 2 (modulo par décalages).

StructureAvantagesInconvénients
Tableauinsertion rapide, accès très rapide par indexrecherche et suppression lentes, taille fixe
Tableau triérecherche plus rapideinsertion et suppression lentes
Pile / Fileaccès LIFO / FIFOaccès lent aux autres éléments
Liste chaînéeinsertion et suppression rapidesrecherche lente
Arbre binairetout rapide si équilibrésuppression complexe
Table de hachageO(1) en moyenne par clécollisions, pas d'ordre

7. Algorithmes de tri (slides 107-118)

Intersection naïve de 2 tableaux : O(n²). En triant (O(n log n)) : trier un tableau + recherche binaire pour chaque valeur ⇒ O(n log n) ; ou trier les deux + deux pointeurs ⇒ 2·n log n + n = O(n log n). Un tri ne peut pas être efficace dans toutes les situations (aléatoires, presque triées, inversées, doublons).

Tri à bulles : plusieurs passages en intervertissant les voisins mal ordonnés ; le plus grand « remonte » à la fin. Simple mais O(n²). Exemple : 5 1 4 2 → 1 4 2 5 → 1 2 4 5.

Récursivité & divide-and-conquer

Récursivité : une fonction s'appelle jusqu'à la condition d'arrêt ; contient une ou plusieurs conditions d'arrêt + un ou plusieurs appels récursifs. Récursivité ≠ récurrence. Patron : Divide (sous le seuil, résoudre ; sinon découper) · Conquer (résoudre récursivement) · Combine (fusionner).
binarySearch(x, array, start, end)          // tableau TRIÉ, O(log n)
  if (start <= end) then
    mid <- (end - start)/2 + start           // évite le débordement de (start+end)/2
    if (array[mid] = x) then return true      // arrêt 1 : trouvé
    if (array[mid] > x) then return binarySearch(x, array, start, mid - 1)
    return binarySearch(x, array, mid + 1, end)
  return false                                // arrêt 2 : start > end

Quicksort

Algorithme de Tony Hoare, récursif, divide-and-conquer. Lomuto : pivot = dernier ; on cherche le 1er élément supérieur au pivot, on l'échange avec chaque élément inférieur rencontré ensuite, puis le 1er supérieur avec le pivot ⇒ L (gauche) et G (droite). Tri en place.

int partition(ArrayList<Integer> s, int debut, int fin) {   // ton TP6
  Integer pivot = s.get(fin);
  int a = debut;
  while (a < fin && s.get(a) <= pivot) a++;
  for (int b = a + 1; b < fin; b++)
    if (s.get(b) < pivot) { swap(s, a, b); a++; }
  swap(s, a, fin);                 // pivot à sa place
  return a;
}

Complexité du quicksort

Meilleur et moyen : O(n log n). Pire : O(n²), quand le pivot est toujours le min ou le max (pivot = dernier sur une liste déjà triée ou inversée : une partition vide à chaque appel) ⇒ récursion de profondeur n ⇒ StackOverflowError dès 50 000 éléments dans ton TP. Remèdes : pivot aléatoire, médiane-de-trois (heuristique : vite et assez bon, sans garantie), médiane-de-9 (meilleur pivot, plus lent).
Liste (taille)classiquerandomisémédiane-de-3médiane-de-9
aléatoire 1 000 000245 ms256 ms254 ms347 ms
triée 10 000142 ms0,94 ms0,52 ms1,5 ms
triée 50 000StackOverflow5,8 ms3,3 ms8,5 ms

8. Java efficace (Effective Java, J. Bloch, 3e éd.)

FicheÀ retenir
1 Fabrique statique+ a un nom, pas obligée de créer un objet, renvoie n'importe quel sous-type, classe variable selon les paramètres ou inexistante à l'écriture. − sans constructeur public/protégé, pas de sous-classe ; difficile à trouver. ≠ pattern Factory Method. Ex. Boolean.valueOf.
2 Builderquand un constructeur a beaucoup de paramètres.
6 Objets inutilesnew String("bikini") : NON. Long sum = 0L : autoboxing, un Long par tour, horriblement lent.
7 Références obsolètesle GC n'empêche pas les fuites : portée la plus courte ; null quand la classe gère sa mémoire (pile, cache, listeners).
10 equalsinutile si instances uniques, pas d'égalité logique, déjà fait par la superclasse, classe privée.
11 hashCodeToujours avec equals. Contrat : stable ; égaux ⇒ même hashCode (obligatoire) ; différents ⇒ distincts non requis. Sinon m.get(new PhoneNumber(…)) renvoie null.
12 / 14toujours redéfinir toString ; Comparable : (compareTo == 0) == equals recommandé mais pas requis.
15 / 16minimiser l'accessibilité (un tableau public static final reste modifiable) ; accesseurs plutôt qu'attributs publics.
17 Immuabilité5 règles : aucun mutateur, classe final, attributs final, attributs private, accès exclusif aux composants mutables. String, Integer, BigInteger, BigDecimal. Inconvénient : un objet par valeur.
18 Composition > héritagehériter d'une classe concrète d'un autre package viole l'encapsulation.
20 Interfaces > classes abstraitesplusieurs interfaces possibles (pas d'héritage multiple), mixins, types non hiérarchiques.
28 Listes > tableauxtableaux covariants : Object[] t = new Long[1]; t[0] = "x"; compile puis ArrayStoreException. Génériques invariants : List<Object> l = new ArrayList<Long>(); ne compile pas.
29 / 34types génériques ; enum plutôt que constantes int (pas de vérification de type, valeurs compilées en dur, pas de nom en chaîne).
49 / 50vérifier les paramètres (Objects.requireNonNull) ; copies défensives : copier avant de vérifier, vérifier sur les copies, méfiance avec clone.
52 Surchargerésolue à la compilation selon le type statique : classify affiche 3 fois « Collection inconnue ». La redéfinition est dynamique.
57-59, 64portée minimale des variables ; for-each ; connaître java.lang, java.util, java.io ; référencer par l'interface (List<X> l = new ArrayList<>()).
63 Concaténation+= en boucle = temps quadratique ⇒ StringBuilder (6,5× plus rapide).
85 Sérialisationtrès risquée (ransomware du métro de San Francisco, 2016) : ne pas l'utiliser, ne jamais désérialiser des données non fiables.

9. Écoconception web (115 bonnes pratiques, F. Bordage)

Constat

70 % des fonctionnalités demandées ne sont pas essentielles, 45 % ne sont jamais utilisées. Outils : Ecoindex, GreenIT-analysis, websitecarbon.com.
BPÀ retenirTest
1 Fonctionnalités essentiellesMoSCoW, wireframes, YAGNI (You Ain't Gonna Need It)non vérifiées = 0 %
2 Quantifier le besoinsans précision : liste de 5 éléments ; Bing −80 % de serveurs ; vidéo 480p
3 Supprimer l'inutiliséfeature flipping ou suppression du code≤ 10 %
4 Mobile firstsinon chargement adaptatif (srcset, <picture>)
5 Parcours utilisateurle temps passé est le 2e poste d'impactfrictions = 0
9 Animationsse limiter à opacity et transform (GPU), prefers-reduced-motion≤ 2 / page
10 Carrouselslourds, peu accessibles≤ 1 / page
11 Titre + metadescription<title> et <h1> cohérents
14 Saisie assistéel'autocomplétion envoie une requête par caractère ; <datalist>≤ 20 %
16 / 17cache clé-valeur en RAM ; traiter au plus près de la donnée : procédures stockées
18 / 20pages statiques (bfcache : pagehide, rel="noopener") ; pages d'erreur statiquesdynamiques ≤ 25 %
24 Connexion BDDpool de connexions : HikariCP (Spring Boot)
28 / 29architecture modulaire ; version la plus récente du langage (JIT PHP 8)
30 Alternative textuelle30 min : vidéo ≈ 500 Mo, podcast ≈ 30 Mo, texte < 1 Mo
31-36CSS print ; polices système ; lien plutôt que document intégré ; CSS via <link media>, pas @importCSS ≤ 10
59 / 61 / 62liens de partage HTML ; valider au W3C ; cookies petits, Set-Cookie: x=; Max-Age=0
63 / 64 / 69TINYINT < SMALLINT < INT < BIGINT ; IndexedDB, localStorage ; thème CMS simpleextensions ≤ 10

10. Tes TPs en UML

Village du Père Noël : classe abstraite Personnage (italique) ; héritage à 3 niveaux Personnage ← Humanoide ← Lutin ← LutinFarceur ; Lutin extends Humanoide implements Travailleur, Divertissable, EtreFantastique ; Village ◆ Bâtiment (composition) ; Bâtiment ◇ Personnage (agrégation : le personnage change de bâtiment) ; PereNoel singleton (constructeur privé, attribut statique instance, getInstance() = fabrique statique) ; enum Proprete et Nourriture(valeurNutritive) + EnumMap ; template method accueillir() → peutAccueillir() ; pattern matching instanceof ; itérer sur une copie quand on modifie la liste.

TP2 threads : MyJobAlphabet et MyJobNumber implémentent Runnable (réalisation), new Thread(job).start(), affichage entrelacé non déterministe. TP6 : bulles sur DLinkedList en échangeant les éléments (pas les nœuds).

⚡ Fiche flash (veille et matin de l'examen)

Organisation

2 ressources, 2 notes : (TD/TP 0,5 + examen 0,5) × 2. StarUML, Eclipse, GitHub, Ametice.

Jour de dépassement

J = B/E × 365 (hectares globaux). Monde 2026 : 30 juillet. France 2026 : 24 avril (2023 : 5 mai).

Limites & chiffres

9 limites, 7 dépassées en 2026 (océans 2025). 4 % eGES = ×1,5 aérien ; 20 % énergie 2030 ; page ×155 ; 75 Md objets.

Écoconception

Qualité constante. Simplicité quali, Frugalité quanti, Pertinence = utilité × rapidité × accessibilité.

Exigences

F = services. NF = propriétés, contraintes, processus, parfois plus critiques. Complètes + consistantes : impossible.

IE

Élicitation, analyse, validation, gestion. Découverte → classification → priorisation → spécification. SRS.

Scénario & séquence

Départ, normal, anomalies, parallèle, final. Appel = plein, retour = pointillé, message reçu ⇒ méthode.

Relations UML

Généralisation plein ▷ vers la mère ; réalisation pointillé ▷ ; dépendance pointillé → ; ◇ partie survit ; ◆ partie meurt. Losange côté tout.

Multiplicités

1 · 0..1 · * = 0..* · 1..* · n..m, à l'autre bout. 0..1 ⇒ référence ; * ⇒ collection.

Grand O

1 < log n < n < n log n < n² < n³ < 2ⁿ < n!. 1 boucle n, 2 imbriquées n², ÷2 log n.

Listes & arbres

Simple : queue.next = null, pas d'index. Double : sentinelles sans élément, 4 pointeurs. Préfixe R-G-D, infixe G-R-D, postfixe G-D-R.

Hachage

Clés uniques. Liste O(n), hash O(1) moyen, collisions. hashCode puis mod N. N premier ou 2^k.

Tris

Bulles O(n²). Quicksort Hoare, Lomuto en place, moyen n log n, pire n² (liste triée). Binaire : trié, 2 arrêts, log n.

Effective Java

F1 fabrique · F6 Long · F7 fuites · F11 hashCode · F17 5 règles · F18 composition · F20 interfaces · F28 covariants · F34 enum · F52 compilation · F63 StringBuilder · F85 sérialisation.

115 BP

70 % / 45 % ; YAGNI ; liste 5 ; opacity/transform ; carrousel ≤ 1 ; saisie assistée ; procédures stockées ; HikariCP ; pas @import ; Max-Age=0.

Prêt pour le contrôle ?

Le parcours guidé reprend tout le cours en 11 étapes : l'essentiel, des cartes à réciter, des exercices interactifs (symboles UML, ordre des complexités, parcours d'arbre, partition du quicksort), des quiz corrigés, un examen blanc et ton carnet d'erreurs.

⏱ Temps moyen : 2 h · ta progression est enregistrée dans ce navigateur

Fiche établie à partir du CM de J.-P. Prost (199 slides) et des TPs de R3.02 / R3.03. En cas de doute, la version de l'enseignant fait foi pour l'examen.

🚀 Parcours