OpenSearch:Classes et objets

class Example {
    double PI;
    Example() {
        PI = 3.1415926;
    }
    static int main() {
        Example example = new Example();
        double a = example.PI; // 3.1415926
        return 0;
    }
}

Définir une classe

Utilisez le mot-clé class pour définir une classe. Une définition de classe peut inclure n'importe quelle combinaison des éléments suivants :

class Example {                    // Define a class named Example.
    public double PI;              // Member variable
    Example() {                    // Constructor
        PI = 3.1415926;
    }
    double getPI() {               // Member function
        return PI;
    }
    static int main() {
        Example example = new Example();
        double a = example.getPI(); // 3.1415926
        return 0;
    }
}

Créer un objet

La création d'un objet à partir d'une classe comporte trois étapes :

1. Déclaration : déclarez une variable et spécifiez son type de classe.

2. Instanciation : utilisez le mot-clé new pour allouer l'objet.

3. Initialisation : spécifiez un constructeur après new pour initialiser l'objet.

Comme Java et C#, Cava requiert le mot-clé new pour créer un objet. Les trois étapes peuvent être combinées sur une seule ligne.

class Example {
    double PI;
    Example() {
        PI = 3.1415926;
    }
    static int main() {
        Example example = new Example(); // Declare, instantiate, and initialize in one line.
        return 0;
    }
}

Une fois l'objet créé, utilisez la variable (example) pour accéder à ses données membres.

Variables membres

Une variable membre contient les données de l'objet concerné.

class Example {
    double PI; // Member variable of type double
    Example() {
        PI = 3.1415926;
    }
}

Initialisez les variables membres dans un constructeur, et non au moment de la déclaration. L'affectation d'une valeur initiale lors de la déclaration n'est pas prise en charge.

// Not supported
class Example {
    double PI = 3.1415926;
}

// Correct
class Example {
    double PI;
    Example() {
        PI = 3.1415926;
    }
}

Constructeurs

Un constructeur initialise un objet juste après sa création. Les constructeurs doivent respecter deux exigences :

• Le nom du constructeur doit correspondre au nom de la classe.

• Un constructeur n'a ni valeur de retour ni paramètres de sortie.

Cava prend en charge plusieurs constructeurs (surcharge de constructeurs). La syntaxe de l'expression new détermine quel constructeur est appelé.

class Example {
    public double PI;
    Example() {                        // Constructor A: default
        this.PI = 3.1415926;
    }
    Example(double customPI) {         // Constructor B: accepts a custom value
        this.PI = customPI;
    }
    double getPI() {
        return PI;
    }
    static int main() {
        Example example1 = new Example();       // Calls Constructor A
        double a = example1.getPI();            // 3.1415926

        Example example2 = new Example(3.14);   // Calls Constructor B
        double b = example2.getPI();            // 3.14
        return 0;
    }
}

Fonctions membres

Une fonction membre encapsule les opérations sur les variables membres d'un objet. Appelez une fonction membre via une instance d'objet pour lire ou modifier ses données.

class Example {
    public double PI;
    Example() {
        this.PI = 3.1415926;
    }
    double getPI() {
        return PI;
    }
    static int main() {
        Example example = new Example();
        double a = example.getPI(); // 3.1415926
        return 0;
    }
}

Les fonctions membres prennent en charge la surcharge : définissez plusieurs fonctions portant le même nom dans une classe, et le compilateur sélectionne la bonne en fonction du type et du nombre de paramètres d'entrée.

Lorsqu'une variable locale dans une fonction membre porte le même nom qu'une variable membre, la variable locale est prioritaire. Pour accéder explicitement à la variable membre, préfixez-la avec this .

Fonctions de classe

Une fonction de classe appartient à la classe, et non à un objet individuel. Elle est partagée par toutes les instances et peut être appelée directement via le nom de la classe, sans nécessiter la création d'un objet.

Définissez une fonction de classe avec le mot-clé static :

class Example {
    static double getPI() { // Class function — accessible without creating an object
        return 3.1415926;
    }
    static int main() {
        double a = Example.getPI(); // Call via class name, not an object instance
        return 0;
    }
}

À titre de comparaison : les fonctions membres nécessitent une instance d'objet, tandis que les fonctions de classe n'en ont pas besoin.

Limitations

Cava ne prend pas en charge l'héritage de classes.