Java

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Objets et classes en Java

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
  •    Classes
  •    Objets
  •    Instance
  •    Méthode
  •    Passage des messages

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

  •     Objet - Les objets ont des états et des comportements. Exemple: Une Lampe a des isOn, ainsi que comportements - allumer, éteindre. Un objet est une instance d'une classe.
  •     Classe - Une classe peut être définie en tant que modèle décrivant le comportement/l'état pris en charge par l'objet de ce type.

Classes en Java

Une classe est un modèle à partir duquel des objets individuels sont créés.

Syntaxe :
                                class < class_name>{  
                                        attributs;  
                                        méthodes;  
                                    } 
                            
Exemple 1 :
                                class Lampe {

                                    // variable d'instance (attribut)
                                    private boolean isOn;

                                    // méthode
                                    public void allumer() {
                                        isOn = true;
                                    }

                                    // méthode
                                    public void eteindre() {
                                        isOn = false;
                                    }
                                }
                            

Ici, nous avons défini une classe nommée Lampe.
La classe a une variable d'instance isOn et deux méthodes allumer() et eteindre(). Ces variables et méthodes définies dans une classe sont appelées membres de la classe.

Remarquez deux mots clés, private et public dans le programme ci-dessus. Ce sont des modificateurs d'accès qui seront détaillés dans les cours suivants. Pour l'instant, rappelez-vous:

  •     Le mot-clé private rend les variables d'instance et les méthodes private qui ne sont accessibles qu'à partir de la même classe.
  •     Le mot-clé public rend publiques les variables d'instance et les méthodes accessibles de l'extérieur de la classe.

Une classe peut contenir l'un des types de variable suivants.

  •     Variables locales - Les variables définies dans des méthodes, des constructeurs ou des blocs sont appelées variables locales. La variable sera déclarée et initialisée dans la méthode et sera détruite une fois la méthode 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 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.

Constructeurs

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

Exemple 2 :
                                class Lampe {

                                    // variable d'instance (attribut)
                                    private boolean isOn;

                                    // constructeur par défaut
                                    public Lampe(){
                                        isOn=false;
                                    }

                                    // Ce constructeur a un paramètre, etat.
                                    public Lampe(boolean etat){
                                        this.isOn=etat;
                                    }

                                    // méthode
                                    public void allumer() {
                                        isOn = true;
                                    }

                                    // méthode
                                    public void eteindre() {
                                        isOn = false;
                                    }
                                }
                            

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 des constructeurs en détail dans les cours suivants.

Objets en Java

Comme mentionné précédemment, une classe fournit un modèle 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 pour créer 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 nouveau objet.
Exemple 3 :
                                class Lampe {

                                    // variable d'instance (attribut)
                                    private boolean isOn;
    
                                    // constructeur par défaut
                                    public Lampe(){
                                        this.isOn=false;
                                        System.out.println("je suis le constructeur par défaut");
                                    }
    
                                    // Ce constructeur a un paramètre, etat.
                                    public Lampe(boolean etat){
                                        this.isOn=etat;
                                        System.out.println("je suis le constructeur d'initialisation");
                                    }
    
                                    // méthode
                                    public void allumer() {
                                        isOn = true;
                                    }
    
                                    // méthode
                                    public void eteindre() {
                                        isOn = false;
                                    }

                                    // méthode principale 
                                    public static void main(String args[]){

                                        Lampe l1= new Lampe();
                                        Lampe l2 = new Lampe(false);
                                    }
                                }
                            
je suis le constructeur par défaut je suis le constructeur d'initialisation

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

Les variables et méthodes d'instance sont accessibles via des objets créés.
Vous pouvez accéder aux membres à l'aide de l'opérateur point ".".

Syntaxe:
                                // D'abord créer un objet
                                ReferenceObjet = new Constructor()

                                // appelez une variable comme suit
                                ReferenceObjet.nomVariable

                                // appelez une méthode de classe
                                ReferenceObjet.nomMethode()
                            
Exemple 4 :
                                class Lampe {

                                    // variable d'instance (attribut)
                                    private boolean isOn;
    
                                    // constructeur par défaut
                                    public Lampe(){
                                        this.isOn=false;
                                    }
    
                                    // méthode
                                    public void allumer() {
                                        isOn = true;
                                        System.out.println("Allumer ");
                                    }
    
                                    // méthode
                                    public void eteindre() {
                                        isOn = false;
                                        System.out.println("éteindre ");
                                    }

                                    // méthode principale 
                                    public static void main(String args[]){

                                        Lampe l1= new Lampe();
                                        l1.allumer();
                                        l1.eteindre();
                                    }
                                }
                            
Allumer
éteindre

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 être le nom du fichier source et doit être ajouté par "".java" à la fin. Par exemple: le nom de la classe est public class Employe{}, le fichier source doit alors être Employe.java.
  •     Si la classe est définie dans un package, l'instruction de 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 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 package 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 cours des modificateurs d'accès.

Outre les types de classes mentionnés ci-dessus, Java dispose également de 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. Par conséquent, la catégorisation de ces classes est indispensable et facilite la vie.

Instructions d'importation

En Java, si un nom complet, comprenant 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é pour que le compilateur trouve cette classe particulière.

Par exemple, la ligne suivante demande au compilateur de charger toutes les classes disponibles dans le répertoire java_installation/java/io

                                import java.io.*;
                            

Ce cours est juste une introduction de base sur les classes et objets. plus tard, nous discuterons en détail de toutes les notions liées aux classes et aux objets

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :