Découvrir les Class
Les class
En Java, une classe est un modèle ou un plan à partir duquel des objets sont créés. Une classe est essentiellement un ensemble de propriétés (variables) et de comportements (méthodes) que tous les objets de cette classe partagent.
Voici comment définir une classe en Java :
public class NomDeLaClasse {
// variables d'instance
type variable1;
type variable2;
// constructeur
public NomDeLaClasse(type variable1, type variable2) {
this.variable1 = variable1;
this.variable2 = variable2;
}
// méthodes
public type getVariable1() {
return this.variable1;
}
public void setVariable1(type variable1) {
this.variable1 = variable1;
}
}
Variables d’instance : Ce sont les variables qui sont déclarées dans une classe mais en dehors de toute méthode. Chaque instance ou objet de la classe a sa propre copie de ces variables.
Constructeur : Un constructeur est une méthode spéciale qui est utilisée pour initialiser un objet. Le constructeur est appelé lorsque nous créons un objet à l’aide du mot-clé new.
Méthodes : Les méthodes sont des fonctions qui définissent le comportement de la classe. Elles peuvent être utilisées pour manipuler les variables d’instance, effectuer des calculs, etc.
this : Le mot-clé this est utilisé pour faire référence à l’objet courant dans une méthode ou un constructeur.
Getters et setters : Ce sont des méthodes utilisées pour accéder et définir les valeurs des variables d’instance. Les getters sont des méthodes pour obtenir la valeur d’une variable, et les setters sont des méthodes pour définir la valeur d’une variable.
// Déclaration de la classe "NomDeLaClasse"
public class NomDeLaClasse {
// Variables d'instance (ou attributs) de la classe
// Ces variables définissent l'état d'un objet de cette classe
// Variable de type int (entier)
private int variableInt;
// Variable de type double (nombre à virgule flottante)
private double variableDouble;
// Variable de type String (chaîne de caractères) initialisée à null
private String variableString = null;
// Variable de type boolean (booléen) accessible publiquement et initialisée à true
public boolean IsBool = true;
// Constructeur de la classe
// Il permet d'initialiser un nouvel objet de cette classe avec des valeurs spécifiques
public NomDeLaClasse(int _variable1, double _variable2, String _variable3) {
this.variableInt = _variable1;
this.variableDouble = _variable2;
this.variableString = _variable3;
}
// Méthodes "getter" et "setter" pour les variables d'instance
// Elles permettent d'accéder et de modifier les valeurs des variables d'instance
public int getVariableInt() {
return this.variableInt;
}
public void setVariableInt(int variable1) {
this.variableInt = variable1;
}
public double getVariableDouble() {
return this.variableDouble;
}
public void setVariableDouble(double variable2) {
this.variableDouble = variable2;
}
public String getVariableString() {
return this.variableString;
}
public void setVariableString(String variable3) {
this.variableString = variable3;
}
// Méthode publique "MaMethodePublic"
// Elle appelle trois méthodes privées et renvoie une chaîne de caractères
public String MaMethodePublic() {
MaMethodePrivate01(); // Modifie "variableString" en y ajoutant "variableInt" et "IsBool"
MaMethodePrivate02(); // Ajoute à "variableString" la valeur de "variableDouble" et une chaîne fixe
return MaMethodePrivate03(); // Renvoie la valeur actuelle de "variableString"
}
// Méthode privée "MaMethodePrivate01"
// Elle modifie la variable "variableString"
private void MaMethodePrivate01() {
this.variableString = "" + this.variableInt + " " + IsBool;
}
// Méthode privée "MaMethodePrivate02"
// Elle ajoute des informations à la variable "variableString"
private void MaMethodePrivate02() {
this.variableString += " " + this.variableDouble + " Modification de la String";
}
// Méthode privée "MaMethodePrivate03"
// Elle renvoie la valeur actuelle de "variableString"
private String MaMethodePrivate03() {
return this.variableString;
}
}
// Déclaration de la classe "Main"
public class Main {
// Méthode principale "main" qui est le point d'entrée de l'application Java
public static void main(String[] args) {
// Création d'une nouvelle instance de la classe "NomDeLaClasse" avec les valeurs 0, 1.5 et "Toto"
// et assignation de cette instance à la variable "maClassIntancie"
NomDeLaClasse maClassIntancie = new NomDeLaClasse(0, 1.5d, "Toto");
// Modification de la variable publique "IsBool" de l'objet "maClassIntancie" pour lui assigner la valeur "false"
maClassIntancie.IsBool = false;
// Appel de la méthode "MaMethodePublic" de l'objet "maClassIntancie"
// et stockage du résultat retourné par cette méthode dans la variable "returnMethode"
String returnMethode = maClassIntancie.MaMethodePublic();
// Affichage du contenu de la variable "returnMethode" dans la console
System.out.println(returnMethode);
}
}
Explications supplémentaires :
- La classe
Maincontient la méthodemain, qui est le point d'entrée standard pour les applications Java. Lorsque vous exécutez une application Java, c'est cette méthode qui est appelée en premier. - Dans cette méthode, nous créons une instance de la classe
NomDeLaClasseen utilisant le mot-clénewsuivi du constructeur de cette classe. Cette instance est stockée dans la variablemaClassIntancie. - Ensuite, nous modifions l'attribut
IsBoolde l'objetmaClassIntanciepour lui donner la valeurfalse. - Après cela, nous appelons la méthode
MaMethodePublicde l'objetmaClassIntancieet stockons le résultat dans la variablereturnMethode. - Enfin, nous affichons le contenu de
returnMethodeà l'aide deSystem.out.println.
Destructeur en Java ?
En Java, il n’y a pas de concept de destructeur comme en C++. Java possède un système de gestion automatique de la mémoire, donc vous n’avez pas besoin de détruire explicitement les objets comme vous le feriez dans d’autres langages de programmation.
Cependant, Java fournit une méthode appelée finalize() qui est appelée par le Garbage Collector juste avant qu’un objet ne soit détruit et que sa mémoire ne soit récupérée. La méthode finalize() est définie dans la classe Object (la classe mère de toutes les classes en Java) et peut être surchargée pour définir des actions spécifiques à effectuer avant qu’un objet ne soit détruit.
Voici comment vous pouvez surcharger la méthode finalize() :
protected void finalize() throws Throwable {
// code à exécuter avant que l'objet ne soit détruit
}
Cependant, il est important de noter que la méthode finalize() n’est pas recommandée pour une utilisation régulière. Elle est dépréciée depuis Java 9 car son exécution n’est pas garantie par la JVM. Elle ne doit être utilisée que pour des nettoyages d’urgence ou comme filet de sécurité.
Pour gérer les ressources non-mémoire (comme les fichiers, les sockets, les connexions à la base de données, etc.), il est recommandé d’utiliser le bloc try-with-resources ou une méthode de fermeture explicite.
Voici un exemple d’utilisation du bloc try-with-resources :
try (Resource r = new Resource()) {
r.use();
} catch (Exception e) {
// gestion des exceptions
}
Dans cet exemple, Resource est une classe qui implémente l’interface AutoCloseable. L’interface AutoCloseable a une seule méthode appelée close() qui est automatiquement appelée à la fin du bloc try.
La surcharge de méthodes
La surcharge de méthodes est une caractéristique de la programmation orientée objet en Java qui permet à une classe d’avoir plusieurs méthodes avec le même nom, mais avec des paramètres différents. C’est un moyen de réaliser le polymorphisme en Java.
Voici comment vous pouvez surcharger une méthode en Java :
public class MaClasse {
// première méthode
public void maMethode(int param1) {
// code
}
// méthode surchargée avec un paramètre différent
public void maMethode(String param1) {
// code
}
// méthode surchargée avec un nombre différent de paramètres
public void maMethode(int param1, int param2) {
// code
}
}
Dans cet exemple, la méthode maMethode est surchargée trois fois : la première prend un entier en paramètre, la deuxième prend une chaîne en paramètre et la troisième prend deux entiers en paramètres.
Il y a quelques règles à suivre lors de la surcharge des méthodes :
-
Le nom de la méthode doit être le même : Pour surcharger une méthode, vous devez utiliser le même nom de méthode.
-
La liste des paramètres doit être différente : Vous pouvez changer le nombre de paramètres ou leur type. Par exemple, si une méthode prend un entier en paramètre, vous pouvez surcharger cette méthode pour qu’elle prenne deux entiers, ou un
String, etc. -
Le type de retour ne suffit pas pour surcharger une méthode : Deux méthodes qui ont le même nom et la même liste de paramètres mais des types de retour différents ne sont pas considérées comme des méthodes surchargées. En fait, cela provoquera une erreur de compilation.
La surcharge de constructeur
La surcharge de constructeur en Java est un concept qui permet à une classe d’avoir plus d’un constructeur, chacun ayant des listes de paramètres différentes. Si nous avons besoin de créer des objets de différentes manières, nous pouvons surcharger le constructeur. Voici comment vous pouvez surcharger un constructeur en Java :
public class MaClasse {
private int var1;
private String var2;
// Premier constructeur
public MaClasse() {
this.var1 = 0;
this.var2 = "";
}
// Constructeur surchargé avec un paramètre
public MaClasse(int var1) {
this.var1 = var1;
this.var2 = "";
}
// Constructeur surchargé avec deux paramètres
public MaClasse(int var1, String var2) {
this.var1 = var1;
this.var2 = var2;
}
}
Dans cet exemple, la classe MaClasse a trois constructeurs : le premier est un constructeur par défaut sans paramètres, le deuxième prend un entier en paramètre et le troisième prend un entier et une chaîne en paramètres.
Lors de la création d’un objet, Java utilise le constructeur qui correspond aux arguments que vous avez fournis. Par exemple, MaClasse mc1 = new MaClasse(); utilisera le premier constructeur, MaClasse mc2 = new MaClasse(10); utilisera le deuxième constructeur, et MaClasse mc3 = new MaClasse(20, "Hello"); utilisera le troisième constructeur.
Exemple
exemple d’utilisation de la surcharge de constructeur en Java avec une classe Personne.
public class Personne {
private String nom;
private int age;
// Constructeur par défaut
public Personne() {
this.nom = "";
this.age = 0;
}
// Constructeur avec un paramètre
public Personne(String nom) {
this.nom = nom;
this.age = 0;
}
// Constructeur avec deux paramètres
public Personne(String nom, int age) {
this.nom = nom;
this.age = age;
}
// Méthodes pour afficher les informations de la personne
public void afficher() {
System.out.println("Nom: " + this.nom + ", Age: " + this.age);
}
}
public class Main {
public static void main(String[] args) {
// Création d'objets Personne en utilisant différents constructeurs
Personne p1 = new Personne();
Personne p2 = new Personne("Alice");
Personne p3 = new Personne("Bob", 25);
// Affichage des informations des personnes
p1.afficher();
p2.afficher();
p3.afficher();
}
}
Dans cet exemple, la classe Personne a trois constructeurs : le premier est un constructeur par défaut sans paramètres, le deuxième prend un String (le nom de la personne) en paramètre et le troisième prend un String et un int (le nom et l’âge de la personne) en paramètres.
Dans la classe principale Main, nous créons trois objets Personne en utilisant les trois constructeurs différents, puis nous affichons leurs informations.
