Génération d'instances de classe Java, partie 3

À propos de la rédaction d'un article

Je ne fais pas référence aux diapositives de classe, donc je pense que c'est expliqué sous un angle différent. Peut-être que je le dis (devrait).

S'il vous plaît laissez-moi savoir si vous pouvez faire une erreur car il s'agit d'une librairie publicitaire!

Il se compose de 4 parties

Part.1 Créons une instance Nettoyeur Part.2 avec constructeur Part.3 Contrôlons l'accès et limitons les valeurs entrantes ← Imakoko Part.4 Essayez d'utiliser des variables / méthodes de classe

Attache

La partie 2 a implémenté le constructeur. Un constructeur est une méthode spéciale qui n'est exécutée qu'une seule fois lorsqu'une instance est créée. Le constructeur peut être implémenté en écrivant le nom de la classe.

DigitalStudentCard.java


class DigitalStudentCard{
  //Numéro d'étudiant
  int num;

  //Nom
  String name;

  //constructeur
  DigitalStudentCard(int num, String name){
    //Argument num à l'instance num(this.num)Remplacer par
    this.num = num;

    //Aussi
    this.name = name;
  }

  //Méthode de sortie (obtenir une auto-introduction)
  String getSelfIntroduction(){
    return "Numéro d'étudiant: " + num + "Nom: " + name);
  }
}

Le constructeur est presque le même que la méthode, vous pouvez donc l'écrire de la même manière.

Limitons l'accès!

Quand j'entends parler de restrictions d'accès, je pense que quelque chose devrait être lié ... </ b>. C'est comme ça. Vous pouvez restreindre l'accès aux variables, méthodes et constructeurs en ajoutant private ou public! !!

Ces mots-clés sont parfois appelés modificateurs d’accès </ b>. La plupart des gens disent: "Pourquoi ne le rendez-vous pas privé?" Ou "N'est-ce pas public?"

Les types de ces modificateurs d'accès sont les suivants.

Qualificatif efficacité
public Accessible de n'importe où
(N'écris rien) Il est accessible de n'importe où dans le package. (J'expliquerai un jour)
protected extendsOuimplementsIl n'est accessible que lorsqu'il existe une relation parent-enfant avec. (J'expliquerai un jour)
private Il n'est accessible qu'à partir de cette classe ou instance.

j'écrirai

Ajoutons le modificateur d'accès private à num et name.

DigitalStudentCard.java


class DigitalStudentCard{
  //Numéro d'étudiant
  private int num;

  //Nom
  private String name;

  //constructeur
  DigitalStudentCard(int num, String name){
    //Argument num à l'instance num(this.num)Remplacer par
    this.num = num;

    //Aussi
    this.name = name;
  }

  //Méthode de sortie (obtenir une auto-introduction)
  String getSelfIntroduction(){
    return "Numéro d'étudiant: " + num + "Nom: " + name);
  }
}

Écrivez pour l'utiliser.

class UseClass{
  public static void main(String[] args){

    //Génération d'instance
    DigitalStudentCardtanaka = new DigitalStudentCard(118114, "Kakuei Tanaka");

    //Créer une autre instance
    DigitalStudentCardnoguchi = new DigitalStudentCard(118514, "Hideyo Noguchi");

    //production
    System.out.println(tanaka.getSelfIntroduction);
        //Numéro d'étudiant:118114 Nom:Kakuei Tanaka

    System.out.println(noguchi.getSelfIntroduction);
        //Numéro d'étudiant:118514 Nom:Hideyo Noguchi
  }
}

Rien ne change dans cet exemple, mais le style d'écriture suivant est NG.

tanaka.num = 114514;
    //Erreur de compilation

tanaka.name = "Kakuei Tanaka";
    //Erreur de compilation

Puisque «num» et «name» sont limités par le modificateur d'accès «private» afin qu'ils ne soient accessibles qu'à l'intérieur de l'instance, ils ne sont pas accessibles.

Pourquoi avez-vous besoin d'un tel tracas?

"C'est plus pratique et plus facile d'accès de n'importe où."

Certes, il semble qu'il vaut mieux écrire d'une manière que vous aimez sans restrictions. Mais vous pouvez faire ce que vous voulez </ b> ça ne vous ressemble pas?

alors. C'est dangereux. (Moins de vocabulaire)

S'il s'agit de la carte d'étudiant de Magimon, il serait irrésistible de réécrire le numéro d'inscription ou le nom de l'école sans autorisation. Même si vous le modifiez, il devrait y avoir des règles telles que les numéros et les noms que vous souhaitez suivre.

Implémentons une méthode appelée Getter / Setter </ b> pour créer une telle règle.

Faire un getter / setter

Soyez assuré que le simple fait de dire "ça s'appelle ainsi" ne signifie pas écrire une méthode spéciale </ b>. C'est comme ça que je l'ai souvent vu.

Il est prudent de nommer les getters / setters get 〇〇 () et set 〇〇 ().

DigitalStudentCard.java


class DigitalStudentCard{
  //Numéro d'étudiant
  private int num;

  //Nom
  private String name;

  //constructeur
  DigitalStudentCard(int num, String name){  
    //Je l'ai tellement fait que j'utilise un getter
    setNum(num);

    //Aussi
    setName(name);
  }

  //Méthode de sortie (obtenir une auto-introduction)
  String getSelfIntroduction(){
    return "Numéro d'étudiant: " + num + "Nom: " + name);
  }

  // -----ajouter à-----

  //Méthode qui ne renvoie que num (getter)
  int getNum(){
    return num;
  }

  //Méthode qui renvoie simplement name (getter)
  String getName(){
    return name;
  }

  //Méthode pour définir num (setter)
  void setNum(int number){
    //Pensez à utiliser le numéro d'inscription scolaire de notre école comme exemple
    //D'une certaine manière je vieillis
    int year = number/1000;

    //Interdire les valeurs supérieures à 119
    if(year > 118){
      year = 118;
    }

    //Extraire uniquement les cousins de type nombre
    number = number%1000;

    //Je veux l'adapter à 3 chiffres, donc si la valeur dépasse 999, réglez-la sur 999.
    if(number > 999){
      number = 999;
    }

    //Stick et retour
    return year*1000 + number;
  }

  //Méthode pour définir le nom (setter)
  void setName(String name){
    this.name = name;
  }
}

Appelons maintenant ces méthodes.

class UseClass{
  public static void main(String[] args){
    //Génération d'instance
    DigitalStudentCardtanaka = new DigitalStudentCard(118114, "Kakuei Tanaka");

    //Afficher la valeur de la variable num
    System.out.println(tanaka.getNum());
        // >> 118114

    //Afficher la valeur de la variable de nom
    System.out.println(tanaka.getName());
        //Kakuei Tanaka

    //Changer la valeur de la variable num
    tanaka.setNum(200, 1000);
        //Essayez de saisir une valeur élevée exprès

    //Changer la valeur de la variable de nom
    tanaka.setName("Tanaka Kakuei");
        //Je ne pouvais penser à rien, alors qu'est-ce que c'était?


    System.out.println(tanaka.getNum());
        // 118999
    System.out.println(tanaka.getName());
        //Tanaka Kakuei
  }
}

En faisant cela, je ne veux que «nonne»! Je ne veux que «nom»! Vous pouvez gérer cela en utilisant getNum () ou getName ().

Si vous souhaitez changer votre numéro d'inscription scolaire en raison de circonstances imprévues, ou si vous vous mariez et que votre nom de famille change, vous pouvez le définir en utilisant setNum () ou setName ().

Ce serait un problème si vous pouviez entrer une valeur désordonnée pour le numéro d'inscription de l'école, nous avons donc créé un mécanisme pour vérifier s'il s'agit d'une valeur appropriée. Puisque la valeur qui peut être entrée dans la variable «num» peut être limitée, on peut éviter de devenir une zone sans loi.

Puisque setNum () et setName () sont également utilisés dans le constructeur, il était possible d'effectuer le processus d'affectation à un seul endroit. En faisant cela, même s'il y a un bug plus tard, vous n'avez qu'à vérifier un endroit, il sera donc plus facile de le corriger! !!

Au fait

Les modificateurs d'accès peuvent également être utilisés pour les méthodes et les constructeurs.

private void setName(String name){
  //Quelque chose de traitement
}

Comme pour les variables, la plage d'accès est limitée à cette instance de classe.

la prochaine fois

Ensuite, accédons au même objet depuis différents endroits en utilisant des variables de classe et des méthodes de classe! Suivant → Part.4 Essayez d'utiliser des variables / méthodes de classe