Avant de comprendre les classes et les objets Java, présentons brièvement la programmation orientée objet. La programmation est la conception de programmes à travers des objets. L'objet représente une entité et l'entité peut être clairement identifiée.
Java comme langage orienté objet. Les concepts de base suivants sont pris en charge :
Polymorphisme
hériter
encapsulation
abstrait
gentil
objet
Exemple
méthode
Analyse des messages
Dans cette section, nous nous concentrons sur les concepts d'objets et de classes.
Objet : Un objet est une instance d'une classe et a un état et un comportement. Par exemple, un chien est un objet. Son statut comprend : sa couleur, son nom et sa race ; ses comportements incluent : remuer la queue, aboyer, manger, etc.
Classe : Une classe est un modèle qui décrit le comportement et l'état d'une classe d'objets.
Voyons maintenant de plus près ce qu'est un objet. Si vous regardez le monde réel qui vous entoure, vous constaterez qu'il y a de nombreux objets autour de vous, comme des voitures, des chiens, des personnes, etc. Tous ces objets ont leur propre état et comportement.
Prenons l'exemple d'un chien. Son statut comprend : le nom, la race et la couleur, et ses comportements incluent : aboyer, remuer la queue et courir.
En comparant des objets réels et des objets logiciels, ils sont très similaires.
Les objets logiciels ont également un état et un comportement. L'état d'un objet logiciel est son attribut et son comportement se reflète à travers les méthodes.
Dans le développement de logiciels, les méthodes opèrent sur les changements de l'état interne des objets, et les appels mutuels entre objets sont également effectués via des méthodes.
Les classes peuvent être considérées comme des modèles permettant de créer des objets Java.
Comprenons la définition des classes en Java à travers la classe simple suivante :
Chien de classe publique{
Race à cordes ;
âge entier ;
Couleur de la chaîne ;
annuler les aboiements(){
}
vide faim(){
}
vider le sommeil(){
}
}Une classe peut contenir des variables des types suivants :
Variables locales : Les variables définies dans les méthodes, constructeurs ou blocs d'instructions sont appelées variables locales. La déclaration et l'initialisation des variables sont toutes dans les méthodes. Une fois la méthode terminée, les variables seront automatiquement détruites.
Variables membres : Les variables membres sont des variables définies dans la classe et en dehors du corps de la méthode. Ces variables sont instanciées lors de la création de l'objet. Les variables membres sont accessibles par les méthodes de classe, les constructeurs et les blocs d'instructions spécifiques à la classe.
Variables de classe : Les variables de classe sont également déclarées dans la classe, en dehors du corps de la méthode, mais elles doivent être déclarées comme type statique.
Une classe peut avoir plusieurs méthodes. Dans l'exemple ci-dessus : barking() , hungry() et sleeping() sont toutes des méthodes de la classe Dog.
Chaque classe possède des méthodes constructeur. Si aucun constructeur n'est explicitement défini pour une classe, le compilateur Java fournira un constructeur par défaut pour la classe.
Lors de la création d'un objet, au moins une méthode constructeur doit être appelée. Le nom du constructeur doit être le même que celui de la classe. Une classe peut avoir plusieurs constructeurs.
Voici un exemple de constructeur :
Chiot de classe publique{
publicPuppy(){
}
public Puppy (nom de la chaîne) {
// Ce constructeur n'a qu'un seul paramètre : nom
}
} Les objets sont créés en fonction des classes. En Java, utilisez le mot-clé new pour créer un nouvel objet. La création d'un objet nécessite les trois étapes suivantes :
Déclaration : déclarez un objet, y compris le nom de l'objet et le type d'objet.
Instanciation : Utilisez le mot-clé new pour créer un objet.
Initialisation : Lors de l'utilisation new pour créer un objet, la méthode constructeur est appelée pour initialiser l'objet.
Voici un exemple de création d'un objet :
Chiot de classe publique{
public Puppy (nom de la chaîne) {
//Ce constructeur n'a qu'un seul paramètre : nom
System.out.println("Le nom du chiot est :" + nom );
}
public static void main(String []args){
//L'instruction suivante créera un objet Puppy Puppy myPuppy = new Puppy( "tommy" );
}
}Compilez et exécutez le programme ci-dessus, et les résultats suivants seront imprimés :
Le nom du chiot est : TommyAccédez aux variables membres et aux méthodes membres via l'objet créé comme suit :
/* Instancier un objet */
ObjectReference = new Constructeur();
/* Accéder aux variables */
ObjectReference.variableName;
/* Accéder aux méthodes de la classe */
ObjectReference.MethodName();L'exemple suivant montre comment accéder aux variables d'instance et appeler les méthodes membres :
Chiot de classe publique{
int chiotAge ;
public Puppy (nom de la chaîne) {
// Ce constructeur n'a qu'un seul paramètre : nom
System.out.println("Le nom transmis est :" + nom );
}
public void setAge(int âge){
chiotAge = âge ;
}
public int getAge( ){
System.out.println("L'âge du chiot est :" + chiotAge );
retourner l'âge du chiot ;
}
public static void main(String []args){
/* Créer un objet */
Chiot monPuppy = new Puppy( "tommy" );
/* Définir l'âge via des méthodes */
monPuppy.setAge(2);
/* Appeler une autre méthode pour obtenir l'âge */
monPuppy.getAge( );
/*Vous pouvez également accéder aux variables membres comme suit */
System.out.println("Valeur de la variable :" + monPuppy.puppyAge );
}
}La compilation et l'exécution du programme ci-dessus produisent les résultats suivants :
Le nom d'identité est :tommy
L'âge du chiot est :2
Valeur variable : 2 Dans la dernière partie de cette section, nous découvrirons les règles de déclaration des fichiers sources. Portez une attention particulière à ces règles lors de la définition de plusieurs classes dans un fichier source et lorsqu'il existe des instructions import et des instructions package .
Il ne peut y avoir qu'une seule classe public dans un fichier source
Un fichier source peut avoir plusieurs classes non public
Le nom du fichier source doit être cohérent avec le nom de la classe public . Par exemple : le nom de la classe public dans le fichier source est Employee , alors le fichier source doit être nommé Employee.java .
Si une classe est définie dans un package, l'instruction package doit figurer sur la première ligne du fichier source.
Si le fichier source contient une instruction import , elle doit être placée entre l'instruction package et la définition de classe. S'il n'y a pas d'instruction package , l'instruction import doit figurer en premier dans le fichier source.
L'instruction import et l'instruction package sont valides pour toutes les classes définies dans le fichier source. Dans le même fichier source, différentes déclarations de package ne peuvent pas être données à différentes classes.
Les classes ont plusieurs niveaux d'accès, et les classes sont également divisées en différents types : classes abstraites, classes final , etc. Ceux-ci seront introduits dans le chapitre sur le contrôle d’accès.
En plus des types mentionnés ci-dessus, Java possède également des classes spéciales, telles que des classes internes et des classes anonymes.
Les packages sont principalement utilisés pour classer les classes et les interfaces. Lors du développement de programmes Java, vous pouvez écrire des centaines ou des milliers de classes, il est donc nécessaire de classer les classes et les interfaces.
En Java, si un nom qualifié complet est donné, incluant le nom du package et le nom de la classe, le compilateur Java peut facilement localiser le code source ou la classe. L'instruction Import est utilisée pour fournir un chemin raisonnable afin que le compilateur puisse trouver une certaine classe.
Par exemple, la ligne de commande suivante demandera au compilateur de charger toutes les classes dans le chemin java_installation/java/io
importer java.io.* ;Dans cet exemple, nous créons deux classes : Employee et EmployeeTest.
Ouvrez d’abord un éditeur de texte et collez-y le code suivant. Notez que le fichier est enregistré sous Employee.java.
La classe Employee comporte quatre variables membres : nom, âge, fonction et salaire. La classe déclare explicitement une méthode constructeur avec un seul paramètre.
importer java.io.* ;
Employé de classe publique{
Nom de la chaîne ;
âge entier ;
Désignation de la chaîne ;
double salaire;
// Constructeur de la classe Employee public Employee (String name) {
this.name = nom ;
}
//Définir la valeur de l'âge public void empAge(int empAge){
âge = empAge ;
}
/*Définir la valeur de la désignation*/
public void empDesignation(String empDesig){
désignation = empDesig;
}
/*Définir la valeur du salaire*/
public void empSalary(double empSalary){
salaire = empSalaire ;
}
/* Imprimer les informations */
public void printEmployee(){
System.out.println("Nom:"+ nom );
System.out.println("Âge :" + âge );
System.out.println("Désignation :" + désignation );
System.out.println("Salaire :" + salaire);
}
} L'exécution du programme commence à partir de la méthode main . Pour exécuter ce programme, la méthode main doit être incluse et un objet instance doit être créé.
La classe EmployeeTest est donnée ci-dessous, qui instancie deux instances de la classe Employee et appelle des méthodes pour définir les valeurs des variables.
Enregistrez le code suivant dans le fichier EmployeeTest.java.
importer java.io.* ;
classe publique EmployeeTest{
public static void main(String args[]){
/* Crée deux objets à l'aide du constructeur */
Employé empOne = nouvel Employé("James Smith");
Employé empTwo = nouvel Employé("Mary Anne");
//Appelle les méthodes membres de ces deux objets empOne.empAge(26);
empOne.empDesignation("Ingénieur logiciel senior");
empOne.empSalary(1000);
empOne.printEmployee();
empTwo.empAge(21);
empTwo.empDesignation("Ingénieur logiciel");
empTwo.empSalary(500);
empTwo.printEmployee();
}
}Compilez ces deux fichiers et exécutez la classe EmployeeTest. Vous pouvez voir les résultats suivants :
C:>javacEmployee.java
C :> vi EmployeeTest.java
C:>javacEmployeeTest.java
C :>javaEmployéTest
Nom:James Smith
Âge :26
Titre : Ingénieur logiciel principal
Salaire : 1000,0
Nom : Marie-Anne
Âge : 21
Titre :Ingénieur logiciel
Salaire : 500,0