Java est un langage orienté objet. En tant que langage ayant la fonctionnalité orientée objet, Java prend en charge les concepts fondamentaux suivants:

• Polymorphisme
• Héritage
• Encapsulation
• Abstraction
• Les classes
• Les Objets
• Instance
• Méthode
• Analyse des messages

Dans cette partie, nous examinerons les concepts Classes et Objets.

• Objet : Les objets ont des états et des comportements. Exemple: un chien a des états - la couleur, le nom, la race ainsi que les comportements - harceler, aboyer, manger. Un objet est une instance d'une classe.
• Classe : Une classe peut être définie comme un modèle qui décrit les comportements / états qui font l'objet de son type de support.

Objets en Java

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

Si nous considérons un chien, son état est: le nom, la race, la couleur et le comportement est : les aboiements, les secousses, les courses.

Si vous comparez l'objet logiciel avec un objet réel, ils ont des caractéristiques très similaires.

Les objets logiciels ont également un état et un comportement. L'état d'un objet logiciel est stocké dans les champs et le comportement est montré via les méthodes.

Ainsi, dans le développement de logiciels, les méthodes fonctionnent sur l'état interne d'un objet et la communication objet-objet se fait via des méthodes.

Classes en Java

Une classe est une moule à partir de laquelle des objets individuels sont créés.

Un échantillon d'une classe est donné ci-dessous:

public class Dog{
   String breed;
   int age;
   String color;

   void barking(){
   }

   void hungry(){
   }

   void sleeping(){
   }
}

Une classe peut contenir l'un des types de variables suivants.

• Variables locales: les variables définies dans les méthodes, les constructeurs ou les blocs sont appelées variables locales. La variable sera déclarée et initialisée dans la méthode et la variable sera détruite lorsque la méthode sera 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 instanciées lorsque la classe est chargée. On peut accéder aux variables d'instance à partir de 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 différents types de méthodes. Dans l'exemple ci-dessus, barking( ), hungry() et sleeping() sont des méthodes.

Voici quelques-uns des sujets importants qui doivent être discutés lors d’utilisation des classes du langage Java.

Constructeurs

En discutant des cours, l'un des sous-sujets les plus importants serait les constructeurs. Chaque classe possède 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 invoqué. 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.

L'exemple d'un constructeur est donné ci-dessous:

public class Dog{
   String breed;
   int age;
   String color;

  public Dog(){
   }

   void barking(){
   }
  
   void hungry(){
   }
  
   void sleeping(){
   }
}

 Java prend également en charge les classes Singleton où vous ne pourrez créer qu'une seule instance d'une classe.

Création d'un objet

Comme mentionné précédemment, une classe fournit les plans pour les objets. Donc, fondamentalement, un objet est créé à partir d'une classe. En Java, le nouveau mot clé est utilisé pour créer de nouveaux objets.

Il y a trois étapes lors de la création d'un objet d'une classe:

• Déclaration: une déclaration de variable avec un nom de variable avec un type d'objet.
• Instantiation: le mot « new » est utilisé pour créer l'objet.
• Initialisation: le mot-clé « new » est suivi d'un appel vers un constructeur. Cet appel initialise le nouvel objet.

Un exemple de création d'un objet est donné ci-dessous:

public class Puppy{
   public Puppy(String name){
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name );
   }

   public static void main(String []args){
      // Following statement would create an object myPuppy
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

Si nous compilez et exécutez le programme ci-dessus, cela produirait le résultat suivant:

Passed Name is : tommy

Accès aux variables et aux méthodes de l'instance

Les variables d'instance et les méthodes sont accessibles via des objets créés. Pour accéder à une variable d'instance, le chemin complet doit être le suivant: 

 /* Créez d'abord un objet */
 ObjectReference = new Constructor(); 

 /* Appelez maintenant une variable comme suit */
 ObjectReference.variableName; 

 /* Maintenant, vous pouvez appeler une méthode de 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 Puppy{
   int puppyAge;

   public Puppy(String name){
      //Ce constructeur a un paramètre, un nom.
      System.out.println("Passed Name is :" + name );
   }

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

   public int getAge( ){
       System.out.println("Puppy's age is :" + puppyAge );
       return puppyAge;
   }

   public static void main(String []args){
      /*  Création d'objet */
      Puppy myPuppy = new Puppy( "tommy" );
      /* Méthode de classe d'appel pour définir l'âge du chiot */
      myPuppy.setAge(2);
      /* Appelle une autre méthode de classe pour obtenir l'âge du chiot */
      myPuppy.getAge();
      /* Vous pouvez également accéder à la variable d'instance comme suit */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

Si nous compilez et exécutez le programme ci-dessus, cela produirait le résultat suivant:

Passed Name is : tommy

Puppy's age is : 2

Variable Value : 2

 Règles de déclaration du fichier source

Comme la dernière partie de cette section, examinons maintenant les règles de déclaration des fichiers sources. 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 classe publique par fichier source.
• Un fichier source peut avoir plusieurs classes non publiques.
• Le nom de la classe publique devrait également être le nom du fichier source qui devrait être ajouté par .java à la fin. Par exemple: le nom de la classe est. public class Employee{} Puis le fichier source doit être comme Employee.java.
• Si la classe est définie dans un package, l'énoncé du package doit être la première instruction dans le fichier source.
• Si les déclarations d'importation sont présentes, elles doivent être écrites entre l'énoncé du package et la déclaration de classe. S'il n'y a pas d'énoncés de package, l'instruction import doit être la première ligne dans le fichier source.
• Les instructions d'importation et de package impliquent toutes les classes présentes dans le fichier source. Il n'est pas possible de déclarer des déclarations d'importation et / ou de package différentes 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. J'expliquerai tout cela dans le chapitre Modificateurs d'accès.

Outre les types de classes mentionnés ci-dessus, Java possède également des classes spéciales appelées classes Inner et classes anonymes.

Les packages

En simple, c'est une façon 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, donc la catégorisation de ces classes est nécessaire et rend la vie beaucoup plus facile.

Déclarations d'importation

En Java, un nom complet, qui comprend le package et le nom de la classe, est donné alors le compilateur peut facilement localiser le code source ou les classes. L'énoncé d'importation est une façon 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.*;

Une étude de cas simple

Pour notre étude de cas, nous créerons deux classes. Ils sont Employee et EmployeeTest.

Ouvrez d'abord le bloc-notes et ajoutez le code suivant. Rappelez-vous que c'est la classe Employee et la classe est une classe publique. Maintenant, enregistrez ce fichier source avec le nom Employee.java.

La classe Employee comporte quatre variables d'instance, le nom, l'âge, la désignation et le salaire. La classe possède un constructeur explicitement défini, qui prend un paramètre.

import java.io.*;

public class Employee{
   String name;
   int age;
   String designation;
   double salary;

   // This is the constructor of the class Employee
   public Employee(String name){
      this.name = name;
   }

   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge){
      age =  empAge;
   }

   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }

   /* Assign the salary to the variable       salary.*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }

   /* Print the Employee details */
   public void printEmployee(){
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

Comme mentionné précédemment dans ce cours, le traitement commence à partir de la méthode principale. Par conséquent, dans l'ordre pour que nous puissions exécuter cette classe Employee, il devrait y avoir une méthode principale et des objets devraient être créés. Nous allons créer une classe distincte pour ces tâches.

Voici ci-dessous la classe EmployeeTest, qui crée deux instances de la classe Employee et invoque les méthodes pour chaque objet d'attribuer des valeurs pour chaque variable.

Enregistrez le code suivant dans le fichier EmployeeTest.java

import java.io.*;
public class EmployeeTest{

   public static void main(String args[]){
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

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

C:> javac Employee.java

C:> javac   EmployeeTest.java

C:> java EmployeeTest

Name:James Smith

Age:26

Designation:Senior Software Engineer

Salary:1000.0

Name:Mary Anne

Age:21

Designation:Software Engineer

Salary:500.0

• ← Syntaxe de base
• Sommaire du cours
• Les types de données de base →