[JAVA] [Scala] Constructeur

Je me promenais dans la référence officielle sur le constructeur Augji Reali (this (), ou .this), mais au lieu de ne pas le trouver, il y avait un article sur le constructeur comme information secondaire, donc le contenu est à peu près dans la littérature. C'est une traduction.

Le constructeur est utilisé pour initialiser l'état de l'objet. Comme les méthodes, un constructeur contient également un ensemble d'instructions qui sont exécutées lors de la création d'un objet.

Scala prend en charge deux types de constructeurs.

1. Constructeur principal
2. Constructeur Augji Reali

Lorsqu'un programme ne contient qu'un seul constructeur, il est appelé constructeur principal. Le constructeur principal et la classe partagent le même corps, de sorte que le programmeur n'a pas besoin de déclarer explicitement la création du constructeur.

class Hello(name) {
  // Statements
}

• Dans la syntaxe ci-dessus, le constructeur principal partage le même corps que la classe. Tout ce qui est défini dans le corps de la classe, à l'exception de la déclaration de méthode, fait partie du constructeur principal.

//Créer un constructeur principal
class Monster(name: String, attribute: String, attack: Int, defense: Int) {
  def status: String = {
    s"""
       |Name: $name
       |Attribute: $attribute
       |Attack: $attack
       |Defense: $defense
       |""".stripMargin
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    //Création et initialisation d'objets
    val dmg = new Monster("Dark Magician Girl", "Dark", 2000, 1700)
    println(dmg.status)
  }
}

Name: Dark Magician Girl
Attribute: Dark
Attack: 2000
Defense: 1700

• Le constructeur principal a zéro ou plusieurs paramètres.
• Si vous ne créez pas de constructeur dans votre programme, le compilateur créera automatiquement un constructeur principal lorsque vous créez un objet à partir d'une classe. Ce constructeur est appelé le constructeur principal par défaut et ne reçoit aucun paramètre.

//Créer un constructeur principal
class Nap {
  def zzz: String = {
    "Zzz.."
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    //Création et initialisation d'objets
    val nobita = new Nap
    println(nobita.nap)
  }
}

Zzz..

--Déclarer un paramètre de constructeur avec var vous permet de changer la valeur d'un champ et de générer une méthode getter et setter pour le champ. --Si vous déclarez un paramètre de constructeur avec val, vous ne pouvez pas modifier la valeur du champ. Seules les méthodes getter sont générées dans le champ.

• Si vous déclarez les paramètres du constructeur sans «var» ou «val», la visibilité du champ sera très limitée. Ni les méthodes getter ni les méthodes setter ne sont générées dans le champ. --Déclarer des paramètres de constructeur avec private var ou private val empêche la génération des méthodes getter et setter de champ. Seuls les membres de cette classe peuvent accéder au champ. --Seul le constructeur principal peut appeler le constructeur de la superclasse.
• Vous pouvez rendre le constructeur principal privé en utilisant le mot-clé private entre le nom de la classe et le paramètre.

//Avec paramètres
class Secret private (n: Int) {
  // Statements
}

//Aucun paramètre
class Privacy private {
  // Statements
}

• Vous pouvez définir des valeurs par défaut pour les paramètres lors de la déclaration d'un constructeur.

class User(val name: String = "Anonymous") {
  def show: String = s"Name: $name"
}

object Main {
  def main(args: Array[String]) = {
    val usr = new User
    println(usr.show)
  }
}

Les constructeurs autres que le constructeur principal sont appelés constructeurs augmentés et vous pouvez en créer autant que vous le souhaitez. Cependant, le programme n'a qu'un seul constructeur principal.

class Apple(product: String, model: String) {
  var color: String = ""

  def details: String = {
    s"""
      |Product name: $product
      |Model: $model
      |Color: $color
      |""".stripMargin
  }

  //Constructeur Augji Reali
  def this(name: String, model: String, color: String) = {
    //Démarrer le constructeur principal
    this(name: String, model: String)
    this.color = color
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val device: Apple = new Apple("iPhone", "iPhone 11 Pro", "Gold")
    println(device.details)
  }
}

Product name: iPhone
Model: iPhone 11 Pro
Color: Gold

Littérature

Scala Constructors - GeeksforGeeks