Classes et Objets en Java
Sommaire
- 1- Objectifs
- 2- Introduction :
- 3- Concepts Fondamentaux
- 4- Structure Générale d'une Classe Java
- 5- Déclaration et Instanciation d'une Classe en Java
- 6- Les constructeurs en Java
- 6.1- Constructeur Non Paramétré
- 6.2- Constructeur Paramétré
- 7- Création d'Instances de Classes en Java
- 8- Les Méthodes en Java
- 8.1- Introduction
- 8.2- Classification des méthodes
- 8.2.1- Les fonctions de création
- 8.2.2- Les méthodes d'accès et de modification
- 8.3- Exemple de Méthodes
- 8.4- Allocation des Méthodes
- 8.5- Type de Retour des Méthodes
- 8.6- Méthodes static vs non-static
- 9- Exemples Pratiques
- 9.1- Exemple 1 : Classe Voiture
- 9.2- Exemple 2 : Classe Étudiant
- 10- Applications
- 10.1- Application 1 : Refactorisation avec Classe Personne
- 10.2- Application 2 : Classe Étudiant
- 10.3- Application 3 : Classe Voiture
- 10.4- Application 4 : Classe Book
- 10.5- Application 5 : Classe Vehicule
- 10.6- Application 6 : Classe Liquide
- 10.6.1- Cours JAVA
Classes et Objets en Java
-
Objectifs
- Comprendre le concept fondamental d’objets en programmation orientée objet (POO) et comment il se distingue d’autres paradigmes de programmation.
- Apprendre à créer des classes en Java, incluant la définition de propriétés et de méthodes, ainsi que la gestion de la visibilité des membres (public, privé, protégé).
-
Introduction :
- La programmation orientée objet (POO) est un paradigme de programmation basé sur le concept d’objets, qui contiennent à la fois des données et des méthodes pour manipuler ces données. En Java, les classes et les objets sont les éléments fondamentaux de ce paradigme.
-
Concepts Fondamentaux
- Les classes
- Classe : Une classe est un modèle ou un plan pour créer des objets. Elle définit des attributs (ou propriétés) et des comportements (ou méthodes) que les objets créés à partir de cette classe peuvent avoir.
- Les objets
- Objet : Un objet est une instance d’une classe. Chaque objet a ses propres valeurs pour les attributs définis dans la classe.
-
Structure Générale d’une Classe Java
- Une classe Java typique comprend les éléments suivants :
Champs (Attributs)
: Les variables qui définissent l’état de l’objet.Constructeur
: La méthode qui est appelée lors de la création d’une nouvelle instance.Méthodes
: Les fonctions qui définissent le comportement de l’objet.-
Déclaration et Instanciation d’une Classe en Java
- Les classes en Java sont déclarées à l’aide du mot-clé class. Voici un exemple de déclaration simple :
- Déclaration de la classe : Le mot-clé class est suivi du nom de la classe (Personne dans cet exemple).
- Attributs : Les variables nom et age sont les attributs de la classe Personne.
- Constructeur : Le constructeur est une méthode spéciale qui initialise les objets lors de leur création.
- Méthodes : Les méthodes définissent les comportements que les objets peuvent exécuter.
-
Les constructeurs en Java
- En Java, un constructeur est une méthode spéciale utilisée pour initialiser les objets. Il porte le même nom que la classe et peut être paramétré ou non paramétré.
- En Java, un constructeur est une méthode spéciale utilisée pour initialiser les objets. Il porte le même nom que la classe et peut être paramétré ou non paramétré.
- Java propose des méthodes particulières qui ont comme rôle d’initialiser les attributs, ce sont les constructeurs.
- Un constructeur est appelé automatiquement au moment au moment de la création de l’objet à l’aide de l’opérateur
new
. - Les constructeurs ont une signature particulière. Ils portent le nom de la classe. Ils ne retourne rien, pas même
void
. - Chaque objet de la classe Produit sera instancié en utilisant le constructeur.
- On peut écrire plusieurs constructeurs pour une classe.
- Il existe des Constructeurs paramétrés et des constructeurs non parametrés.
-
Constructeur Non Paramétré
- Un constructeur non paramétré n’accepte pas d’arguments et initialise généralement les membres de la classe avec des valeurs par défaut.
-
Constructeur Paramétré
- Un constructeur paramétré accepte des arguments qui permettent d’initialiser les membres de la classe avec des valeurs spécifiques au moment de la création de l’objet.
- Le mécanisme permettant de définir plusieurs méthodes ayant le même nom (mais pas la même signature) s’appelle une surcharge.
- Le mécanisme de 1 surcharge s’inscrit dans un concept plus général, celui de polymorphisme.
- Le langage appellera le constructeur correspondant aux arguments passés au moment de l’appel.
- Remarque: Il est fortement conseiller de toujours fournir au moins un constructeur à chaque classe.
-
Création d’Instances de Classes en Java
- Un objet peut être vu comme un ensemble de données regroupées à la manière des structures de C ou des enregistrements de Pascal. Une classe définit un modèle d’objet. Chaque objet créé à partir d’une classe est appelé instance de cette classe.
- L’ensemble de données internes d’un objet – les champs de cet objet – est spécifié par sa classe. Une classe peut en outre contenir : d’une part, des constructeurs – du code destiné à l’initialisation de ses instances au moment de leur création ; d’autre part des méthodes – du code destiné à la gestion des données internes de chacune de ses instances.
- Une fois qu’une classe est définie, vous pouvez créer des objets de cette classe :
- Dans cet exemple, personne1 et personne2 sont des instances de la classe Personne. Nous les avons initialisées avec des valeurs spécifiques pour nom et age, puis nous avons appelé la méthode sePresenter() sur chacune d’elles.
-
Les Méthodes en Java
-
Introduction
- Les méthodes sont chargées d’effectuer des opérations, souvent en manipulant des données. Elles peuvent avoir différents niveaux de visibilité : public, private, ou protected. Les méthodes déclarées comme public forment l’interface de la classe, c’est-à-dire la partie de la classe accessible à l’extérieur.
-
Classification des méthodes
- Selon leur fonctionnalité, les méthodes peuvent être divisées en trois groupes principaux :
-
Les fonctions de création
- Ces méthodes, qui servent à instancier des objets, seront étudiées plus en détail plus tard.
-
Les méthodes d’accès et de modification
-
Exemple de Méthodes
- Remarque : L’utilisation du mot-clé this permet de faire référence à l’objet courant, ce qui améliore la lisibilité du code, bien que cela ne soit pas toujours nécessaire.
-
Allocation des Méthodes
- Méthode d’instance : Lorsqu’une méthode est associée à un objet spécifique, elle est appelée méthode d’instance. Ces méthodes ne portent aucun mot-clé spécifique.
- Méthode de classe (static) : Une méthode déclarée avec le mot-clé static appartient à la classe elle-même, plutôt qu’à une instance spécifique. Elle ne peut interagir qu’avec des attributs ou d’autres méthodes également static.
-
Type de Retour des Méthodes
- Sans type de retour : Un constructeur n’a pas de type de retour explicite.
- void : La méthode ne retourne aucune valeur (procédure).
- Type primitif : La méthode retourne une valeur d’un type primitif (int, double, etc.).
- Classe : La méthode retourne une référence à un objet d’une classe spécifique.
-
Méthodes static vs non-static
- Méthode static : Peut être utilisée sans créer une instance de la classe. Par exemple :
-
Exemples Pratiques
-
Exemple 1 : Classe Voiture
-
Exemple 2 : Classe Étudiant
-
Applications
-
Application 1 : Refactorisation avec Classe Personne
- Refactorisez le code suivant pour utiliser une classe Person :
-
Application 2 : Classe Étudiant
- Déclarez une classe Etudiant en Java avec les propriétés nom, age, note et une méthode afficherInfo() pour afficher les informations.
-
Application 3 : Classe Voiture
- Déclarez une classe Voiture en Java avec les propriétés marque, modele, annee, vitesse, et une méthode accelerer(double augmentation).
-
Application 4 : Classe Book
- Déclarez une classe Book en Java avec les propriétés title, author, pageCount et une méthode printInfo().
-
Application 5 : Classe Vehicule
- Créez une classe Vehicule et une classe VoitureComposee pour explorer la composition d’objets en Java.
-
Application 6 : Classe Liquide
- Créez des classes dérivées de Liquide pour comprendre l’héritage en Java.
class NomDeLaClasse {
// Champs (Attributs)
TypeNomAttribut1;
TypeNomAttribut2;
// Constructeur
NomDeLaClasse(Type param1, Type param2) {
// Initialisation des attributs
}
// Méthodes
void methode1() {
// Corps de la méthode
}
Type methode2(Type param) {
// Corps de la méthode
return valeur;
}
}
class Personne {
// Déclaration des attributs
String nom;
int age;
// Constructeur
Personne(String nom, int age) {
this.nom = nom;
this.age = age;
}
// Méthode
void sePresenter() {
System.out.println("Je m'appelle " + nom + " et j'ai " + age + " ans.");
}
}
Exemple:
public Produit( String I, int p, int q)
{
this.Libelle = I;
this.Prix = p ;
this.QtStock = q;
}
Personne p1 = new Personne(); // Appel du constructeur non paramétré
Personne p2 = new Personne("Alice", 25); // Appel du constructeur paramétré
Exemple:
Produit p = new Produit( );
{
// appel du constructeur par défaut.
Produit pl = new Produit("scie",50, 10);
//appel du constructeur à trois arguments
}
public class Main {
public static void main(String[] args) {
// Création d'une instance de la classe Personne
Personne personne1 = new Personne("Alice", 25);
Personne personne2 = new Personne("Bob", 30);
// Appel de la méthode sur les objets
personne1.sePresenter();
personne2.sePresenter();
}
}
-
Méthodes d’accès (Getters) : Elles fournissent l’état d’un objet sans le modifier, généralement préfixées par « get ».
Méthodes de modification (Setters) : Elles permettent de modifier l’état d’un objet, généralement préfixées par « set ».
public String getLibelle() {
return this.libelle;
}
public void setStock(int stock) {
this.qtStock = stock;
}
double racineDeDeux = Math.sqrt(2);
class Voiture {
String marque;
String couleur;
void conduire() {
System.out.println("La voiture roule");
}
void freiner() {
System.out.println("Le frein a été appliqué");
}
}
public class Main {
public static void main(String[] args) {
Voiture voiture1 = new Voiture();
voiture1.marque = "Mazda";
voiture1.couleur = "Blanche";
System.out.println("Marque: " + voiture1.marque + ", Couleur: " + voiture1.couleur);
voiture1.conduire();
}
}
class Etudiant {
String nom;
int age;
int matricule;
void afficherInfo() {
System.out.println("Nom: " + nom + ", Age: " + age + ", Matricule: " + matricule);
}
}
public class Main {
public static void main(String[] args) {
Etudiant etudiant1 = new Etudiant();
etudiant1.nom = "Emma";
etudiant1.age = 21;
etudiant1.matricule = 12345;
etudiant1.afficherInfo();
}
}
// Code avant refactorisation
public class Main {
public static void main(String[] args) {
final Map person = new HashMap<>();
person.put("name", "Mohamed");
person.put("age", 36);
person.put("height", 1.84);
System.out.println("Je m'appelle " + person.get("name") + ". J'ai " + person.get("age") + " ans, je mesure " + person.get("height") + " mètres.");
}
}
Solution : Créez une classe Person qui contient les attributs name, age, et height, avec une méthode printDescription().
Code
public class Etudiant {
// Propriétés de la classe
private String nom;
private int age;
private double note;
// Constructeur paramétré pour initialiser les propriétés
public Etudiant(String nom, int age, double note) {
this.nom = nom;
this.age = age;
this.note = note;
}
// Méthode pour afficher les informations de l'étudiant
public void afficherInfo() {
System.out.println("Nom : " + nom);
System.out.println("Âge : " + age + " ans");
System.out.println("Note : " + note);
}
// Méthode main pour tester la classe
public static void main(String[] args) {
// Création d'un objet Etudiant
Etudiant etudiant1 = new Etudiant("Alice", 20, 15.5);
// Affichage des informations de l'étudiant
etudiant1.afficherInfo();
}
}
Code
public class Voiture {
// Propriétés de la classe
private String marque;
private String modele;
private int annee;
private double vitesse;
// Constructeur paramétré pour initialiser les propriétés
public Voiture(String marque, String modele, int annee, double vitesse) {
this.marque = marque;
this.modele = modele;
this.annee = annee;
this.vitesse = vitesse;
}
// Méthode pour accélérer la voiture
public void accelerer(double augmentation) {
this.vitesse += augmentation;
System.out.println("La vitesse actuelle est de " + this.vitesse + " km/h");
}
// Méthode main pour tester la classe
public static void main(String[] args) {
// Création d'un objet Voiture
Voiture voiture1 = new Voiture("Toyota", "Corolla", 2020, 100.0);
// Affichage de la vitesse initiale
System.out.println("Vitesse initiale : " + voiture1.vitesse + " km/h");
// Accélération de la voiture
voiture1.accelerer(20.0);
}
}
Code
public class Book {
// Propriétés de la classe
private String title;
private String author;
private int pageCount;
// Constructeur paramétré pour initialiser les propriétés
public Book(String title, String author, int pageCount) {
this.title = title;
this.author = author;
this.pageCount = pageCount;
}
// Méthode pour afficher les informations du livre
public void printInfo() {
System.out.println("Title: " + this.title);
System.out.println("Author: " + this.author);
System.out.println("Page Count: " + this.pageCount);
}
// Méthode main pour tester la classe
public static void main(String[] args) {
// Création d'un objet Book
Book book1 = new Book("1984", "George Orwell", 328);
// Affichage des informations du livre
book1.printInfo();
}
}
Code
Classe Vehicule
public class Vehicule {
// Propriétés de la classe Vehicule
private String marque;
private String modele;
private int annee;
// Constructeur pour initialiser les propriétés
public Vehicule(String marque, String modele, int annee) {
this.marque = marque;
this.modele = modele;
this.annee = annee;
}
// Méthode pour afficher les informations du véhicule
public void afficherInfoVehicule() {
System.out.println("Marque: " + marque);
System.out.println("Modèle: " + modele);
System.out.println("Année: " + annee);
}
// Getters pour accéder aux propriétés si nécessaire
public String getMarque() {
return marque;
}
public String getModele() {
return modele;
}
public int getAnnee() {
return annee;
}
}
Classe VoitureComposee
public class VoitureComposee {
// Propriété pour composer la classe VoitureComposee avec un objet Vehicule
private Vehicule vehicule;
private double vitesse;
// Constructeur pour initialiser les propriétés
public VoitureComposee(String marque, String modele, int annee, double vitesse) {
// Composition d'un objet Vehicule
this.vehicule = new Vehicule(marque, modele, annee);
this.vitesse = vitesse;
}
// Méthode pour accélérer la vitesse
public void accelerer(double augmentation) {
this.vitesse += augmentation;
System.out.println("Nouvelle vitesse: " + vitesse + " km/h");
}
// Méthode pour afficher les informations complètes de la voiture
public void afficherInfoVoiture() {
vehicule.afficherInfoVehicule();
System.out.println("Vitesse actuelle: " + vitesse + " km/h");
}
// Méthode main pour tester la classe
public static void main(String[] args) {
// Création d'un objet VoitureComposee
VoitureComposee voiture = new VoitureComposee("Toyota", "Corolla", 2020, 120);
// Affichage des informations de la voiture
voiture.afficherInfoVoiture();
// Accélération de la voiture
voiture.accelerer(30);
}
}
Code
Classe de base Liquide
public class Liquide {
// Propriétés de la classe Liquide
private String couleur;
private double volume; // en litres
// Constructeur pour initialiser les propriétés
public Liquide(String couleur, double volume) {
this.couleur = couleur;
this.volume = volume;
}
// Méthode pour afficher les informations du liquide
public void afficherInfo() {
System.out.println("Couleur: " + couleur);
System.out.println("Volume: " + volume + " litres");
}
// Getters pour accéder aux propriétés
public String getCouleur() {
return couleur;
}
public double getVolume() {
return volume;
}
}
Classe dérivée Eau
public class Eau extends Liquide {
// Propriété supplémentaire spécifique à l'eau
private boolean estMinerale;
// Constructeur pour initialiser les propriétés de Eau
public Eau(double volume, boolean estMinerale) {
super("Transparente", volume); // Appelle le constructeur de la classe parente Liquide
this.estMinerale = estMinerale;
}
// Méthode pour afficher les informations de l'eau
@Override
public void afficherInfo() {
super.afficherInfo(); // Appelle la méthode afficherInfo() de la classe parente
System.out.println("Est minérale: " + (estMinerale ? "Oui" : "Non"));
}
}
Classe dérivée Jus
public class Jus extends Liquide {
// Propriété supplémentaire spécifique au jus
private String fruit;
// Constructeur pour initialiser les propriétés de Jus
public Jus(String couleur, double volume, String fruit) {
super(couleur, volume); // Appelle le constructeur de la classe parente Liquide
this.fruit = fruit;
}
// Méthode pour afficher les informations du jus
@Override
public void afficherInfo() {
super.afficherInfo(); // Appelle la méthode afficherInfo() de la classe parente
System.out.println("Fruit: " + fruit);
}
}
Méthode main() pour tester les classes
public class Main {
public static void main(String[] args) {
// Création d'un objet Eau
Eau eau = new Eau(1.5, true);
System.out.println("Informations sur l'eau:");
eau.afficherInfo();
System.out.println();
// Création d'un objet Jus
Jus jus = new Jus("Orange", 0.5, "Orange");
System.out.println("Informations sur le jus:");
jus.afficherInfo();
}
}