Apprenez à créer des classes en Java

La création de classes en Java est une composante fondamentale de ce que l'on appelle la programmation orientée objet. La programmation orientée objet est un paradigme (un style de programmation) basé sur l'utilisation d'objets capables de s'envoyer des messages.

Pour bien comprendre comment utiliser les classes en Java, vous devez d'abord comprendre ce que sont les objets.

Explorer des objets

En Java, le terme objet est souvent utilisé de manière interchangeable avec le terme classe, ce qui est compréhensible étant donné qu'un objet est créé à partir d'une classe.

Une classe peut être considérée comme un plan - elle contient donc toutes les informations nécessaires pour créer un objet.

Par exemple, vous pouvez créer une classe d'élèves qui contiendra des informations de base sur un élève, telles qu'un nom, un âge et un programme d'études. Chaque fois qu'un nouvel élève est créé à l'aide de la classe d'élève, cet élève est appelé objet.

Créer une classe en Java

La création de classes en Java est nécessaire car elles donnent la structure de votre programme et réduisent la quantité de code présent dans votre programme. Au lieu de créer un nouvel état et un nouveau comportement pour chaque objet similaire dans un programme, vous pouvez simplement appeler la classe qui a le modèle pour la création de cet objet.

Dans une classe Java, l'une des instructions les plus importantes est une déclaration de classe.

Déclaration de classe

En règle générale, chaque classe en Java est déclarée à l'aide du mot-clé «public», qui indique que la classe en question est accessible par d'autres classes du programme Java. Le mot-clé «class» suit ceci et sert à indiquer que l'instruction Java que vous créez est une classe.

Vient ensuite le nom de la classe, qui commence généralement par une majuscule et peut être n'importe quel nom que vous jugez approprié pour les objets que vous souhaitez créer. Dans l'exemple ci-dessous, le nom de la classe est étudiant, car l'intention est de créer des objets étudiants à partir de cette classe.

Exemple de déclaration de classe en Java

Public class Student {
}

Le dernier composant d'une déclaration de classe est les accolades ouvertes et fermées. La première accolade signifie le début de la classe, tandis que la seconde accolade signifie la fin de la classe. Par conséquent, chaque état et comportement qui est unique à notre classe sera stocké entre ces accolades.

L'utilisation d'accolades permet d'ajouter de la structure à votre code Java. Cette fonctionnalité ne doit pas être considérée comme acquise car d'autres langages, tels que Python, n'utilisent pas d'accolades pour structurer le code lors de la création de classes.

En rapport: Comment créer une classe simple en Python

Attributs de classe Java

Les attributs peuvent être considérés comme des blocs de construction pour une classe Java; ils contiennent les éléments de données qui sont utilisés pour donner à un objet son état et sont souvent appelés variables.

Notre classe s'appelle «étudiant» et se concentre sur le stockage des informations sur les étudiants appartenant à un collège / une université en particulier. Par conséquent, les informations contenues dans le dossier pourraient être le nom, l’âge et le programme d’études de chaque élève.

Exemple de classe avec des attributs

Public class Student {
// déclaration de variable
private String fname;
private String lname;
int age privé;
private String courseOfStudy;
}

Il y a quelques points importants à noter dans le programme ci-dessus. Lors de la déclaration d'un attribut / variable en Java, vous devez disposer d'un modificateur d'accès, d'un type de données et du nom de la variable.

Dans notre programme, le modificateur d'accès est le mot-clé «privé», qui est utilisé pour empêcher l'accès externe aux données dans le classe d'étudiants, et c'est une bonne pratique de programmation car elle protège l'intégrité des données stockées dans un classer.

Il existe deux représentations différentes des types de données dans notre programme: String et int.

• Le mot clé String est utilisé pour déclarer des variables qui stockent des données texte et doit commencer par un «S» majuscule pour être reconnu par le compilateur Java.
• Le mot clé «int» est utilisé pour déclarer des attributs qui stockent des données entières et doit être en minuscules car le langage de programmation Java est sensible à la casse.

Le nom de la variable est généralement la dernière partie d'une déclaration d'attribut / variable. Cependant, la valeur d'une variable peut lui être affectée lors de l'étape de déclaration. Une fois toutes les variables déclarées, vous pouvez passer à la création de constructeurs.

Constructeurs Java

Aucune classe en Java n'est complète sans un constructeurc'est un concept fondamental de la langue. Un constructeur est une méthode en Java qui est utilisée pour donner à un objet son état et est appelée automatiquement lorsqu'un objet est créé. Il existe maintenant trois types de constructeurs: par défaut, principal et copie.

Lorsqu'un objet est créé à partir d'une classe, vous pouvez choisir de fournir ce que l'on appelle des paramètres (valeurs pouvant être transmises à une méthode) à l'objet ou vous pouvez le créer sans aucun paramètre.

Si un nouvel objet est créé à partir d'une classe et ne reçoit aucun paramètre, le constructeur par défaut sera appelé; cependant, si des paramètres sont fournis, le constructeur principal sera appelé.

Exemple de classe avec un constructeur par défaut

Public class Student {
// déclaration de variable
private String fname;
private String lname;
int age privé;
private String courseOfStudy;
// constructeur par défaut
public Student () {
fname = "Jean";
lname = "Biche";
âge = 20;
courseOfStudy = "Pyschologie";
}
}

Dans le code ci-dessus, notre constructeur par défaut est affecté au modificateur d'accès «public», qui lui permet d'être accessible en dehors de la classe étudiante. Votre modificateur d'accès au constructeur doit être «public», sinon votre classe ne pourra pas créer d'objets en utilisant d'autres classes.

Les constructeurs reçoivent toujours le nom de la classe à laquelle ils appartiennent. Pour un constructeur par défaut, le nom de la classe est suivi de parenthèses comme illustré dans notre code ci-dessus. Les parenthèses doivent être suivies d'accolades ouvertes et fermées qui contiendront l'affectation par défaut des variables appartenant à la classe.

À partir de notre exemple de code ci-dessus, chaque fois qu'une instance de la classe étudiante est créée sans paramètres constructeur sera appelé et un étudiant avec le nom de John Doe, âgé de 20 ans, et un cours de psychologie sera créé.

Exemple de classe avec un constructeur principal

Public class Student {
// déclaration de variable
private String fname;
private String lname;
int age privé;
private String courseOfStudy; 
// constructeur par défaut
public Student () {
fname = "Jean";
lname = "Biche";
âge = 0;
courseOfStudy = "Pyschologie";
}
// constructeur principal
public Student (String fname, String lname, int age, String courseOfStudy) {
this.fname = fname;
this.lname = lname;
this.age = âge;
this.courseOfStudy = courseOfStudy;
}
}

La principale différence entre un constructeur par défaut et un constructeur principal est que le constructeur principal prend des arguments, contrairement au constructeur par défaut. Pour utiliser le constructeur principal de la classe Student, vous devrez fournir le nom, l'âge et le programme d'études de l'objet étudiant que vous souhaitez créer.

Dans le constructeur principal, chaque valeur d'attribut de données reçue en tant que paramètre est stockée dans la variable appropriée. Le mot-clé «this» est utilisé pour indiquer que les variables auxquelles elles sont liées appartiennent à la classe des élèves, tandis que les autres variables sont ce qui est reçu en tant que paramètres lorsqu'un objet de la classe est créé en utilisant le primaire constructeur.

Le constructeur de copie est une copie du constructeur principal et n'est pas nécessaire à l'exécution réussie de votre programme Java; il n'est donc pas nécessaire de l'inclure.

Vous pouvez maintenant créer une classe simple en Java

Cet article montre comment créer non seulement une classe utile dans le langage de programmation Java, mais également quelques principes de base de la programmation orientée objet. Cela inclut la création de variables et l'exploration des types de données «Sting» et «int», et la compréhension des modificateurs d'accès public et privé en Java.

Crédit d'image: Christina Morillo /Pexels

Comment écrire une boucle for en Java

Apprenez à utiliser les boucles for, l'une des compétences les plus utiles à maîtriser en programmation pour débutants.

A propos de l'auteur