introduction

La dernière fois, j'ai écrit un article "Je m'intéresse à la programmation web donc je vais étudier", mais cette fois c'est Java: lunettes de soleil: J'étudiais Java depuis plus de deux ans dans une classe universitaire, mais je ne le comprenais pas du tout, alors je n'ai résumé que les parties nécessaires sous forme de cahier. J'ai également écrit sur l'orientation objet dans cet article, mais je pense que c'est important car cela ** conduit également à une compréhension de l'orientation objet en PHP et JavaScript **. Eh bien, merci: information_desk_person:

Déclaration de classe

Une classe est un ensemble de processus requis pour exécuter un programme. Écrivez le début et le délimiteur du mot en majuscules et en nomenclature. L'état et le comportement de la classe sont définis dans la partie processus d'exécution. La façon de l'écrire est la suivante.

nom de classe de classe{
Traitement d'exécution...
}

En Java, un fichier et une classe sont le principe. Dans ce qui suit, il est écrit de manière à ce qu'il y ait plusieurs classes dans un fichier, mais lorsque vous écrivez réellement le code, veuillez les séparer. (Pourquoi seulement 1 classe publique dans le fichier Java)

À propos des variables de membre (champs)

Une variable membre définit l'état d'une classe et peut déclarer des variables de type de base, de type de classe et de type tableau. L'ordre de déclaration des variables membres est «nom de variable de type qualificatif». Type de base: ʻint id; Type de classe:Test a = nouveau test; Type de tableau: ʻint a []; ʻor ʻint [] a;
Les variables membres incluent des variables de classe et des variables d'instance. Les variables de classe sont des types avec «static» devant elles. Les variables d'instance sont des variables qui n'ont pas de «static».


public class Test{
    int id = 1; //Variable membre (variable d'instance)
    static int value = 200; //Variable membre (variable de classe)

    void student(){ //Ceci est une méthode
        System.out.println(id);
        System.out.println(value);
    }
}

De plus, les variables membres peuvent être référencées à partir de n'importe quelle méthode ou constructeur qui tente de référencer l'état de cette classe. Cependant, les variables locales, qui sont des variables qui définissent l'état de chaque méthode et constructeur, ne peuvent être référencées qu'à partir de chaque méthode et constructeur.


public class Student{
    int grade = 1; //Variables de membre
    void student1(){
        int id_1 = 7; //Variables locales
        System.out.println(grade); //Peut être référencé car il s'agit d'une variable membre
        System.out.println(id_1); //Peut être référencé car il s'agit d'une variable locale déclarée dans student1
        System.out.println(id_2); //Ne peut pas être référencé car il s'agit d'une variable locale déclarée dans student2 ×
    }
    void student2(){
        int id_2  = 1000;
        System.out.println(grade); //Peut être référencé car il s'agit d'une variable membre
        System.out.println(id_1); //Ne peut pas être référencé car il s'agit d'une variable locale déclarée dans student1 ×
    }
}

Méthode

Une méthode définit le comportement au sein d'une classe. Il se compose des formats suivants.

Modificateur Type de données de la valeur de retour Nom de la méthode (type d'argument nom de l'argument)....）{
Corps de la méthode
}

① Type de données de valeur de retour

La valeur de retour est la valeur à renvoyer à l'appelant de la méthode. Si aucune valeur n'est renvoyée (il n'y a pas de valeur de retour), elle est décrite comme un type void. Un exemple est écrit ci-dessous.


public class Return {
    public static void print() {  //Puisqu'il s'agit d'un type void, il ne renvoie pas de valeur de retour
        System.out.println("It all returns to nothing");
    }
    public static int add(int x) {
        int result = x + 1999;
        return result;  //L'instruction return renvoie la valeur du résultat.
    }

    public static void main(String[] args) {
        int result = add(1); //Spécifiez la variable avec le même type que la valeur renvoyée par return pour plus de clarté
        print(); //Sortie "Tout revient à rien"
        System.out.println(result); //Sortie comme "2000"
    }
}

② Argument

Décrivez l'argument lorsqu'il est nécessaire d'hériter de la valeur de la méthode. Comment écrire est (type d'argument nom d'argument formel ....) Le type d'argument représente le type de la valeur à hériter et le nom d'argument formel représente le nom de variable qui ne peut être référencé que dans la méthode. S'il n'y a aucune valeur à hériter, seul () est utilisé. La méthode pour lire la méthode avec l'argument est nom de la méthode (valeur 1, valeur 2, ...);, et quand il est lu, le nom passe de ** argument formel ** à ** argument réel **.


public class Argument {
    public static void  main(String[] args){
        rabbithouse("Tomono Kafu"); //← Argument réel
        rabbithouse("Hoto Shinai");
        rabbithouse("Riyo Tenzenza");
        amausaan("Chiya Ujimatsu");
        fleur_du_lapin("Kirima Saji");
    }
    public static void rabbithouse(String name){ //← Argument formel
        System.out.println("Maison de lapin:"+ name);
    }
    public static void amausaan(String name){
        System.out.println("Kantoan:" + name);
    }
    public static void fleur_du_lapin(String name){
        System.out.println("Fleur de Lapin:" + name);
    }
}

Le résultat de l'exécution sera comme ça.

Maison de lapin:Tomono Kafu
Maison de lapin:Hoto Shinai
Maison de lapin:Riyo Tenzenza
Kantoan:Chiya Ujimatsu
Fleur de Lapin:Kirima Saji

Qualificatif

Il existe les types suivants de modificateurs Java. (J'ai omis un peu)

① Modificateur d'accès

public: Aucune restriction, peut être référencé de n'importe où protected: accessible uniquement à partir de la même classe, dans le même package, ou de ses sous-classes private: ne peut être référencé qu'à partir de la même classe. Les variables membres sont souvent «privées» pour apprendre de l'encapsulation. «Aucun»: dites package privé. Il ne peut être librement accessible que depuis l'intérieur du package avec le modificateur d'accès omis.

②static Indique qu'il s'agit d'une variable de classe. Vous pouvez y accéder sans instancier la classe, vous pouvez donc y accéder avec nom de classe.nom de membre.

③final Si vous le déclarez sur une classe, vous ne pourrez pas hériter de la classe. De plus, si elle est attachée à une méthode, la sous-classe ne peut pas remplacer la méthode.

À propos des instances et des objets

De là, je vais aborder l'orientation des objets. En tant qu'image, considérez une classe comme un dessin de conception, un objet comme un objet (tel qu'un humain ou une voiture) et une instance comme une entité créée à partir du dessin de conception. .. ..
L'instance est créée au format suivant. Nom de la classe Nom de la variable = nouveau nom de la classe (argument); Il existe deux façons de faire référence à une instance. Nom de la variable Nom de la variable membre; Nom de la variable Nom de la méthode;

** Mis à jour le 8 juin ** En Java, il existe une convention de dénomination selon laquelle toutes les variables membres (champs) et les noms de méthode sont tous inférieurs, et dans le cas de caractères composés, le délimiteur est supérieur. On dit qu'il s'agit d'un cas de chameau, mais il a commenté qu'il s'agit d'une méthode de description générale. .. !! Dans ce qui suit, le nom de la variable est défini sur "A" etc., mais ce n'est pas courant, donc j'apprécierais que vous puissiez le compléter ...: bow_tone1:

Un exemple est écrit ci-dessous.


class Instance {
    String name = "Destructeur de type rosée blanche "Yutachi""; //Variables de membre

    void shipType(){ //Méthode
        System.out.println("Destructeur");
    }
}

class MainClass{
    public static void main(String[] args) {
        Instance A = new Instance();
        System.out.println(A.name); //Ici, sortie comme "Destructeur de type rosée blanche" Yutachi ""
        A.shipType(); //Sortez "Destroyer" ici
    }
}

statique et non statique

J'ai mentionné un peu les variables membres (champs) et les modificateurs ci-dessus, mais je les expliquerai plus en détail ici.

Les méthodes et les variables avec statique sont référencées de diverses manières dans les livres de référence et sur le net, telles que «méthode statique», «méthode statique», «méthode de classe» et «variable de classe». Ne vous fâchez pas: peureux: Inversement, les méthodes et les variables qui n'ont pas de statique sont appelées «méthodes d'instance», «méthodes non statiques» et «variables d'instance».

méthode statique

Étant donné que la méthode statique est une méthode de la classe, elle peut être appelée par d'autres méthodes statiques, des méthodes d'instance ou une autre classe sans créer d'instance à l'aide de ** new **. Cependant, lors de l'appel dans votre propre classe, vous pouvez utiliser method name ();, mais lors de l'appel dans une autre classe, vous devez utiliser class name.method name ();. De plus, les méthodes statiques seront partagées et utilisées par cette classe. Par conséquent, le processus ne change pas, peu importe où vous l'appelez, donc s'il existe un processus ou des données communs dans la conception, la méthode statique est bonne.

Méthode d'instance

Une méthode identifiée pour chaque objet instancié à l'aide du nouvel opérateur. Par conséquent, ** vous devez toujours créer et appeler une instance. ** **

Résumé


class Method1 {

    //méthode statique, méthode statique, méthode de classe
    static void staticMethod1() {

        // instanceMethod();Ce n'est pas bien!Vous ne pouvez pas (directement) accéder aux méthodes d'instance (dans la même classe) à partir de méthodes statiques.

        Method1 a = new Method1(); //Créer une instance de la classe
        a.instanceMethod(); //Vous pouvez accéder aux méthodes d'instance avec un accès indirect via l'instance.
    }

    //méthode statique / méthode statique
    static void staticMethod1_1() {
        staticMethod1(); //Puisqu'il s'agit d'un appel depuis votre propre classe, vous n'avez pas besoin d'un nom de classe.

        Method1.staticMethod1(); //Vous pouvez toujours l'appeler.
    }

    //Méthode d'instance / méthode non statique
    void instanceMethod() {
        staticMethod1(); //Appel d'une méthode statique à partir d'une méthode d'instance(accès)Aussi ok sans nom de classe

        Method1.staticMethod1(); //Vous pouvez toujours l'appeler.
    }
}

//Une autre classe
class Method2 {
    static void staticMethod2() {

        // staticMethod1();Ce n'est pas bien!

        Method1.staticMethod1(); //Lors d'un appel depuis une autre classe, le nom de la classe.nom de méthode statique

        // instanceMethod();Ce n'est pas bien!

        Method1 b  = new Method1(); //Lors de l'accès à une méthode d'instance d'une autre classe, accédez à la méthode d'instance via l'instance
        b.instanceMethod();

        Method2 c = new Method2(); //L'accès aux méthodes d'instance de votre classe est le même.
        c.instanceMethod2();
    }

    void instanceMethod2() {
        Method1.staticMethod1_1(); //Un nom de classe est requis lors de l'appel d'une méthode statique d'une autre classe à partir d'une méthode d'instance!
        staticMethod2();
        Method3.staticMethod3();
    }
}

class Method3 extends Method1{
    static void staticMethod3() {
        staticMethod1(); //Lorsqu'il est hérité, il peut être appelé sans avoir besoin d'un nom de classe

        //instanceMethod();Ce n'est pas bon pour l'héritage. Assurez-vous de créer une instance de la classe et d'y accéder

        Method1 d = new Method1();
        d.instanceMethod();
    }

    void instanceMethod3() {
        staticMethod1();
    }
}

constructeur

Un constructeur est exécuté lorsqu'une instance d'une classe est créée et est un processus qui vous permet de déterminer et d'initialiser les valeurs des variables membres. Pour appeler le constructeur, la méthode avec le même nom de classe que lors de la création de l'instance avec nom de classe nom de variable = nouveau nom de classe (argument); est le constructeur **. En d'autres termes, il peut également être exprimé comme nom de la variable nom de classe = nouveau nom du constructeur (argument).

Exemple de constructeur sans argument (constructeur par défaut) *


public class Constructor1{
    String name = "Aoyama Blue Mountain";

    public Constructor1(){
        System.out.println(name);
    }
}
class Main{
    public static void main(String[] args) {
        Constructor1 cs = new Constructor1();
    }
}

Le résultat de l'exécution est le suivant.

Aoyama Blue Mountain

Exemple de constructeur avec arguments *


public class Constructor2{
    public Constructor2(String str){
        System.out.println(str);
    }
}
class Main{
    public static void main(String[] args){
        Constructor2 A = new Constructor2("Hello");
    }
}

Le résultat de l'exécution est le suivant.

Hello

À propos de ça

① Ceci qui pointe vers votre propre variable d'instance et méthode d'instance

Utilisez «this» lorsque les noms de variable des variables membres (champs) et des variables locales sont identiques. Si cela n'est pas ajouté, les variables locales définies dans la méthode prévaudront et les variables membres (champs) ne seront pas référencées.


class ThisClass{
    private int number;
    public void setNumber(int number){ //Variables locales(argument)La valeur de nombre est une variable membre(Plier)En remplaçant le nombre de
        this.number = number + 100;
    }
    public int getNumber(){
        return this.number;
    }
}

class Main{
    public static void main(String[] args) {
        ThisClass A = new ThisClass();
        A.setNumber(1);
        System.out.println(A.getNumber()); //Il est sorti comme 101.
    }
}

Par rapport à la classe Student écrite dans l'en-tête ci-dessus «À propos des variables membres (champs)», avec ou sans «this» selon que les noms de variable des variables membres (champs) et des variables locales sont identiques. Veuillez juger.

② Appelez un autre constructeur depuis le constructeur this ()

Utilisez this () lorsque vous voulez décrire le traitement commun dans un seul constructeur et appelez ce traitement depuis un autre constructeur. Il est différent de celui écrit en ①.


class ThisConstructor {
    private String ShopName;
    private String CharacterName;

    public ThisConstructor(String shopName , String CharacterName){
        this.ShopName = shopName;
        this.CharacterName = CharacterName;
    }

    //Définition de la valeur par défaut
    public ThisConstructor(){
        this("Maison de lapin" , "Tomono Kafu");
    }

    //Initialisation du champ
    public void print(){
        System.out.println(ShopName+" : "+CharacterName);
    }
}

class Main{
    public static void main(String[] args) {
        ThisConstructor tc1 = new ThisConstructor();
        tc1.print();

        ThisConstructor tc2 = new ThisConstructor("Maison de lapin" , "Riyo Tenzenza");
        tc2.print();
    }
}

[Introduction à Java] J'ai essayé de résumer les connaissances que j'estime essentielles