Classes Java : écriture de vos propres classes, constructeurs

Salut! Aujourd'hui, nous allons parler des classes en Java. On pourrait dire que les classes constituent la pierre angulaire de la programmation Java. Lorsque vous devenez programmeur, la quasi-totalité de votre travail consiste à écrire vos propres classes qui ont diverses fonctions. Voyons ce que cela signifie et comment cela fonctionne. :) Comme vous le savez, Java est un langage de programmation orienté objet. Tous les programmes sont constitués d'objets qui, d'une manière ou d'une autre, sont liés les uns aux autres. Une classe est, essentiellement, un modèle pour un objet. Il détermine à quoi ressemblera l'objet et quelles fonctions il aura. Chaque objet est un objet d'une certaine classe. Considérez cet exemple très simple :

public class Cat {

    String name;
    int age;

}

Disons que nous écrivons un programme qui implique des chats pour une raison quelconque (par exemple, nous avons une clinique vétérinaire qui offre un accès à un compte en ligne). Nous avons créé une classe Cat et y avons déclaré deux variables : String name et int age . Ces variables membres sont appelées champs. Il s'agit essentiellement d'un modèle pour tous les chats que nous créerons à l'avenir. Chaque objet Cat aura deux variables : un nom et un âge.

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";

        System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
    }

}

Voici comment cela fonctionne! Nous créons un chat, lui donnons un nom et un âge, et affichons le tout sur la console. Part de gâteau. :) Le plus souvent, les cours décrivent des choses et des phénomènes du monde réel. Un chat, une table, une personne, un éclair, une page de livre, une roue, vous créerez toutes ces choses dans vos programmes en utilisant des classes individuelles. Pour l'instant, concentrons-nous sur les variables que nous avons déclarées dans la classe Cat . Ils sont appelés champs ou variables d'instance. Leur nom dit vraiment tout. Chaque instance (ou objet) de la classe Cat aura ces variables. Chaque chat que nous créons aura sa propre variable de nom et son propre âgevariable. Cela a du sens - c'est essentiellement comme ça avec les vrais chats. :) En plus des variables d'instance, il existe également des variables de classe (variables statiques). Terminons notre exemple :

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";
        count++;

        Cat fluffy = new Cat();
        fluffy.age = 5;
        fluffy.name = "Fluffy";
        count++;

        System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
        System.out.println("We created a cat named " + fluffy.name + ". His age is " + fluffy.age);

        System.out.println("Total number of cats = " + count);
    }
}

Sortie console : Nous avons créé un chat nommé Smudge. Son âge est de 3 ans Nous avons créé un chat nommé Fluffy. Son âge est de 5 ans Nombre total de chats = 2 Maintenant, notre classe a une nouvelle variable appelée nombre. Il est chargé de compter les chats créés. Chaque fois que nous créons un chat dans l' ensembleméthode, on augmente cette variable de 1. Cette variable est déclarée à l'aide du mot clé static. Cela signifie qu'il appartient à la classe, et non à un objet spécifique de la classe. Ce qui, bien sûr, a du sens : le nom de chaque chat appartient à ce chat spécifique, mais nous avons besoin d'un compteur de chat qui s'applique à tous. C'est précisément ce que fait le mot-clé static : il fait de la variable count une variable unique pour tous les chats. Remarque : lorsque nous affichons la variable, nous n'utilisons pas smudge.count ou fluffy.count. Il n'appartient ni à Smudge ni à Fluffy ; il appartient à toute la classe Cat . C'est pourquoi c'est simplement compter. Vous pouvez également écrire Cat.count. Ce serait également correct. Lors de l'affichage de la variable de nom, nous ne ferions pas ce qui suit :

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";
        count++;

        System.out.println("We created a cat named " + name + ". His age is " + smudge.age);

        System.out.println("Total number of cats = " + count);
    }
}

C'est une erreur ! Chaque chat a son propre nom. Le compilateur est confus ici. "Afficher un nom sur la console ? Le nom de qui ?" :/"

Méthodes

En plus des variables, chaque classe a des méthodes. Nous en parlerons plus en détail dans une leçon séparée, mais les principes généraux sont assez simples. Les méthodes définissent la fonctionnalité de votre classe, c'est-à-dire ce que les objets de votre classe peuvent faire. Vous connaissez déjà l'une de ces méthodes : la méthode main() . Mais, comme vous vous en souvenez peut-être, la méthode principale est statique, ce qui signifie qu'elle appartient à toute la classe (la logique est la même qu'avec les variables). Cependant, les méthodes standard non statiques ne peuvent être appelées que sur des objets spécifiques que nous avons créés. Par exemple, si nous voulons écrire une classe de chat, nous devons savoir quelles fonctions un chat dans notre programme devrait avoir. Sur cette prémisse, écrivons quelques méthodes pour notre chat :

public class Cat {

    String name;
    int age;

    public void sayMeow() {
        System.out.println("Meow!");
    }

    public void jump() {
        System.out.println("Pounce!");
    }

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";

        smudge.sayMeow();
        smudge.jump();

    }
}

Vérifiez-le! Maintenant, notre classe ressemble beaucoup plus à un chat ! Maintenant, nous n'avons pas seulement un chat avec un nom ("Smudge") et un âge (3). Il peut aussi dire miaou et sauter ! Quel genre de chat serait-il sans cette "fonctionnalité" ? :) Nous prenons un objet spécifique (smudge) et appelons ses méthodes sayMeow() et jump() . Regardons la console : Miaou ! Bondir! Un vrai chat ! :)

Création de vos propres classes. Abstraction

À l'avenir, vous devrez écrire vos propres classes. À quoi devez-vous faire attention lorsque vous les écrivez ? Si nous parlons de variables, vous devrez utiliser quelque chose appelé abstraction. L'abstraction est l'un des quatre principes de base de la programmation orientée objet. Cela signifie extraire les caractéristiques les plus importantes et les plus significatives d'un élément et, inversement, écarter celles qui sont mineures ou insignifiantes. Par exemple, créons un classeur pour les employés de l'entreprise. Pour créer des objets Employee, nous avons écrit un Employeeclasse. Quelles caractéristiques sont des descripteurs importants d'un employé pour le classeur de notre entreprise ? Nom, date de naissance, SSN et ID d'employé. Mais il est peu probable que nous ayons besoin de la taille, de la couleur des yeux ou de la couleur des cheveux de l'employé pour le dossier de l'employé de l'entreprise. Les entreprises n'ont pas besoin de ces informations. Ainsi, dans la classe Employee , nous déclarons les variables suivantes : String name , int age , int socialSecurityNumber et int employeeId. Et nous laissons de côté les informations inutiles (comme la couleur des yeux). En d'autres termes, nous créons une abstraction. Cependant, si nous fabriquons un classeur pour les agences de mannequins, la situation change radicalement. La taille, la couleur des yeux et la couleur des cheveux d'un modèle sont des caractéristiques importantes, mais son SSN n'a absolument aucune importance pour nous. Ainsi, dans la classe Model , nous devons créer les variables suivantes : String height , String hair , String eyes . C'est ainsi que fonctionne l'abstraction - c'est facile ! :)

Constructeurs

Revenons à notre exemple de chat.

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat smudge = new Cat();

        System.out.println("Here the program does something for 2 hours...");

        smudge.age = 3;
        smudge.name = "Smudge";

    }
}

Examinez ce code et essayez de comprendre ce qui ne va pas avec notre programme. Notre programme avait un chat sans nom ni âge pendant 2 heures ! Bien sûr, c'est intrinsèquement faux. La base de données de la clinique vétérinaire ne devrait pas inclure de chats sans information. Actuellement, notre chat est à la merci du programmeur. Nous espérons qu'il n'oubliera pas de préciser un nom et un âge, et que tout ira bien. S'il oublie, la base de données aura un problème : des chats sans nom. Comment pouvons-nous résoudre ce problème ? Nous devons en quelque sorte empêcher que des chats soient créés sans nom ni âge. C'est là que les constructeurs viennent à la rescousse. Donnons un exemple :

public class Cat {

    String name;
    int age;

    // Constructor for the Cat class
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
    }
}

Essentiellement, un constructeur est un modèle pour les objets d'une classe. Dans ce cas, nous indiquons que deux arguments, un String et un int , doivent être spécifiés pour chaque objet cat . Si nous essayons de créer un chat sans nom maintenant, cela ne fonctionnera pas.

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // Error!
    }
}

Maintenant que la classe a un constructeur, le compilateur Java sait à quoi les objets doivent ressembler et n'autorise pas la création d'objets sans spécifier les arguments. Maintenant, examinons le mot-clé this, que vous voyez à l'intérieur du constructeur. C'est simple aussi. Le mot-clé this sert à indiquer un objet particulier. Le code dans le constructeur

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

peut être interprété presque textuellement : "Le nom de ce chat (celui que nous créons) = l'argument passé pour le paramètre de nom du constructeur. L'âge de ce chat (celui que nous créons) = l'argument passé pour le nom du constructeur paramètre d'âge." Une fois le constructeur exécuté, vous pouvez vérifier que toutes les valeurs nécessaires ont été attribuées à notre chat :

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
        System.out.println(smudge.name);
        System.out.println(smudge.age);
    }
}

Sortie console : Smudge 5 Lorsque le constructeur a été appelé :

Cat smudge = new Cat("Smudge", 5);

Voici ce qui s'est réellement passé en interne :

this.name = "Smudge";
this.age = 5;

Et les valeurs des arguments passés au constructeur ont été affectées à l' objet smudge (c'est à cela que cela fait référence dans ce cas). En fait, même si vous ne déclarez aucun constructeur dans une classe, elle appellera quand même un constructeur ! Mais comment est-ce possible ? О_О Parce que toutes les classes Java ont un constructeur dit par défaut. Il ne prend aucun argument, mais il est invoqué chaque fois que vous créez un objet de n'importe quelle classe.

public class Cat {

    public static void main(String[] args) {

        Cat smudge = new Cat(); // The default constructor is invoked here
    }
}

À première vue, cela peut ne pas être évident. Nous avons créé un objet, et alors ? Où le constructeur fait-il quelque chose ici ? Pour le voir, écrivons explicitement un constructeur vide pour la classe Cat . À l'intérieur, nous afficherons une phrase sur la console. Si la phrase est affichée, le constructeur a été appelé.

public class Cat {

    public Cat() {
        System.out.println("A cat has been created!");
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // The default constructor is invoked here
    }
}

Sortie console : Un chat a été créé ! Voilà la confirmation. Le constructeur par défaut est toujours présent de manière invisible dans vos classes. Mais vous devez savoir une chose de plus à ce sujet. Le constructeur par défaut est éliminé d'une classe une fois que vous avez créé un constructeur avec des arguments. En fait, nous en avons déjà vu la preuve ci-dessus. C'était dans ce code :

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // Error!
    }
}

Nous ne pouvions pas créer un Cat sans nom ni âge, car nous avons déclaré un constructeur Cat avec des paramètres string et int. Cela a provoqué la disparition immédiate du constructeur par défaut de la classe. N'oubliez donc pas que si vous avez besoin de plusieurs constructeurs dans votre classe, y compris un constructeur sans argument, vous devrez le déclarer séparément. Notre clinique veut faire de bonnes actions et aider les chatons sans abri dont les noms et les âges sont inconnus. Ensuite, notre code devrait ressembler à ceci :

public class Cat {

    String name;
    int age;

    // For cats with owners
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // For street cats
    public Cat() {
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
        Cat streetCat = new Cat();
    }
}

Maintenant que nous avons spécifié un constructeur par défaut explicite, nous pouvons créer les deux types de chats. Dans le constructeur, vous pouvez affecter des valeurs directement. Vous n'avez pas à toujours les prendre à partir d'arguments. Par exemple, nous pourrions étiqueter tous les chats de rue dans la base de données en utilisant "Street cat No. <count>" comme modèle. :

public class Cat {

    String name;
    int age;

    static int count = 0;

    public Cat() {
        count++;
        this.name = "Street cat No. " + count;
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat streetCat1 = new Cat();
        Cat streetCat2 = new Cat();
        System.out.println(streetCat1.name);
        System.out.println(streetCat2.name);
    }
}

Nous avons une variable de comptage , qui compte nos chats de rue. Chaque fois que le constructeur par défaut est exécuté, nous augmentons le nombre de 1 et attachons ce nombre au nom du chat. L'ordre des arguments est très important pour les constructeurs. Échangeons les arguments name et age passés à notre constructeur.

public class Cat {

    String name;
    int age;

    public Cat(int age, String name) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 10); // Error!
    }
}

Nous avons une erreur ! Le constructeur stipule clairement que lorsqu'un objet Cat est créé, il faut lui passer un nombre et une chaîne, dans cet ordre. Donc, notre code ne fonctionne pas. Assurez-vous de vous rappeler et de respecter cette règle lorsque vous déclarez vos propres classes :

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

public Cat(int age, String name) {
    this.age = age;
    this.name = name;
}

Ce sont deux constructeurs totalement différents ! Maintenant, effectuez quelques tâches pour consolider votre compréhension du matériau. :)

Musée des Antiquités.

Votre tâche consiste à concevoir une classe d'artefacts .
Il existe trois types d'artefacts conservés au musée.
On ne sait rien du premier type si ce n'est le numéro de série attribué par le musée (par exemple : 212121).
Pour le second type, nous connaissons le numéro de série et la culture qui l'a créé (par exemple : 212121, « Aztèques »).
Pour le troisième type, nous connaissons le numéro de série, la culture qui l'a créé et le siècle au cours duquel il a été créé (par exemple : 212121, "Aztèques", 12).

Créez une classe Artefact qui décrit les antiquités conservées au musée et écrivez l'ensemble de constructeurs requis pour la classe. Ensuite, dans la méthode main() , créez un artefact de chaque type.
```
public class Artifact {

    // Write your code here

    public static void main(String[] args) {
        // Write your code here
    }
}
```
Site de rencontre

Créons une base de données d'utilisateurs pour un site de rencontres.
Mais voici le problème : vous avez oublié l'ordre requis des arguments et aucune documentation technique n'est disponible.
Concevez une classe User , qui aura les champs suivants : name ( String ), age ( short ) et height ( int ).
Créez le nombre approprié de constructeurs, afin que le nom, l'âge et la hauteur puissent être spécifiés dans n'importe quel ordre.
```
public class User {

    String name;
    short age;
    int height;

    // Write your code here

    public static void main(String[] args) {

    }
}
```

Pour renforcer ce que vous avez appris, nous vous suggérons de regarder une leçon vidéo de notre cours Java

Plus de lecture :
Cours anonymes Classes imbriquées statiques Classes internes imbriquées Relations entre classes. Héritage, composition et agrégation La différence entre les classes abstraites et les interfaces