[Java] Syntaxe orientée objet --Constructeur

constructeur

• Lors de l'utilisation d'une classe ** Une méthode appelée lors de l'instanciation (création d'un objet) avec le nouvel opérateur **
• Utilisé pour décrire l'initialisation du champ et la préparation des ressources externes utilisées dans la classe
• ** Modificateurs d'accès disponibles ** * public, protected, private
• ** Aucune valeur de retour **
• La valeur de retour n'est pas nulle et ** le type lui-même ne peut pas être décrit **
• La commande return ne peut pas être utilisée
• ** Ne peut pas être nommé librement **
• Rendre le nom identique au nom de la classe
• Définissez l'argument sur le champ correspondant dans le constructeur
• Les arguments et les champs ont le même nom
• this. field name = argument;
• S'il existe à la fois un initialiseur de champ et un constructeur, l'initialisation du constructeur a la priorité.

//Nom de l'argument dans le constructeur/Définissez l'âge dans le champ correspondant
public class Person {
  public String name;
  public int age;

  //constructeur
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public String show() {
    return String.format("%s（%ré).", this.name, this.age);
  }
}

ConstBasic.java

public class ConstBasic {
  public static void main(String[] args) {
    var p = new Person("Yamada Taro", 30);
    System.out.println(p.show()); //Je suis Taro Yamada (30 ans).
  }
}

Constructeur par défaut

• Un constructeur vide sans arguments qui est généré implicitement lorsque la définition est omise **
• Ce qui suit est le même
• Notez qu'une erreur se produira lors de l'ajout d'un constructeur avec des arguments.

public class MyClass{
}

public class MyClass{
    public MyClass(){
    }
}

Surcharge

• Le constructeur peut avoir plusieurs signatures *　StringBuilder()
• StringBuilder (String str): Génère un objet StringBuilder avec une chaîne de caractères
• StringBuilder (capacité int): Génère un objet StringBuilder avec chaîne de caractères et capacité
• Utilisez ceci pour appeler une surcharge avec des arguments correspondants
• ** Cet appel est au début du constructeur! ** **

Person.java

public class Person {
  public String name;
  public int age;

  //constructeur
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public Person() {
    //Appeler le constructeur
    this("Hello Kitty", 46);
  }

  public void show() {
    System.out.printf("%s（%ré).\n", this.name, this.age);
  }
}

ConstructorBasic.java

public class ConstructorBasic {

  public static void main(String[] args) {
    var p = new Person();
    p.show(); //Je suis Kitty (46 ans).
  }
}

Bloc d'initialisation

• ** Bloc anonyme directement sous la classe {...} **
• ** Exécuter avant le constructeur lors de l'instanciation **
• ** Code découpé commun à plusieurs constructeurs ** Rôle
• Tout d'abord, donnez la priorité au constructeur
• La surcharge représentant la valeur par défaut de l'initialisation n'est pas le bloc d'initialisation mais cette priorité d'appel

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;

public class Person {
  public String name;
  public int age;
  public LocalDateTime updated;

  //Bloc d'initialisation
  {
    this.updated = LocalDateTime.now();
  }
  //Prénom et nom,Initialiser à partir de l'anniversaire
  public Person(String firstName, String lastName, LocalDate birth) {
    this.name = lastName + " " + firstName;
    this.age = Period.between(birth, LocalDate.now()).getYears();
  }
  //Nom,Initialiser à partir de l'âge
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

Méthode d'usine

• ** Méthode d'instanciation **
• Créez uniquement une instance et renvoyez-la comme valeur de retour
• Rendre le constructeur privé pour qu'il ne puisse être instancié que via des méthodes d'usine
• var fc = FactoryClass.getInstance();
• mérite
• ** Peut être nommé librement **
• cf: Constructeur non autorisé
• ** Vous n'êtes pas obligé de créer une instance **
• Instances en cache réutilisables (modèle singleton, etc.)
• ** Le type de retour peut être abstrait / type d'interface **
• Puisqu'il s'agit d'une méthode, la valeur de retour peut renvoyer n'importe quelle classe dérivée / implémentée
• La dépendance à la classe d'implémentation peut être limitée à la classe d'usine

public class FactoryClass {
  //constructeur privé
  private FactoryClass() {
    System.out.println("Usine!!");
  }
  //Méthode d'usine
  public static FactoryClass getInstance() {
    return new FactoryClass();
  }
}