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:

  • Polymorphism
  • Inheritance
  • Encapsulation
  • Abstraction
  • Classes
  • Objects
  • Instance
  • Method
  • Message passant

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

  • Object- Les objets ont des états et des comportements. Exemple: un chien a des états - couleur, nom, race ainsi que comportements - remuant la queue, aboyant, mangeant. Un objet est une instance d'une classe.

  • Class - Une classe peut être définie comme un modèle / plan qui décrit le comportement / l'état pris en charge par l'objet de son type.

Objets en Java

Examinons maintenant ce que sont les objets. Si l'on considère le monde réel, on peut 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, son état est - son nom, sa race, sa couleur et son comportement - 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 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.

Cours en Java

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

Voici un exemple d'une 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.

  • Local variables- 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.

  • Instance variables- Les variables d'instance sont des 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 sont accessibles depuis n'importe quelle méthode, constructeur ou blocs de cette classe particulière.

  • Class variables - 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, barking (), hungry () et sleeping () 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 plus d'un constructeur.

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 dans lesquelles vous ne pourrez créer qu'une seule instance d'une classe.

Note- 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 -

  • Declaration - Une déclaration de variable avec un nom de variable avec un type d'objet.

  • Instantiation - Le mot-clé 'new' est utilisé pour créer l'objet.

  • Initialization- 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

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 -

Production

Passed Name is :tommy

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

Les variables et méthodes d'instance sont accessibles via les objets créés. Pour accéder à une variable d'instance, voici le chemin d'accès 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.

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 -

Production

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, d' instructions d' importation et d' 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 être ajouté par .javaà la fin. Par exemple: le nom de la classe est la classe publique Employee {} alors le fichier source doit être comme Employee.java.

  • Si la classe est définie dans un package, alors 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 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 à 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 a également des classes spéciales appelées classes internes et classes anonymes.

Package Java

En termes simples, c'est une manière 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.Par conséquent, la catégorisation de ces classes est indispensable et rend la vie beaucoup plus facile.

Importer des déclarations

En Java, si un nom complet, qui comprend 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 Employee 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 démarre à 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 la classe EmployeeTest , qui crée deux instances de la classe Employee et appelle les méthodes de chaque objet pour affecter 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 -

Production

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.