Maîtriser Java : Comprendre les Objets, Classes et Concepts POO de Base

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

• Polymorphisme
• Héritage
• Encapsulation
• Abstraction
• Classes
• Objets
• Instance
• Méthode
• Passage de messages

Dans ce chapitre, nous examinerons les concepts de 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 qui décrit le comportement/état que les objets de son type supportent.

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 : voitures, chiens, humains, etc. Tous ces objets ont un état et un comportement.

Si nous considérons un chien, son état est – nom, race, couleur – et son comportement est – aboyer, remuer la queue, courir.

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 logiciel, les méthodes opèrent sur l'état interne d'un objet et la communication objet-à-objet se fait via les méthodes.

Classes 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 l'un des types de variables suivants.

• Variables locales – Variables définies à l'intérieur de méthodes, constructeurs ou blocs. La variable sera déclarée et initialisée dans la méthode et sera détruite lorsque la méthode se terminera.

• Variables d'instance – Variables au sein d'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 accessibles depuis n'importe quelle méthode, constructeur ou bloc de cette classe particulière.

• Variables de classe – Variables déclarées dans une classe, en dehors de toute méthode, avec le mot-clé static.

Une classe peut avoir un nombre quelconque de méthodes pour accéder à la valeur de divers types de méthodes. Dans l'exemple ci-dessus, barking(), hungry() et sleeping() sont des méthodes.

Voici quelques-uns des sujets importants à discuter lors de l'examen des classes en Java.

Constructeurs

Lorsqu'on parle de 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 invoqué. La règle principale des constructeurs est qu'ils doivent avoir le même nom que la classe. Une classe peut avoir plus d'un constructeur.

Voici un exemple de constructeur :

Exemple

public class Puppy {
  public Puppy() { }
  public Puppy(String name) {
    // Ce constructeur a un paramètre, name.
  }
}

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

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

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 mot-clé new 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 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 nouvel objet.

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

Exemple

Live Demo

public class Puppy {
  public Puppy(String name) {
    // Ce constructeur a un paramètre, name.
    System.out.println("Passed Name is :" + name );
  }
  public static void main(String []args) {
    // L'instruction suivante créerait un objet 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ès aux variables d'instance et aux méthodes

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

/* D'abord créer un objet */
ObjectReference = new Constructor();
/* Maintenant appeler 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.

Live Demo

public class Puppy {
  int puppyAge;
  public Puppy(String name) {
    // Ce constructeur a un paramètre, 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) {
    /* Création de l'objet */
    Puppy myPuppy = new Puppy( "tommy" );
    /* Appel de la méthode de classe pour définir l'âge du chiot */
    myPuppy.setAge( 2 );
    /* Appel d'une autre méthode de classe pour obtenir l'âge du chiot */
    myPuppy.getAge( );
    /* Vous pouvez accéder à la variable d'instance comme suit également */
    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 des fichiers sources

En tant que dernière partie de cette section, examinons les règles de déclaration des fichiers sources. Ces règles sont essentielles lors de la déclaration de classes, d'instructions import et 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 également, avec .java à la fin. Par exemple : le nom de la classe est public class Employee{} alors le fichier source doit être 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 import sont présentes, elles doivent être écrites entre l'instruction package et la déclaration de classe. S'il n'y a pas d'instructions package, l'instruction import doit être la première ligne du fichier source.

• Les instructions import et package s'appliquent à toutes les classes présentes dans le fichier source. Il n'est pas possible de déclarer différentes instructions import et/ou 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 en parlerons dans le chapitre sur les modificateurs d'accès.

En plus des types de classes mentionnés ci-dessus, Java a aussi des 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 interfaces seront écrites, donc les catégoriser est indispensable et facilite grandement la vie.

Instructions Import

En Java, si un nom pleinement qualifié, 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 import 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.*;

Étude de cas simple

Pour notre étude de cas, nous allons créer deux classes : Employee et EmployeeTest.

Ouvrez d'abord le bloc-notes et ajoutez le code suivant. Rappelez-vous que c'est la classe Employee et qu'elle est une classe publique. Enregistrez maintenant ce fichier source sous le nom Employee.java.

La classe Employee a quatre variables d'instance : name, age, designation et salary. 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;
  // Constructeur de la classe Employee
  public Employee(String name) {
    this.name = name;
  }
  // Assigne l'âge de l'employé à la variable age.
  public void empAge(int empAge) {
    age = empAge;
  }
  /* Assigne la désignation à la variable designation. */
  public void empDesignation(String empDesig) {
    designation = empDesig;
  }
  /* Assigne le salaire à la variable salary. */
  public void empSalary(double empSalary) {
    salary = empSalary;
  }
  /* Affiche les détails de l'employé */
  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 tutoriel, le traitement commence par la méthode main. Par conséquent, pour exécuter cette classe Employee, il doit y avoir une méthode main et des objets doivent être créés. Nous allons créer une classe séparée pour ces tâches.

Voici la classe EmployeeTest, qui crée deux instances de la classe Employee et invoque les méthodes pour chaque objet afin d'assigner des valeurs à chaque variable.

Enregistrez le code suivant dans EmployeeTest.java.

import java.io.*;
public class EmployeeTest {
  public static void main(String args[]) {
    /* Création de deux objets en utilisant le constructeur */
    Employee empOne = new Employee("James Smith");
    Employee empTwo = new Employee("Mary Anne");
    // Invocation des méthodes pour chaque objet créé
    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 et exécutez EmployeeTest pour voir le résultat :

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 suite ?

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