Objets et classes Java

En tant que langage de programmation orienté objet, Java prend en charge les concepts de base suivants :

1, Classe：

  • Un modèle qui définit des objets, incluant les attributs et les méthodes.
  • Exemple :public class Car { ... }

2. Objet：

  • Une instance d'une classe, possédant un état et un comportement.
  • Exemple :Car myCar = new Car();

3. Héritage：

  • Une classe peut hériter des attributs et des méthodes d’une autre classe.
  • Exemple :public class Dog extends Animal { ... }

4. Encapsulation：

  • Rendre l’état de l’objet (champs) privé et y accéder via des méthodes publiques.
  • Exemple :
    private String name; 
public String getName() { return name; }

5. Polymorphisme：

  • Les objets peuvent se présenter sous plusieurs formes, principalement mises en œuvre au moyen de la surcharge et de la redéfinition de méthodes.
  • Exemple :
    • Surcharge de méthodes :public int add(int a, int b) { ... }etpublic double add(double a, double b) { ... }
    • Redéfinition de méthode :@Override public void makeSound() { System.out.println("Meow"); }

6. Abstraction：

  • Utiliser des classes abstraites et des interfaces pour définir des méthodes qui doivent être implémentées, sans fournir d’implémentations concrètes.
  • Exemple :
    • Classe abstraite :public abstract class Shape { abstract void draw(); }
    • Interface :public interface Animal { void eat(); }

7. Interface：

  • Définit les méthodes qu'une classe doit implémenter, en prenant en charge l'héritage multiple.
  • Exemple :public interface Drivable { void drive(); }

8. Méthode：

  • Définit le comportement d'une classe ; fonctions contenues dans une classe.
  • Exemple :public void displayInfo() { System.out.println("Info"); }

9. Surcharge de méthode：

  • La même classe peut avoir plusieurs méthodes portant le même nom mais avec des paramètres différents.
  • Exemple :
    public class MathUtils {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

Dans cette section, nous nous concentrons sur les concepts d'objets et de classes.

  • Objet: Un objet est une instance d'une classe (un objet, ce n'est pas trouver une petite amie), et il a un état et un comportement.
  • Classe: Une classe est un modèle qui décrit le comportement et l'état d'un type d'objet.

Dans la figure ci-dessousgarçon、filleestclasse, et chaque personne spécifique est unobjet：

Dans la figure ci-dessousvoitureestclasse, et chaque voiture spécifique est unevoiturede la classeobjet, et l'objet contient la couleur, la marque, le nom, etc. de la voiture.

Objets en Java

Maintenant, cherchons à mieux comprendre ce qu'est un objet. Regardez le monde réel autour de vous ; vous trouverez de nombreux objets autour de vous, tels que des voitures, des chiens, des personnes, etc. Tous ces objets ont leur propre état et leur propre comportement.

Prenons un chien comme exemple : son état comprend le nom, la race et la couleur, et son comportement comprend aboyer, remuer la queue et courir.

Si l'on compare les objets du monde réel avec les objets logiciels, ils sont très similaires.

Les objets logiciels ont aussi un état et un comportement. L'état d'un objet logiciel correspond à ses attributs, et son comportement se reflète à travers des méthodes.

Dans le développement logiciel, les méthodes opèrent sur les modifications de l'état interne des objets, et l'invocation mutuelle des objets s'effectue également au moyen de méthodes.

Les classes en Java

Une classe peut être considérée comme un modèle pour créer des objets Java.

Créez une classe simple comme indiqué dans la figure ci-dessus pour comprendre la définition d'une classe en Java :

public class Dog { String breed; int size; String colour; int age; void eat() { } void run() { } void sleep(){ } void name(){ } }

Une classe peut contenir les types de variables suivants :

  • Variables locales: Les variables définies dans les méthodes, les constructeurs ou les blocs d'instructions sont appelées variables locales. La déclaration et l'initialisation de la variable se font toutes deux dans la méthode, et lorsque la méthode se termine, la variable est automatiquement détruite.
  • Variables membres: Les variables membres sont des variables définies dans une classe mais en dehors du corps des méthodes. Ces variables sont instanciées lorsqu'un objet est créé. Les variables membres peuvent être accédées par les méthodes, les constructeurs et les blocs d'instructions d'une classe spécifique.
  • Variables de classe: Les variables de classe sont également déclarées dans une classe, en dehors du corps des méthodes, mais elles doivent être déclarées comme static.

Une classe peut avoir plusieurs méthodes. Dans l'exemple ci-dessus, eat(), run(), sleep() et name() sont toutes des méthodes de la classe Dog.

Méthodes de constructeur

Chaque classe a un constructeur. Si un constructeur n'est pas explicitement défini pour une classe, le compilateur Java fournira un constructeur par défaut pour cette classe.

Lors de la création d'un objet, au moins un constructeur doit être appelé. Le nom du constructeur doit être identique au nom de la classe, et une classe peut avoir plusieurs constructeurs.

Voici un exemple de constructeur :

public class Puppy{ public Puppy(){ } public Puppy(String name){ //Ce constructeur n'a qu'un seul paramètre : name } }

Création d'objets

Les objets sont créés à partir de classes. En Java, le mot-clé new est utilisé pour créer un nouvel objet. La création d'un objet nécessite les trois étapes suivantes :

  • Déclaration: Déclarez un objet, y compris le nom de l'objet et le type d'objet.
  • Instanciation: Utilisez le mot-clé new pour créer un objet.
  • Initialisation: Lorsqu'un objet est créé avec new, le constructeur est appelé pour initialiser l'objet.

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

public class Puppy{ public Puppy(String name){ //Ce constructeur n'a qu'un seul paramètre : name System.out.println("Le nom du chiot est :" + name ); } public static void main(String[] args){ //L'instruction suivante créera un objet Puppy Puppy myPuppy = new Puppy( "tommy" ); } }

Compilez et exécutez le programme ci-dessus, et il affichera le résultat suivant :

小狗的名字是 : tommy

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

Accéder aux variables membres et aux méthodes membres via l'objet créé, comme indiqué ci-dessous :

/*Instancier l'objet*/ Object referenceVariable = new Constructeur(); /*Accéder aux variables de la classe*/ referenceVariable.variableName; /*Accéder aux méthodes de la classe*/ referenceVariable.methodName();

L'utilisation du type Object pour déclarer une variable ne permet d'accéder, au moment de la compilation, qu'aux méthodes et propriétés de la classe Object ; mais à l'exécution, vous pouvez la convertir en un type spécifique pour une conversion de type, afin d'accéder aux méthodes et propriétés de ce type spécifique.

Exemple

L'exemple suivant montre comment accéder aux variables d'instance et appeler des méthodes membres :

Code du fichier Puppy.java :

public class Puppy { private int age; private String name; //Constructeur public Puppy(String name) { this.name = name; System.out.println("Le nom du chiot est :" + name); } //Définir la valeur de age public void setAge(int age) { this.age = age; } //Obtenir la valeur de age public int getAge() { return age; } //Obtenir la valeur de name public String getName() { return name; } //Méthode Main public static void main(String[] args) { //Créer un objet Puppy myPuppy = new Puppy("Tommy"); //Définir age via une méthode myPuppy.setAge(2); //Appeler une autre méthode pour obtenir age int age = myPuppy.getAge(); System.out.println("L'âge du chiot est :" + age); //Vous pouvez également accéder directement aux variables membres (via les méthodes getter) System.out.println("Valeur de la variable :" + myPuppy.getAge()); } }

Compilez et exécutez le programme ci-dessus, ce qui produit le résultat suivant :

小狗的名字是 : tommy
小狗的年龄为 : 2
变量值 : 2

Règles de déclaration des fichiers source

Dans la dernière partie de cette section, nous allons apprendre les règles de déclaration des fichiers source. Lorsque plusieurs classes sont définies dans un fichier source, et qu'il y a également des instructions import et des instructions package, une attention particulière doit être portée à ces règles.

  • Un fichier source ne peut avoir qu'une seule classe public
  • Un fichier source peut avoir plusieurs classes non-public
  • Le nom du fichier source doit correspondre au nom de la classe public. Par exemple, si la classe public dans le fichier source est nommée Employee, alors le fichier source doit être nommé Employee.java.
  • Si une classe est définie dans un package, alors l'instruction package doit être la première ligne du fichier source.
  • Si un fichier source contient des instructions import, elles doivent être placées entre l'instruction package et la définition de la classe. S'il n'y a pas d'instruction package, les instructions import doivent se trouver tout au début du fichier source.
  • Les instructions import et l'instruction package sont valides pour toutes les classes définies dans le fichier source. Dans un même fichier source, vous ne pouvez pas donner à différentes classes des déclarations package différentes.

Les classes ont plusieurs niveaux d'accès, et les classes sont également divisées en différents types : classes abstraites, classes finales, etc. Ces notions seront présentées dans le chapitre sur le contrôle d'accès.

En plus des types mentionnés ci-dessus, Java possède également quelques classes spéciales, telles que :Classes internes、Classes anonymes。

Packages Java

Les paquetages sont principalement utilisés pour catégoriser les classes et les interfaces. Lors du développement de programmes Java, vous pouvez écrire des centaines ou des milliers de classes, il est donc nécessaire de catégoriser les classes et les interfaces.

Instructions import

En Java, si un nom qualifié complet est donné, incluant le nom du paquetage et le nom de la classe, le compilateur Java peut facilement localiser le code source ou la classe. L'instruction import est utilisée pour fournir un chemin raisonnable afin que le compilateur puisse trouver une certaine classe.

Par exemple, la ligne de commande suivante demandera au compilateur de charger toutes les classes sous le chemin java_installation/java/io.

import java.io.*;

Un exemple simple

Dans cet exemple, nous créons deux classes :EmployeeetEmployeeTest。

Ouvrez d'abord l'éditeur de code, collez le code suivant dedans, et enregistrez le fichier sous le nomEmployee.java。

La classe Employee possède quatre variables membres : name, age, designation et salary. Cette classe déclare explicitement une méthode constructeur, qui n'a qu'un seul paramètre.

Code du fichier Employee.java :

import java.io.*; public class Employee { private String name; private int age; private String designation; private double salary; //Constructeur de la classe Employee public Employee(String name) { this.name = name; } //Définir la valeur de age public void setAge(int age) { this.age = age; } //Obtenir la valeur de age public int getAge() { return age; } //Définir la valeur de designation public void setDesignation(String designation) { this.designation = designation; } //Obtenir la valeur de designation public String getDesignation() { return designation; } //Définir la valeur de salary public void setSalary(double salary) { this.salary = salary; } //Obtenir la valeur de salary public double getSalary() { return salary; } //Afficher les informations public void printEmployee() { System.out.println(this); } //Redéfinir la méthode toString @Override public String toString() { return "Nom :" + name + "\n" + "Âge :" + age + "\n" + "Poste :" + designation + "\n" + "Salaire :" + salary; } }

Tous les programmes Java commencent leur exécution à partir de la méthodemain. Pour exécuter ce programme, vous devez inclure la méthode main et créer un objet instance.

Ci-dessous se trouve la classe EmployeeTest, qui instancie deux instances de la classe Employee et appelle des méthodes pour définir les valeurs des variables.

Enregistrez le code suivant dans le fichier EmployeeTest.java.

Code du fichier EmployeeTest.java :

import java.io.*; public class EmployeeTest { public static void main(String[] args) { //Utilisez le constructeur pour créer deux objets Employee empOne = new Employee("EXAMPLE1"); Employee empTwo = new Employee("EXAMPLE2"); //Appelez les méthodes membres de ces deux objets empOne.setAge(26); empOne.setDesignation("Programmeur senior"); empOne.setSalary(1000); empOne.printEmployee(); empTwo.setAge(21); empTwo.setDesignation("Programmeur débutant"); empTwo.setSalary(500); empTwo.printEmployee(); } }

Compilez ces deux fichiers et exécutez la classe EmployeeTest, et vous pouvez voir le résultat suivant :

$ javac EmployeeTest.java Employee.java
$ java EmployeeTest 
名字:EXAMPLE1
年龄:26
职位:高级程序员
薪水:1000.0
名字:EXAMPLE2
年龄:21
职位:Example程序员
薪水:500.0
Autres extensions