two primary new method expected data constructors syntax constructor kotlin

syntax - primary - Kotlin constructor secundario



new in kotlin (8)

¿Cómo declaro un constructor secundario en Kotlin?

¿Hay alguna documentación sobre eso?

Siguiendo no compila ...

class C(a : Int) { // Secondary constructor this(s : String) : this(s.length) { ... } }


Acabo de ver esta pregunta y creo que puede haber otra técnica que suene incluso mejor que las propuestas por Andrey.

class C(a: Int) { class object { fun invoke(name: String) = C(name.length) } }

Que puede escribir algo como val c:C = C(3) o val c:C = C("abc") , porque los métodos de invoke funcionan de la misma manera que los métodos de apply funcionan en Scala.

Actualizar

A partir de ahora, los constructores secundarios ya forman parte de la especificación del idioma, por lo que esta solución alternativa no debe utilizarse.


Como señala la documentación , puede usar un constructor secundario de esta manera

class GoogleMapsRestApiClient constructor(val baseUrl: String) { constructor() : this("https://api.whatever.com/") }

Recuerde que debe extender el primer comportamiento del constructor.


Ejemplo de constructor secundario de kotlin

class Person(name: String){ var name="" var age=0 constructor(age :Int,name : String) : this(name){ this.age=age this.name=name } fun display(){ print("Kotlin Secondary constructor $name , $age") } }

función principal

fun main(args : Array<String>){ var objd=Person(25,"Deven") objd.display() }


El siguiente fragmento de código debería funcionar

class C(a:Int){ constructor(s:String):this(s.length){..} }


Puede definir varios constructores en Kotlin con el constructor pero debe omitir la class AuthLog(_data: String) constructor predeterminada class AuthLog(_data: String)

class AuthLog { constructor(_data: String): this(_data, -1) constructor(_numberOfData: Int): this("From count ", _numberOfData) private constructor(_data: String, _numberOfData: Int) }

Para más detalles ver aquí


para declarar un constructor secundario, Kotlin solo usa la palabra clave constructor : como

este es un constructor primario:

class Person constructor(firstName: String) { }

o

class Person(firstName: String) { }

para el código de constructor secundario como este:

class Person(val name: String) { constructor(name: String, parent: Person) : this(name) { parent.children.add(this) } }

es obligatorio llamar al constructor primario; de lo contrario, el compilador lanzará el siguiente error

Primary constructor call expected


Actualización : desde M11 (0.11. *) Kotlin admite constructores secundarios .

Por ahora, Kotlin solo admite constructores primarios (los constructores secundarios pueden ser compatibles más adelante).

La mayoría de los casos de uso para constructores secundarios se resuelven mediante una de las siguientes técnicas:

Técnica 1. (resuelve su caso) Defina un método de fábrica al lado de su clase

fun C(s: String) = C(s.length) class C(a: Int) { ... }

uso:

val c1 = C(1) // constructor val c2 = C("str") // factory method

Técnica 2. (también puede ser útil) Definir valores predeterminados para parámetros

class C(name: String? = null) {...}

uso:

val c1 = C("foo") // parameter passed explicitly val c2 = C() // default value used

Tenga en cuenta que los valores predeterminados funcionan para cualquier función , no solo para los constructores

Técnica 3. (cuando necesite encapsulación) Use un método de fábrica definido en un objeto complementario

Algunas veces quiere que su constructor sea privado y solo un método de fábrica disponible para los clientes. Por ahora esto solo es posible con un método de fábrica definido en un objeto complementario :

class C private (s: Int) { companion object { fun new(s: String) = C(s.length) } }

uso:

val c = C.new("foo")


class Person(val name: String) { constructor(name: String, parent: Person) : this(name) { parent.children.add(this) } }

puedes probar esto