Tutoriel – Apprendre Java – 4 – Objets et classes

image_tutoriel_newstrottteur_java

Java est un langage orienté objet. En tant que langage doté de la fonction Orienté objet, Java prend en charge les concepts fondamentaux suivants:

  • Polymorphisme
  • Héritage
  • Encapsulation
  • Abstraction
  • Des classes
  • Objets
  • Exemple
  • Méthode
  • Analyse du message

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 – remuant la queue, aboyant, mangeant. Un objet est une instance d’une classe.
  • Class – Une classe peut être définie comme un modèle / blueprint qui décrit le comportement / état que l’objet de son type supporte.

 

Objets en Java

Regardons à présent 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, remuant la queue, en cours d’exécution.

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 des champs et le comportement est affiché via des méthodes.

Ainsi, dans le développement de logiciels, les méthodes agissent sur l’état interne d’un objet et la communication objet-objet est effectuée par 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.

  • 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 initialisées lorsque la classe est instanciée. Les variables d’instance peuvent être accessibles 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 un nombre quelconque de méthodes pour accéder à la valeur de différents types de méthodes. Dans l’exemple ci-dessus, barking(), hungry() et sleep() sont des méthodes.

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

 

Constructeurs

Lors de la discussion sur les classes, l’un des sous-thèmes 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 dans lesquelles vous ne pouvez créer qu’une seule instance d’une classe.

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

 

Créer 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 dans la création 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 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:

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, alors 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 des objets créés. Pour accéder à une variable d’instance, le chemin complet est le suivant:

/* 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, alors 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

Comme dernière partie de cette section, examinons maintenant les règles de déclaration du fichier source. Ces règles sont essentielles pour déclarer des classes, importer des instructions et des instructions de paquet 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 doit être comme Employee.java.
  • Si la classe est définie dans un package, l’instruction package doit être la première du fichier source.
  • Si des instructions d’importation sont présentes, elles doivent être écrites entre l’instruction package et la déclaration de classe. S’il n’y a aucune instruction 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 paquetage 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. Nous expliquerons tout cela dans le chapitre sur les modificateurs d’accès.

Mis à part les 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 d’interfaces seront écrites, donc la catégorisation de ces classes est un must et rend la vie beaucoup plus facile.

 

Déclarations d’importation

En Java, si un nom complet, qui inclut le package et le nom de la classe est donné, le compilateur peut facilement localiser le ou les fichiers source. La déclaration 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: Employee et EmployeeTest.

Commencez par ouvrir le bloc-notes et ajoutez le code suivant. Rappelez-vous que c’est la classe des employés et que la classe est une classe publique. Maintenant, enregistrez ce fichier source avec le nom Employee.java.

La classe des employés 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 tutoriel, le traitement commence à partir de la méthode principale. Par conséquent, pour que nous puissions exécuter cette classe Employé, il devrait y avoir une méthode principale et des objets devraient ê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 appelle les méthodes pour que chaque objet affecte 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

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Articles récents

Santé

illusions-d-optique-video
plages-cachees-newstrotteur
personnes-incroyables-newstrotteur
endroits-mysterieux-newstrotteur
science-inexpliquees-newstrotteur
mystères_jamais-resolues

Actualité