Définitions à savoir formuler, et bugs conceptuels à repérer.
L'épreuve : pas de code à écrire. Deux types de questions — donner des définitions et trouver des bugs. Les bugs portent sur des erreurs de raisonnement (concepts), pas sur la syntaxe pure (point-virgule, accolades).
.java est compilé en bytecode .class par javac, puis exécuté par la JVM. D'où la portabilité : le même bytecode tourne sur toute plateforme avec une JVM.javac (compilateur), java (interpréteur), jdb (débogueur), javadoc (doc).new.byte (8 bits), short (16), int (32), long (64) ; réels float (32), double (64) ; boolean ; char (1 caractère Unicode, 16 bits).null = aucun objet.new), lue via .length.java.util) : liste à taille dynamique. Méthodes : add(o) (ajoute à la fin), get(i) (élément à l'indice), remove(i) (supprime à l'indice), contains(o), isEmpty(), removeAll(...), size() (nombre d'éléments).addElement au lieu de add, elementAt(i) au lieu de get(i) ; garde size().ArrayList, LinkedList, Vector) · Set (pas de doublons → HashSet) · Map (clé/valeur → HashMap).staticstatic) : associée à la classe, pas aux instances → un seul exemplaire, partagé par toutes les instances.static) : associée à la classe → appelable sans créer d'objet.static par le nom de la classe : Math.PI, Math.sqrt(3.6), MaClasse.maMethode().static n'a pas de this → elle ne peut pas toucher un membre d'instance sans passer par un objet.static : un seul exemplaire dans la classe, partagé. « nom » ne l'est pas : un par objet.Le reste des membres : Constructeur (appelé automatiquement à la création, même nom que la classe, aucun type de retour ; this(...) appelle un autre constructeur). Destructeur finalize(). Garbage collector (détruit un objet sans référence). this = l'instance courante ; super = la classe parente.
@Override).extends ; pas d'héritage multiple. Toute classe hérite de java.lang.Object (equals, toString).== vs .equals() : == compare les références ; .equals() compare le contenu (pour String : equals / equalsIgnoreCase).abstract : méthode sans implémentation → classe non instanciable. final : classe non dérivable · méthode non redéfinissable · variable = constante.interface + implements ; que des constantes et signatures publiques ; depuis Java 8, méthodes default et static. Une classe s'engage à définir toutes les méthodes (contrat) et peut en implémenter plusieurs.import pour utiliser un package ; java.lang est implicite. Les 4 visibilités :
| Modificateur | Classe | Même package | Sous-classe | Ailleurs |
|---|---|---|---|---|
private | oui | non | non | non |
| aucun (package) | oui | oui | non | non |
protected | oui | oui | oui | non |
public | oui | oui | oui | oui |
int n = (int) x; (perd les décimales).Integer.parseInt("123"), Double.parseDouble("1.5") → lèvent une exception si invalide.String.valueOf(...), Integer.toString(...).Object → Throwable → (Error | Exception) ; RuntimeException est une sous-classe d'Exception.Exception mais pas de RuntimeException → traitement (try/catch ou throws) obligatoire.try / catch / finally ; throw (déclenche) vs throws (déclare) ; ordre des catch du plus précis au plus général ; exception perso = classe qui hérite d'Exception.Des codes qui ont l'air corrects mais appliquent mal une notion.
class Animal { public void seReproduire() { System.out.println("Animal"); } }
class Mammifere extends Animal {
public void seReproduire(String mode) { ... } // signature DIFFÉRENTE
}
// Mammifere.seReproduire() affiche "Animal" : on a SURCHARGÉ, pas REDÉFINI.Pour redéfinir, exactement la même signature. @Override aurait fait échouer la compilation.
private de la mèreclass Animal { private int poids; }
class Chat extends Animal {
void afficher() { System.out.println(poids); } // poids est private → invisible
}Mettre l'attribut en protected, ou passer par un getter.
class Animal { Animal(int poids) { } } // seul constructeur, avec paramètre
class Chat extends Animal { Chat() { } } // super() implicite cherche Animal() — absent
// ✅ Chat() { super(0); }Appeler explicitement super(...).
super(...) n'est pas la première instructionChat(String nom, int poids) {
this.nom = nom;
super(poids); // super(...) doit être la TOUTE première instruction
}abstract class Animal { abstract void deplacement(); }
class Felin extends Animal { } // ne définit pas deplacement() → doit l'implémenter
Animal a = new Animal(); // on ne peut pas instancier une classe abstraitefinalclass Animal { public final void dormir() { } }
class Chat extends Animal { public void dormir() { } } // dormir() est final → interdit== au lieu de .equals() sur des objetsRectangle r1 = new Rectangle(10, 20);
Rectangle r3 = new Rectangle(10, 20);
if (r1 == r3) ... // false : deux objets distincts en mémoire
if (r1.equals(r3)) ... // true si equals compare le contenuclass Camionnette extends Camion, Automobile { } // interdit en Java
class Camionnette extends Camion implements ComportementAuto { } // ✅ une classe + des interfacesFil rouge héritage : redéfinition vs surcharge · visibilité héritée (private/protected) · chaînage des constructeurs (super) · abstract/final · référence vs contenu.
ArrayList et tableauliste.length // length = TABLEAUX
liste[0] // crochets = tableaux
liste.size() // ✅ taille d'une ArrayList
liste.get(0) // ✅ accès à un élémentTableau = taille fixe (.length) ; ArrayList = taille dynamique (.size()).
remove(int) supprime par INDICE, pas par valeurArrayList<Integer> liste = new ArrayList<>();
liste.add(10); liste.add(20); liste.add(30);
liste.remove(2); // supprime l'élément à l'INDICE 2 (donc 30), pas la valeur 2for (int i = 0; i < liste.size(); i++) {
if (...) liste.remove(i); // après remove, tout se décale → on saute un élément
}IndexOutOfBoundsExceptionArrayList<String> l = new ArrayList<>(); // l.size() == 0
l.get(0); // exception : aucun élémentArrayList<int> liste; // pas de primitif dans les generics
ArrayList<Integer> liste; // ✅ classe enveloppe (Integer, Double…)static depuis mainpublic class Test {
int x = 5;
void afficher() { ... }
public static void main(String[] a) {
afficher(); // main est static : pas d'objet "courant"
Test t = new Test();
t.afficher(); // ✅ via une instance
}
}public void setPourcent(int effectue, int total) {
pourcent = total / effectue; // int/int = division ENTIÈRE (3/2 donne 1)
}
pourcent = (float) effectue / total * 100; // ✅ forcer le flottantNullPointerExceptionString s = null;
int n = s.length(); // NullPointerException à l'exécution
if (s != null) n = s.length(); // ✅switch sans breakswitch (note) {
case 1: System.out.print("un"); // pas de break → continue sur case 2
case 2: System.out.print("deux");
}catch : général avant préciscatch (Exception e) { ... } // attrape tout en premier
catch (NumberFormatException e) {...} // → ce bloc devient inatteignable
// ✅ le plus précis d'abordsuper(...) en premier ? constructeur parent appelé ?private touché de l'extérieur ou depuis une fille ?static (ex. main) ?final ?== vs .equals() (référence vs contenu) ?.length vs .size() ? remove par indice ? indice hors bornes ? suppression en cours de parcours ?int/int ? risque de NullPointerException ?catch (précis avant général) ?D'après le cours « Java POO » 2025-2026 (N. Faye). Fiche de révision personnelle.