Objets et classes en Java
Java est un langage orienté objet. En tant que langage doté de la fonctionnalité orientée objet, Java prend en charge les concepts fondamentaux suivants
- Polymorphisme
- Héritage
- Encapsulation
- Abstraction
- Classes
- Objets
- Instance
- Méthode
- Passage des messages
Dans ce cours, nous examinerons les concepts - Classes et objets.
- Objet - Les objets ont des états et des comportements. Exemple: Une Lampe a des isOn, ainsi que comportements - allumer, éteindre. Un objet est une instance d'une classe.
- Classe - Une classe peut être définie en tant que modèle décrivant le comportement/l'état pris en charge par l'objet de ce type.
Classes en Java
Une classe est un modèle à partir duquel des objets individuels sont créés.
Syntaxe :
class < class_name>{
attributs;
méthodes;
}
Exemple 1 :
class Lampe {
// variable d'instance (attribut)
private boolean isOn;
// méthode
public void allumer() {
isOn = true;
}
// méthode
public void eteindre() {
isOn = false;
}
}
Ici, nous avons défini une classe nommée Lampe.
La classe a une variable d'instance isOn et deux méthodes allumer() et eteindre(). Ces variables et méthodes définies dans une classe sont appelées membres de la classe.
Remarquez deux mots clés, private et public dans le programme ci-dessus. Ce sont des modificateurs d'accès qui seront détaillés dans les cours suivants. Pour l'instant, rappelez-vous:
- Le mot-clé private rend les variables d'instance et les méthodes private qui ne sont accessibles qu'à partir de la même classe.
- Le mot-clé public rend publiques les variables d'instance et les méthodes accessibles de l'extérieur de la classe.
Une classe peut contenir l'un des types de variable suivants.
- Variables locales - Les variables définies dans des méthodes, des constructeurs ou des blocs sont appelées variables locales. La variable sera déclarée et initialisée dans la méthode et sera détruite une fois la méthode terminée.
- Variables d'instance - Les variables d'instance sont des variables dans une classe mais en dehors de toute méthode. Ces variables sont initialisées lorsque la classe est instanciée. Les variables d'instance sont accessibles depuis n'importe quelle méthode, constructeur ou bloc de cette classe particulière.
- Variables de classe - Les variables de classe sont des variables déclarées dans une classe, en dehors de toute méthode, avec le mot clé static.
Constructeurs
Lors de discussions sur les classes, l'un des sous-sujets les plus importants serait les constructeurs. Chaque classe a un constructeur. Si nous n'écrivons pas explicitement un constructeur pour une classe, le compilateur Java construit un constructeur par défaut pour cette classe.
Chaque fois qu'un nouvel objet est créé, au moins un constructeur sera appelé. La règle principale de constructeurs, c'est qu'ils doivent avoir le même nom que la classe. Une classe peut avoir plusieurs constructeur.
Exemple 2 :
class Lampe {
// variable d'instance (attribut)
private boolean isOn;
// constructeur par défaut
public Lampe(){
isOn=false;
}
// Ce constructeur a un paramètre, etat.
public Lampe(boolean etat){
this.isOn=etat;
}
// méthode
public void allumer() {
isOn = true;
}
// méthode
public void eteindre() {
isOn = false;
}
}
Java prend également en charge les classes Singleton dans lesquelles vous ne pouvez créer qu’une seule instance d’une classe.
Objets en Java
Comme mentionné précédemment, une classe fournit un modèle pour les objets. Donc, fondamentalement, un objet est créé à partir d'une classe. En Java, le mot-clé new est utilisé pour créer de nouveaux objets.
Il y a trois étapes pour créer un objet à partir d’une classe
- Déclaration − Une déclaration de variable avec un nom de variable et un type d'objet.
- Instanciation - Le mot clé 'new' est utilisé pour créer l'objet.
- Initialisation - Le mot-clé 'new' est suivi d'un appel à un constructeur. Cet appel initialise le nouveau objet.
Exemple 3 :
class Lampe {
// variable d'instance (attribut)
private boolean isOn;
// constructeur par défaut
public Lampe(){
this.isOn=false;
System.out.println("je suis le constructeur par défaut");
}
// Ce constructeur a un paramètre, etat.
public Lampe(boolean etat){
this.isOn=etat;
System.out.println("je suis le constructeur d'initialisation");
}
// méthode
public void allumer() {
isOn = true;
}
// méthode
public void eteindre() {
isOn = false;
}
// méthode principale
public static void main(String args[]){
Lampe l1= new Lampe();
Lampe l2 = new Lampe(false);
}
}
Accès aux variables et méthodes d'instance
Les variables et méthodes d'instance sont accessibles via des objets créés.
Vous pouvez accéder aux membres à l'aide de l'opérateur point ".".
Syntaxe:
// D'abord créer un objet
ReferenceObjet = new Constructor()
// appelez une variable comme suit
ReferenceObjet.nomVariable
// appelez une méthode de classe
ReferenceObjet.nomMethode()
Exemple 4 :
class Lampe {
// variable d'instance (attribut)
private boolean isOn;
// constructeur par défaut
public Lampe(){
this.isOn=false;
}
// méthode
public void allumer() {
isOn = true;
System.out.println("Allumer ");
}
// méthode
public void eteindre() {
isOn = false;
System.out.println("éteindre ");
}
// méthode principale
public static void main(String args[]){
Lampe l1= new Lampe();
l1.allumer();
l1.eteindre();
}
}
éteindre
Règles de déclaration du fichier source
Ces règles sont essentielles lors de la déclaration de classes, d'instructions d'importation et d'instructions de package dans un fichier source.
- Il ne peut y avoir qu'une seule classe publique par fichier source.
- Un fichier source peut avoir plusieurs classes non publiques.
- Le nom de la classe publique doit être le nom du fichier source et doit être ajouté par "".java" à la fin. Par exemple: le nom de la classe est public class Employe{}, le fichier source doit alors être Employe.java.
- Si la classe est définie dans un package, l'instruction de package doit être la première instruction du fichier source.
- Si des instructions d'importation sont présentes, elles doivent être écrites entre l'instruction de package et la déclaration de classe. S'il n'y a aucune instruction de package, l'instruction d'importation doit être la première ligne du fichier source.
- Les instructions d'importation et de package impliqueront toutes les classes présentes dans le fichier source. Il n'est pas possible de déclarer différentes instructions d'importation et/ou de package dans différentes classes du fichier source.
Les classes ont plusieurs niveaux d'accès et il existe différents types de classes; classes abstraites, classes finales, etc. Nous expliquerons tout cela dans le cours des modificateurs d'accès.
Outre les types de classes mentionnés ci-dessus, Java dispose également de classes spéciales appelées classes internes et classes anonymes.
Package Java
En termes simples, c’est un moyen de catégoriser les classes et les interfaces. Lors du développement d'applications en Java, des centaines de classes et d'interfaces seront écrites. Par conséquent, la catégorisation de ces classes est indispensable et facilite la vie.
Instructions d'importation
En Java, si un nom complet, comprenant le package et le nom de la classe, est donné, le compilateur peut facilement localiser le code source ou les classes. L'instruction d'importation est un moyen de donner l'emplacement approprié pour que le compilateur trouve cette classe particulière.
Par exemple, la ligne suivante demande au compilateur de charger toutes les classes disponibles dans le répertoire java_installation/java/io
import java.io.*;
Ce cours est juste une introduction de base sur les classes et objets. plus tard, nous discuterons en détail de toutes les notions liées aux classes et aux objets
