1. Erreurs lors de la déclaration d’une classe
Absence de modificateurs d’accès (package-private par défaut)
En Java, si vous n’indiquez pas explicitement un modificateur d’accès pour une classe, alors elle n’est accessible qu’à l’intérieur du paquet courant. Cela s’appelle package-private ou « accès par défaut ». Par exemple :
// Fichier Book.java
class Book {
String title;
}
Une telle classe ne peut pas être utilisée depuis un autre paquet. Si vous voulez que la classe soit accessible partout (et c’est le plus souvent ce qu’il faut pour les modèles principaux), utilisez le modificateur public :
public class Book {
String title;
}
Pourquoi est‑ce important ?
Si vous oubliez de mettre public, vous vous demanderez longtemps pourquoi une Library d’un autre paquet ne voit pas votre classe.
Non‑correspondance entre le nom de la classe et le nom du fichier
En Java, le nom du fichier contenant une classe doit correspondre au nom de la classe public à l’intérieur de ce fichier (en respectant la casse !). Par exemple :
// Fichier Book.java
public class Book {
// ...
}
Si vous nommez le fichier book.java (en minuscules) ou, pire encore, BooK.java, le compilateur lèvera une erreur. C’est l’une des raisons pour lesquelles l’IDE « ronchonne » quand vous avez renommé une classe mais oublié de renommer le fichier.
Erreurs de syntaxe de déclaration : accolades oubliées, mauvais emplacement des méthodes et des champs
Java est un langage strict. Si vous oubliez une accolade quelque part ou si vous déclarez par inadvertance une méthode à l’intérieur d’une autre (ce qui est interdit !), le compilateur vous rappellera immédiatement à l’ordre.
Mauvais exemple de déclaration :
public class User
String name; // Oups ! Accolades de classe manquantes
public void printName() {
System.out.println(name);
}
}
Bonne version :
public class User {
String name;
public void printName() {
System.out.println(name);
}
}
À retenir :
- Tous les champs et les méthodes ne se déclarent qu’à l’intérieur des accolades de la classe.
- Les méthodes ne peuvent pas être imbriquées les unes dans les autres (dans certains langages c’est possible, mais pas en Java !).
2. Erreurs lors de la création d’objets
Tentative d’utiliser un objet avant son initialisation (NullPointerException)
L’erreur la plus fréquente de tous les temps : tenter d’accéder à un objet qui n’a pas encore été créé. En Java, les variables de type référence valent par défaut null.
Exemple :
User user;
System.out.println(user.name); // NullPointerException!
Pourquoi ?
La variable user est déclarée mais non initialisée. En tentant d’accéder à un champ ou à une méthode, vous obtiendrez une NPE (NullPointerException).
Bonne approche :
User user = new User();
System.out.println(user.name); // Maintenant tout va bien (si le champ n’est pas null)
Erreurs lors de l’appel du constructeur (paramètres non concordants, absence de constructeur par défaut)
Si une classe ne possède qu’un constructeur avec paramètres, tenter de créer un objet sans paramètres provoquera une erreur de compilation.
public class Book {
String title;
public Book(String title) {
this.title = title;
}
}
Book book = new Book(); // Erreur ! Pas de constructeur sans paramètres
Solution : soit ajouter un constructeur sans paramètres, soit toujours passer les valeurs requises :
Book book = new Book("Java pour les nuls");
Création multiple d’objets au lieu de leur réutilisation
Parfois, les débutants créent un nouvel objet à chaque fois qu’ils en ont besoin, au lieu de réutiliser celui déjà créé.
Book book = new Book("Java pour les nuls");
System.out.println(book.title);
book = new Book("Java pour les nuls"); // Pourquoi ? Un tel objet existait déjà !
System.out.println(book.title);
Ce n’est pas une erreur de compilation, mais c’est un signe de mauvais style : vous perdez la référence vers l’ancien objet et gaspillez de la mémoire.
3. Bonnes pratiques : comment éviter les pièges
Indiquez toujours explicitement les modificateurs d’accès
Ne soyez pas paresseux : écrivez public, private ou protected — ce n’est pas seulement une question de sécurité, mais aussi de lisibilité du code. L’IDE vous le suggérera, bien sûr, mais il vaut mieux prendre l’habitude dès le départ.
Exemple :
public class User {
private String name;
// ...
}
Respectez les conventions de nommage des classes
- Le nom de la classe commence par une majuscule, style CamelCase : Book, LibraryUser, BookManager.
- Le nom du fichier correspond exactement au nom de la classe.
Utilisez des constructeurs pour initialiser les champs obligatoires
Si un objet possède des champs qui doivent impérativement être renseignés à la création, ajoutez un constructeur avec paramètres. Cela protège contre les erreurs au moment de l’utilisation.
Exemple :
public class User {
private String name;
public User(String name) {
this.name = name;
}
}
Il est désormais impossible de créer un User sans nom — le compilateur ne le permettra pas.
4. Mettons en pratique : construisons une mini‑application « Bibliothèque »
Continuons à développer notre application d’apprentissage. Supposons que nous ayons une classe Book et une classe Library qui gère les livres.
Exemple de déclaration correcte d’une classe
// Fichier Book.java
public class Book {
private String title;
private String author;
// Constructeur avec paramètres
public Book(String title, String author) {
this.title = title;
this.author = author;
}
// Getters
public String getTitle() {
return title;
}
public String getAuthor() {
return author;
}
}
Exemple de création correcte d’un objet
Book book = new Book("Java pour les nuls", "John Doe");
System.out.println(book.getTitle() + " - " + book.getAuthor());
Exemple de classe‑gestionnaire
// Fichier Library.java
import java.util.ArrayList;
public class Library {
private ArrayList<Book> books = new ArrayList<>();
public void addBook(Book book) {
books.add(book);
}
public void printAllBooks() {
for (Book book : books) {
System.out.println(book.getTitle() + " - " + book.getAuthor());
}
}
}
Utilisation dans main
public class Main {
public static void main(String[] args) {
Library library = new Library();
Book book1 = new Book("Java pour les nuls", "John Doe");
Book book2 = new Book("POO expliquée simplement", "John Smith");
library.addBook(book1);
library.addBook(book2);
library.printAllBooks();
}
}
5. Illustrations et schémas
Schéma : où déclarer quoi ?
+-----------------------------+
| Book.java |
|-----------------------------|
| public class Book { |
| private String title; | <--- champs (uniquement à l’intérieur de la classe)
| ... |
| public Book(...) {...} | <--- constructeur (dans la classe)
| public String getTitle()| <--- méthodes (dans la classe)
| } |
+-----------------------------+
+-----------------------------+
| Main.java |
|-----------------------------|
| public class Main { |
| public static void main |
| // Création d’objets|
| Book book = new Book|
| } |
+-----------------------------+
6. Analyse des erreurs typiques
Erreur 1 : non‑correspondance entre le nom de la classe et le fichier
// Fichier : Libraryuser.java
public class LibraryUser { // Nom de classe avec un « U » majuscule, fichier avec un « u » minuscule !
// ...
}
class LibraryUser is public, should be declared in a file named LibraryUser.java
Erreur 2 : tentative d’utiliser un objet non initialisé
Book book;
System.out.println(book.getTitle()); // NullPointerException!
Erreur 3 : accolades oubliées
public class Book
private String title; // Les champs sont généralement private pour l’encapsulation
// ...
}
';' expected
Erreur 4 : déclaration d’une méthode à l’intérieur d’une méthode
public class User {
public void printName() {
void sayHello() {
System.out.println("Hello!"); // On ne peut pas déclarer une méthode à l’intérieur d’une méthode !
}
}
}
illegal start of type
GO TO FULL VERSION