caso di default di classe metodo

Question

applicare Supponendo che abbiamo la classe seguente caso:

case class CasePerson(firstName: String) 

E abbiamo anche definire un oggetto compagno per esso:

object CasePerson { 
def apply() = new CasePerson("XYZ") 
} 

noti che nell'esempio di cui sopra ho definito in modo esplicito un oggetto associato con un metodo apply, senza definire il metodo di applicare il predefinito:

// This "default" apply has the same argument as the primary constructor of the case class 
def apply(firstName : String) = new CasePerson(firstName) 

Q: Quindi, dove viene applicato questo "predefinito" di Scala? Ho esplicitamente definito il compagno oggetto qui senza il default applicare e il compilatore sa ancora come eseguire questo:

val casePerson = CasePerson("PQR") 

Come funziona?

Answer 1

Le classi dei casi Scala sono zucchero sintattico. Quando crei una classe case, il compilatore Scala creerà un oggetto companion con un apply e un metodo unapply per te, che potrai quindi utilizzare come se esistesse semplicemente. Here è un collegamento a informazioni più approfondite sulle classi dei casi.

Answer 2

È inoltre possibile assegnare al parametro di classe firstName un valore predefinito. Quindi puoi creare un'istanza senza passare nessun parametro.

Esempio:

case class CasePerson(firstName : String = "XYZ") 
val person = CasePerson() 

Answer 3

classi di casi sono implicitamente accompagnati da un oggetto associato con una apply() che ha gli stessi argomenti del costruttore principale della classe caso.

Cioè:

case class CasePerson(firstName: String) 

sarà accompagnata da

object CasePerson{ 
    def apply(firstName: String) = new CasePerson(firstName) 
} 

Ora, se anche si definisce in modo esplicito un oggetto associato, si può pensare ad esso come aggiungendo a quello implicitamente definito.

Per esempio, nel tuo esempio è stato aggiunto un nuovo apply all'oggetto compagna:

object CasePerson{ 
    def apply() = new CasePerson("XYZ") 
} 

Questa affermazione, si può pensare ad esso come se si sta creando un oggetto compagno combinato:

object CasePerson{ 
    def apply() = new CasePerson("XYZ") // the one manually added 
    def apply(firstName: String) = new CasePerson(firstName) // this one is automatically added 
} 

Ora, se si decide di aggiungere la propria versione di apply con gli stessi argomenti del costruttore principale, questo oscurerà il comportamento predefinito della classe case.

object CasePerson{ 
    def apply() = new CasePerson("XYZ") 
    def apply(s: String) = Seq(new CasePerson(s), new CasePerson(s)) // will replace the default factory for the case class 
} 

Ora, se si chiama CasePerson("hi") sarà invece generate:

List(CasePerson("hi"), CasePerson("hi"))