Java - Objet et classes

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
• Cours
• Objets
• Instance
• Méthode
• Transmission de messages

Dans ce chapitre, nous examinerons les concepts - Classes et Objets.

• Objet − Les objets ont des états et des comportements. Exemple :Un chien a des états - couleur, nom, race ainsi que des comportements - remuer la queue, aboyer, manger. Un objet est une instance d'une classe.

• Classe − Une classe peut être définie comme un modèle/plan directeur qui décrit le comportement/l'état que l'objet de son type prend en charge.

Objets en Java

Examinons maintenant en profondeur 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 - aboiement, remue la queue, court.

Si vous comparez l'objet logiciel avec un objet du monde 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 des champs et son comportement est affiché via des méthodes.

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

Cours en Java

Une classe est un plan à partir duquel des objets individuels sont créés.

Voici un exemple de classe.

Exemple

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

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

Une classe peut contenir n'importe lequel des types de variables suivants.

• Variables locales − Les variables définies à l'intérieur des méthodes, constructeurs ou 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 à l'intérieur d'une classe mais en dehors de toute méthode. Ces variables sont initialisées lors de l'instanciation de la classe. 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.

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, aboyer(), faim() et dormir() sont des méthodes.

Voici quelques-uns des sujets importants qui doivent être abordés lors de l'examen des classes du langage Java.

Constructeurs

Lors de la discussion 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 des constructeurs est qu'ils doivent avoir le même nom que la classe. Une classe peut avoir plusieurs constructeurs.

Voici un exemple de constructeur −

Exemple

public class Puppy {
   public Puppy() {
   }

   public Puppy(String name) {
      // This constructor has one parameter, name.
   }
}

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

Remarque − Nous avons deux types de constructeurs différents. Nous allons discuter des constructeurs en détail dans les chapitres suivants.

Créer un objet

Comme mentionné précédemment, une classe fournit les plans des 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 à partir d'une classe −

• Déclaration − Une déclaration de variable avec un nom de variable avec 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 nouvel objet.

Voici un exemple de création d'un objet −

Exemple

Démo en direct

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 compilons et exécutons le programme ci-dessus, il produira le résultat suivant -

Sortie

Passed Name is :tommy

Accéder aux variables et méthodes d'instance

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

/* First create an object */
ObjectReference = new Constructor();

/* Now call a variable as follows */
ObjectReference.variableName;

/* Now you can call a class method as follows */
ObjectReference.MethodName();

Exemple

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

Démo en direct

public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Name chosen 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) {
      /* Object creation */
      Puppy myPuppy = new Puppy( "tommy" );

      /* Call class method to set puppy's age */
      myPuppy.setAge( 2 );

      /* Call another class method to get puppy's age */
      myPuppy.getAge( );

      /* You can access instance variable as follows as well */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

Si nous compilons et exécutons le programme ci-dessus, il produira le résultat suivant -

Sortie

Name chosen is :tommy
Puppy's age is :2
Variable Value :2

Règles de déclaration du fichier source

Dans la dernière partie de cette section, examinons maintenant les règles de déclaration du fichier source. Ces règles sont essentielles lors de la déclaration de classes, import déclarations et paquet déclarations 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 être ajouté par .java à la fin. Par exemple :le nom de la classe est public class Employee{} alors le fichier source devrait être comme Employee.java.

• Si la classe est définie dans un package, l'instruction 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 pas d'instructions 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 pour différentes classes dans le 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 chapitre sur les modificateurs d'accès.

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

Package Java

En termes simples, 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. La catégorisation de ces classes est donc indispensable et facilite grandement la vie.

Importer des relevés

En Java, si un nom complet, qui inclut 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é au compilateur pour trouver cette classe particulière.

Par exemple, la ligne suivante demanderait 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 allons créer deux classes. Ce sont Employee et EmployeeTest.

Ouvrez d'abord le bloc-notes et ajoutez le code suivant. N'oubliez pas qu'il s'agit de la classe Employee et que la classe est une classe publique. Maintenant, enregistrez ce fichier source sous le nom Employee.java.

La classe Employé a quatre variables d'instance - nom, âge, désignation et salaire. La classe a un constructeur explicitement défini, qui prend un paramètre.

Exemple

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 didacticiel, le traitement commence à partir de la méthode principale. Par conséquent, pour que nous puissions exécuter cette classe Employee, il doit y avoir une méthode principale et des objets doivent être créés. Nous allons créer une classe distincte pour ces tâches.

Voici le EmployeeTest class, qui crée deux instances de la classe Employee et appelle les méthodes de chaque objet pour attribuer des valeurs à 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 −

Sortie

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

Quelle est la prochaine ?

Dans la prochaine session, nous discuterons des types de données de base en Java et de la manière dont ils peuvent être utilisés lors du développement d'applications Java.