1. Qu'est-ce qu'une classe et un objet
Commençons par une analogie. Imaginez le plan d'une voiture. Le plan indique que la voiture a quatre roues, un moteur, une couleur, des sièges, etc. Mais le plan, en lui-même, ne roule pas sur les routes, ne fait pas de bruit de moteur et ne consomme pas d'essence. Ce n'est qu'une description de la façon dont la voiture est conçue.
Une classe en programmation est un « plan » (ou modèle) qui définit quelles données (champs) et quelles actions (méthodes) auront ses instances.
Un objet, c'est la « véritable » voiture assemblée selon ce plan, l'instance concrète. Chaque objet a son propre état (par exemple, une voiture est rouge, une autre — bleue) et un comportement : chaque objet peut effectuer les actions définies dans la classe (par exemple, rouler, freiner, klaxonner).
Exemples de la vie courante
- Classe : Person (Person) — description indiquant qu'une personne a un nom, un âge, une taille et qu'elle peut parler ou courir.
- Objets : John, Peter, Kate — des personnes concrètes, chacune avec son propre nom et âge.
| Classe | Objet 1 | Objet 2 |
|---|---|---|
|
|
|
Pourquoi les classes sont importantes ?
- Regrouper des variables et des méthodes liées.
- Créer autant d'objets que nécessaire avec la même structure mais des données différentes.
- Décrire facilement des entités complexes : par exemple, « Compte bancaire », « Produit », « Livre », « Utilisateur ».
2. Syntaxe de déclaration d'une classe
En Java, une classe se déclare à l'aide du mot-clé class. Il est suivi du nom de la classe (traditionnellement avec une majuscule), puis d'accolades à l'intérieur desquelles on écrit les champs et les méthodes.
Exemple le plus simple
public class Person {
// Ici, il y aura des champs et des méthodes
}
Explication :
- public — modificateur d'accès.
- class — indique au compilateur « j'annonce une classe ».
- Person — nom de la classe (vous le choisissez, mais avec une majuscule).
Règles importantes de nommage des classes
- Le nom d'une classe doit commencer par une majuscule (par exemple, Car, Account, Book).
- Le nom d'une classe ne doit pas contenir d'espaces ni de caractères spéciaux, à l'exception du tiret bas et de $ (mais c'est rare).
- Si le nom comporte plusieurs mots, utilisez le style CamelCase : BankAccount, BookStore.
Où écrire les classes ?
Une classe peut être déclarée dans un fichier séparé (c'est généralement le cas : un fichier — une classe) ou à l'intérieur d'une autre classe (nous parlerons des classes imbriquées plus tard).
Par exemple, le fichier Person.java :
public class Person {
// champs et méthodes
}
3. Champs et méthodes d'une classe (en bref)
Pour l'instant, nous n'avons fait que déclarer une classe, mais elle est vide — comme une boîte sans contenu. Ajoutons-y des « propriétés » (champs) et des « actions » (méthodes).
Champs (variables à l'intérieur de la classe)
Les champs décrivent les données que possédera chaque objet de cette classe.
public class Person {
String name; // nom de la personne
int age; // âge
}
Méthodes (fonctions à l'intérieur de la classe)
Les méthodes décrivent ce que sait faire l'objet.
public class Person {
String name;
int age;
void sayHello() {
System.out.println("Bonjour, je m'appelle " + name + " !");
}
}
Explication :
- void — la méthode ne renvoie rien (nous parlerons des valeurs de retour plus tard).
- sayHello() — nom de la méthode, les parenthèses sont obligatoires.
- À l'intérieur de la méthode, on peut accéder aux champs de la classe (par exemple, à name).
4. Création d'un objet
Et maintenant — de la magie ! Comment transformer le plan en « véritable voiture » ? On utilise pour cela le mot-clé new.
Syntaxe de création d'un objet
Person john = new Person();
- Person — type de la variable (notre classe).
- john — nom de la variable (vous pouvez en choisir n'importe lequel).
- new Person() — création d'un nouvel objet de type Person.
Nous avons maintenant une variable john qui fait référence à un objet de la classe Person. Cet objet possède ses propres champs et méthodes.
Accès aux champs et aux méthodes
On accède aux champs et aux méthodes avec un point :
john.name = "John";
john.age = 25;
john.sayHello(); // Affichera: Bonjour, je m'appelle John !
Vous pouvez créer autant d'objets que vous voulez
Person peter = new Person();
peter.name = "Peter";
peter.age = 30;
peter.sayHello(); // Bonjour, je m'appelle Peter !
Chaque objet est une « copie » indépendante avec ses propres données.
5. Lien avec les thèmes précédents
Jusqu'à aujourd'hui, nous déclarions toutes les variables et méthodes directement dans la classe avec la méthode main sans réfléchir à la création de nos propres types. Désormais, nous pouvons créer nos propres « conteneurs » de données et de fonctions.
Cela ouvre d'énormes possibilités ! Vous pouvez maintenant décrire n'importe quelles entités qui se présentent dans votre problème : clients, produits, comptes, commandes, animaux, voitures — tout ce que vous voulez. Les programmes deviennent plus structurés, plus lisibles et plus évolutifs.
Exemple : notre première classe à nous
Écrivons une classe simple pour notre mini-programme — disons, « Compte bancaire » (BankAccount). Nous ferons évoluer cet exemple au fil du cours.
public class BankAccount {
String owner; // propriétaire du compte
int balance; // solde du compte
void printInfo() {
System.out.println("Propriétaire: " + owner + ", solde: " + balance + " euros.");
}
}
Dans la méthode principale main (qui est toujours nécessaire pour lancer le programme), nous pouvons maintenant créer des objets de cette classe :
public class Main {
public static void main(String[] args) {
BankAccount account1 = new BankAccount();
account1.owner = "John";
account1.balance = 1000;
account1.printInfo(); // Propriétaire: John, solde: 1000 euros.
BankAccount account2 = new BankAccount();
account2.owner = "Maria";
account2.balance = 2000;
account2.printInfo(); // Propriétaire: Maria, solde: 2000 euros.
}
}
Remarque : chaque objet possède ses propres valeurs de champs. Si vous modifiez le solde de account1, cela n'affectera en rien account2.
Schéma visuel : classe et objets
graph TD
subgraph Class
Person["Class Person | name:String | age:int | sayHello()"]
end
subgraph Objects
john["john : Person | name = 'John' | age = 20"]
peter["peter : Person | name = 'Peter' | age = 25"]
end
john --> Person
peter --> Person
Explication :
- Person — c'est la classe (le modèle).
- john et peter — ce sont des objets (instances) créés à partir de ce modèle.
6. Erreurs typiques lors de la déclaration de classes et de la création d'objets
Erreur n° 1 : nom de classe commençant par une minuscule.
En Java, il est d'usage (le compilateur ne se plaint pas, mais tous les développeurs expérimentés oui !) de nommer les classes avec une majuscule. N'écrivez pas class person — écrivez class Person.
Erreur n° 2 : absence d'accolades.
N'oubliez pas que le corps de la classe doit toujours être entouré d'accolades.
public class Person // erreur !
String name;
Correct :
public class Person {
String name;
}
Erreur n° 3 : tentative d'accéder aux champs et aux méthodes de la classe sans créer d'objet.
Si une méthode ou un champ n'est pas déclaré static, on ne peut y accéder qu'au travers d'un objet :
Person.sayHello(); // erreur !
Correct :
Person john = new Person();
john.sayHello();
Erreur n° 4 : non-correspondance entre le nom de fichier et le nom de la classe (pour une classe public).
Si une classe est déclarée public, le nom du fichier doit correspondre au nom de la classe :
// Fichier Person.java
public class Person { ... }
Si le fichier porte un autre nom, le compilateur signalera une erreur.
Erreur n° 5 : utilisation de champs sans initialiser d'objet.
Les champs (non static) appartiennent à l'objet, et non à la classe elle-même.
GO TO FULL VERSION