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).
| Chiffre | Valeur à connaître |
|---|---|
| Empreinte carbone du numérique mondial | ≈ 4 % des eGES = ×1,5 l'aérien mondial (GIEC 2022) |
| Prévision GIEC 2030 | numérique = 20 % de la consommation d'énergie mondiale |
| Transistors par processeur | 2 300 (1971) → 19+ milliards (2017) : ×10⁷ |
| Personnes connectées | 2 Md (2010) → 5 Md (2020) → 6 Md (2025) |
| Objets connectés | 1 Md (2010) → 75 Md (2025) |
| Poids d'une page web | 14 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.
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.
| Fonctionnelles | Non-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 |
|---|---|
| Vitesse | transactions/s, temps de réponse, rafraîchissement écran |
| Taille | Mo, nombre de puces ROM |
| Facilité d'utilisation | temps de formation, nombre d'écrans d'aide |
| Fiabilité | temps moyen d'échec, probabilité de non-disponibilité, taux d'échec, disponibilité |
| Robustesse | temps 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ément | Notation (cheatsheet) |
|---|---|
| Visibilité | + public · - private · # protected · ~ package |
| Classe abstraite / interface | nom en italique / «interface» IFoo |
| Inheritance (is-a) | trait plein + triangle vide |
| Implémentation | pointillés + triangle vide (la slide 60 l'appelle « Generalization ») |
| Association / two-way | trait ou flèche ouverte (A peut appeler B) / <——> |
| Dependency | flèche ouverte pointillée : « uses but is not a field » |
| Aggregation / Composition | losange vide (B survit) / losange plein (B ne peut exister sans A) |
| Cardinality / Note | 1..* / 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 :
| Relation | Symbole | Se lit | En Java |
|---|---|---|---|
| Dépendance | utilise temporairement | paramètre, variable locale, appel statique | |
| Association | connaît | attribut référence | |
| Navigable | connaît, dans un sens | seul A a un attribut vers B | |
| Agrégation | a / regroupe (partagé) | collection d'objets qui vivent sans le tout | |
| Composition | est composé de (exclusif) | le tout crée et détruit ses parties | |
| Généralisation | est un | extends | |
| Réalisation | respecte le contrat | implements |
À 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
| Type | Quand l'utiliser | Exemple |
|---|---|---|
| 1. Association simple | relation durable entre objets « égaux », parcourue dans les deux sens | Professeur ↔ Cours |
| 2. Navigable | un seul sens utile : moins de couplage (× côté source = non navigable) | Commande → Client |
| 3. Réflexive | classe liée à elle-même, rôles indispensables | chef / subordonné, DNode next/prev |
| 4. Classe d'association | la donnée appartient au lien (souvent * — *) | Inscription (note) entre Etudiant et Module |
| 5. Qualifiée | une clé sélectionne un objet, réduit * à 0..1 ; en Java une Map | Banque [numero] → Compte |
| 6. N-aire | losange vide central (≠ agrégation), rare | Professeur + 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 lui | Maison ◆ Pièce, Commande ◆ LigneCommande |
| 9. Généralisation | « B est une sorte de A » dans tous les cas (Liskov) ; sinon composition | Lutin → Personnage |
| 10. Réalisation | capacité transversale ; lollipop ○— possible | Lutin ⇢ Travailleur |
| 11. Dépendance | couplage 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 vite | Association | Agrégation ◇ | Composition ◆ |
|---|---|---|---|
| Tout / partie ? | Non | Oui (faible) | Oui (forte) |
| Partie partageable ? | — | Oui | Non |
| Partie survit au tout ? | Oui | Oui | Non |
| Multiplicité côté tout | libre | libre | 1 ou 0..1 |
| Qui crée la partie ? | n'importe qui | l'extérieur | le tout |
| Exemple | Personne — Voiture | Université ◇ Étudiant | Université ◆ 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 O | Nom | Reconnaître |
|---|---|---|
| O(1) | constante | accès direct |
| O(log n) | logarithmique | entrée divisée par 2 à chaque étape (recherche binaire) |
| O(n) | linéaire | une passe (countChars, recherche linéaire : n/2 tours en moyenne) |
| O(n log n) | log-linéaire | bons tris (quicksort moyen) |
| O(n²) / O(n³) | quadratique / cubique | 2 / 3 boucles imbriquées (intersection naïve) |
| O(2ⁿ) / O(n!) | exponentielle / factorielle | voyageur 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ègle | Résultat |
|---|---|---|
| Préfixe | racine d'abord (R, G, D) | F B A D C E G I H |
| Infixe | racine au milieu (G, R, D), binaire seulement | A B C D E F G H I |
| Postfixe | racine 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).
| Structure | Avantages | Inconvénients |
|---|---|---|
| Tableau | insertion rapide, accès très rapide par index | recherche et suppression lentes, taille fixe |
| Tableau trié | recherche plus rapide | insertion et suppression lentes |
| Pile / File | accès LIFO / FIFO | accès lent aux autres éléments |
| Liste chaînée | insertion et suppression rapides | recherche lente |
| Arbre binaire | tout rapide si équilibré | suppression complexe |
| Table de hachage | O(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) | classique | randomisé | médiane-de-3 | médiane-de-9 |
|---|---|---|---|---|
| aléatoire 1 000 000 | 245 ms | 256 ms | 254 ms | 347 ms |
| triée 10 000 | 142 ms | 0,94 ms | 0,52 ms | 1,5 ms |
| triée 50 000 | StackOverflow | 5,8 ms | 3,3 ms | 8,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 Builder | quand un constructeur a beaucoup de paramètres. |
| 6 Objets inutiles | new String("bikini") : NON. Long sum = 0L : autoboxing, un Long par tour, horriblement lent. |
| 7 Références obsolètes | le 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 equals | inutile si instances uniques, pas d'égalité logique, déjà fait par la superclasse, classe privée. |
| 11 hashCode | Toujours avec equals. Contrat : stable ; égaux ⇒ même hashCode (obligatoire) ; différents ⇒ distincts non requis. Sinon m.get(new PhoneNumber(…)) renvoie null. |
| 12 / 14 | toujours redéfinir toString ; Comparable : (compareTo == 0) == equals recommandé mais pas requis. |
| 15 / 16 | minimiser 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éritage | hériter d'une classe concrète d'un autre package viole l'encapsulation. |
| 20 Interfaces > classes abstraites | plusieurs interfaces possibles (pas d'héritage multiple), mixins, types non hiérarchiques. |
| 28 Listes > tableaux | tableaux 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 / 34 | types 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 / 50 | vérifier les paramètres (Objects.requireNonNull) ; copies défensives : copier avant de vérifier, vérifier sur les copies, méfiance avec clone. |
| 52 Surcharge | résolue à la compilation selon le type statique : classify affiche 3 fois « Collection inconnue ». La redéfinition est dynamique. |
| 57-59, 64 | porté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érialisation | trè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 | À retenir | Test |
|---|---|---|
| 1 Fonctionnalités essentielles | MoSCoW, wireframes, YAGNI (You Ain't Gonna Need It) | non vérifiées = 0 % |
| 2 Quantifier le besoin | sans 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 first | sinon chargement adaptatif (srcset, <picture>) | |
| 5 Parcours utilisateur | le temps passé est le 2e poste d'impact | frictions = 0 |
| 9 Animations | se limiter à opacity et transform (GPU), prefers-reduced-motion | ≤ 2 / page |
| 10 Carrousels | lourds, peu accessibles | ≤ 1 / page |
| 11 Titre + metadescription | <title> et <h1> cohérents | |
| 14 Saisie assistée | l'autocomplétion envoie une requête par caractère ; <datalist> | ≤ 20 % |
| 16 / 17 | cache clé-valeur en RAM ; traiter au plus près de la donnée : procédures stockées | |
| 18 / 20 | pages statiques (bfcache : pagehide, rel="noopener") ; pages d'erreur statiques | dynamiques ≤ 25 % |
| 24 Connexion BDD | pool de connexions : HikariCP (Spring Boot) | |
| 28 / 29 | architecture modulaire ; version la plus récente du langage (JIT PHP 8) | |
| 30 Alternative textuelle | 30 min : vidéo ≈ 500 Mo, podcast ≈ 30 Mo, texte < 1 Mo | |
| 31-36 | CSS print ; polices système ; lien plutôt que document intégré ; CSS via <link media>, pas @import | CSS ≤ 10 |
| 59 / 61 / 62 | liens de partage HTML ; valider au W3C ; cookies petits, Set-Cookie: x=; Max-Age=0 | |
| 63 / 64 / 69 | TINYINT < SMALLINT < INT < BIGINT ; IndexedDB, localStorage ; thème CMS simple | extensions ≤ 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.