Programmation en Java – Objet et Classes

Java est un langage orienté objet, basée sur le concept d’objets, qui peut contenir des données, sous forme de champs, souvent appelés attributs; Et le code, sous la forme de procédures, souvent appelées méthodes. Une des caractéristiques des objets est que les procédures d’un objet peuvent accéder et modifier les attributs de l’objet auquel ils sont associés, Java prend en charge les concepts fondamentaux suivants :
 
 

• Polymorphisme
• Héritage
• Encapsulation
• Abstraction
• Classes
• Objets
• Instance
• Méthode
• Message Parsing

Dans ce chapitre, nous allons voir les concepts – Classes et Objets.

Classe – Une classe peut être définie comme un modèle ou un plan qui décrit le comportement ou l’état que l’objet de son type prend en charge.

 

Objets en Java

Examinons maintenant ce que sont les objets. Si nous considérons le monde réel, nous pouvons trouver de nombreux objets autour de nous, des voitures, des chiens, des humains, etc Tous ces objets ont un état et un comportement.

Si nous considérons un chien, alors son état est – nom, race, couleur, et le comportement est – aboyer, courir etc.

Si vous comparez l’objet en programmation à un objet du monde réel, ils ont des caractéristiques très similaires.

Les objets en programmation ont également un état et un comportement. L’état d’un objet en programmation est stocké dans des champs et le comportement est affiché via des méthodes.

Ainsi, dans le développement logiciel, les méthodes opèrent sur l’état interne d’un objet et la communication objet à objet se fait via des méthodes.

 

Classes en Java

Une classe est un modèle à partir duquel des objets individuels sont créés.

Voici un simple exemple d’une classe :

public class Chien {
   String race;
   int age;
   String coleur;

   void aboyer() {
   }

   void manger() {
   }

   void dormir() {
   }
}

Une classe peut contenir l’un des types de variable suivants.

Variables locales : Les variables définies à l’intérieur 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 il sera détruite lorsque la méthode est 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 peuvent être accédées depuis n’importe quelle méthode, constructeur ou blocs 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.

Une classe peut avoir n’importe quel nombre de méthodes pour accéder à la valeur de divers types de méthodes. Dans l’exemple ci-dessus, dormir(), manger() et aboyer() sont des méthodes.

Voici quelques-uns des sujets importants qui doivent être discutés lors qu’on parle des classes en Java.

 

 

Constructeurs

Lors qu’on parle d’une classe, un des sous-thème le plus important serait les constructeurs. Chaque classe a un constructeur. Si nous n’écrivons pas explicitement un constructeur pour une classe, le compilateur Java crée un constructeur par défaut pour cette classe.

Chaque fois qu’un nouvel objet est créé, au moins un constructeur est appelé. La règle principale des constructeurs est qu’ils devraient avoir le même nom que la classe. Une classe peut avoir plus d’un constructeur.

Voici un exemple de constructeur

public class Test {
   public Test() {
   }

   public Test(String nom) {
      // Ce constructeur a un paramètre, nom.
   }
}

Java prend également en charge la Classe Singleton où vous seriez en mesure de créer une seule instance d’une classe.

 

Création d’un objet

Comme mentionné précédemment, une classe fournit les modèles pour les objets. Donc, généralement, un objet est créé à partir d’une classe. En Java, le mot clé new est utilisé pour créer de nouveaux objets.

Il existe trois étapes pour créer un objet à partir d’une classe:

Déclaration : Une déclaration de variable avec un nom et un type d’objet.

Instanciation : Le mot clé ‘new‘ est utilisé pour créer l’objet.

Initialisation : Le mot clé ‘new‘ est suivi par un appel à un constructeur. Cet appel initialise le nouvel objet.

Voici un exemple de création d’un objet –

public class Voiture {
   public Voiture (String nom) {
      // Ce constructeur a le paramètre, nom.
      System.out.println("Nom de la voiture est :" + nom);
   }

   public static void main(String []args) {
      // L'instruction suivante crée un objet maVoiture 
      Voiture maVoiture = new Voiture ( "BM" );
   }
} 

La sortie :

Nom de la voiture est :BM

 

 

Accès aux variables d’instance et méthodes

Les variables d’instance et les méthodes sont accessibles via des objets créés. Pour accéder à une variable d’instance, suivez le étapes suivants :

/* Créer d'abord un objet */
ObjectReference = new Constructor();
/* Appelez maintenant la variable comme suit */
ObjectReference.variableName;
/* Maintenant, vous pouvez appeler la méthode de la classe comme suit */
ObjectReference.MethodName();

Exemple :
Cet exemple explique comment accéder aux variables d’instance et aux méthodes d’une classe.

public class Personne{
   int agePersonne;

   public Personne(String nom) {
       // Ce constructeur a le paramètre, nom.
      System.out.println("Nom choisi est :" + nom);
   }

   public void setAge( int age ) {
      agePersonne = age;
   }

   public int getAge( ) {
      System.out.println("l'age de la personne est :" + agePersonne);
      return agePersonne;
   }

   public static void main(String []args) {
      /* Création d'objet */
      Personne personne1 = new Personne( "Alex" );

      /* Appelez la méthode de la classe Personnes pour fixer l'âge */
      personne1.setAge( 23 );

      /* Appelez la méthode de la classe Personnes pour obtenir l'âge */
      personne1.getAge( );

       /* Vous pouvez accéder à la variable d'instance comme suit */
      System.out.println("La valeur de la variable d'instance est :" + personne1.agePersonne);
   }
}

La sortie :

Nom choisi est : Alex
l'age de la personne est :23
La valeur de la variable d'instance est :23

 

La déclaration des fichiers sources

Comme c’est la dernière partie de cette section, nous allons maintenant examiner les règles de déclaration de fichier source. Ces règles sont essentielles lors de la déclaration des classes, des instructions d’importation et des 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 également être le nom du fichier source qui doit apporter l’extension .java à la fin. Par exemple: public class Employe {} alors le fichier source doit être utilisé comme Employe.java.

– Si la classe est définie à l’intérieur d’un package, l’instruction package doit être la première dans le fichier source.

– Si des instructions import sont présentes, elles doivent être écrites entre l’instruction package et la déclaration de la classe. S’il n’y a pas d’instructions package, l’instruction import 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 de différentes classes dans le fichier source.

– Les classes ont plusieurs niveaux d’accès et il existe différents types de classes; Des classes abstraites, des classes finales, etc. Nous expliquerons tout cela dans le chapitre des modificateurs d’accès.

– En dehors des types de classes mentionnés ci-dessus, Java a également des classes spécifiques appelées classes Inner et classes Anonymous.

 

 

Package en Java

Les packages en Java sont un mécanisme permettant d’encapsuler un groupe de classes, d’interfaces et de sous-packages. De nombreuses implémentations de Java utilisent un système de fichiers hiérarchique pour gérer les fichiers source et les fichiers de classe. Il est facile d’organiser des fichiers de classe en Package. Tout ce que nous devons faire est de mettre des fichiers de classe liés dans le même répertoire, donner au répertoire un nom qui se rapporte à l’objet des classes et ajouter une ligne au haut de chaque fichier de classe qui déclare le nom du package, qui porte le même nom du répertoire où ils résident. Exemple :

package monPackage;

 

Déclarations ‘Import‘

En Java si un nom pleinement qualifié, qui inclut le package et le nom de classe, alors le compilateur peut facilement localiser le code source ou les classes. Déclaration Import est une façon de donner l’emplacement approprié pour le compilateur pour trouver cette classe particulière.

Par exemple, la ligne suivante demande au compilateur de charger toutes les classes disponibles dans le répertoire java/class/

import java.class.*;

 

Une étude d’un cas simple

Nous créerons deux classes Personne et TestPersonne.

Ouvrez l’éditeur de texte et ajoutez le code suivant. Rappelez-vous que c’est la classe Personne et une classe public. Maintenant, enregistrez ce fichier source avec le nom Personne.java.

La classe Personne a quatre variables d’instance: nom, prénom, et l’age. La classe a un constructeur explicitement défini, qui prend un paramètre.

Exemple :

import java.io.*;
class Personne {

   String nom;
   String prenom;
   int age;

   // C'est le constructeur de la classe Personne
   public Personne(String nom) {
      this.nom= nom;
   }

   // Affectez l'âge du Personne à la variable âge .
   public void agePersonne(int ag) {
      age = ag;
   }

   /* Affecter le prenom à la variable prenom. */
   public void prenomPersonne(String pren) {
      prenom = pren;
   }

   /* Afficher les détails de la personne*/
   public void afficherPersonne() {
      System.out.println("Nom:"+ nom);
      System.out.println("Age:" + age );
      System.out.println("Prenom :" + prenom );
   }
} 

 
 
Comme mentionné précédemment dans ce tutoriel, le traitement commence à partir de la méthode principale. Donc, afin que nous puissions exécuter la classe Personne, il devrait y avoir une méthode principale main() et des objets devraient être créés. Nous allons créer une classe pour ces tâches.

Voici la classe PersonneTest, qui crée deux instances de la classe Personne et invoque les méthodes pour chaque objet pour assigner des valeurs pour chaque variable.

Enregistrez le code suivant dans le fichier PersonneTest.java.

public class PersonneTest {

   public static void main(String args[]) {
      /* Créer deux objets en utilisant le constructeur */
      Personne personne1 = new Personne("Smith");
      Personne personne2 = new Personne("Alfredo");

      // Invocation des méthodes pour chaque objet créé
      personne1 .agePersonne(26);
      personne1 .prenomPersonne("Juhan");
      personne1 .afficherPersonne();

      personne2 .agePersonne(21);
      personne2 .prenomPersonne("Alex");
      personne2 .afficherPersonne();
   }
} 

Maintenant, compilez les deux classes, puis exécutez PersonneTest pour afficher le résultat comme suit :

C:> javac Personne.java
C:> javac PersonneTest.java
C:> java PersonneTest 

Nom:Smith
Age:26
Prenom :Juhan
Nom:Alfredo
Age:21
Prenom :Alex