Share
Kotlin es un lenguaje de programación moderno que compila a bytecode Java. Es gratuito y de código abierto, y promete hacer que la codificación para Android sea aún más divertida.
En el artículo anterior, aprendió usos avanzados de funciones, como funciones de extensión, cierres, funciones de orden superior y funciones en línea en Kotlin.
En esta publicación, obtendrá una introducción a la programación orientada a objetos en Kotlin al aprender acerca de las clases: constructores y propiedades, casting y características de clase más avanzadas que Kotlin facilita..
Una clase es una unidad de programa que agrupa funciones y datos para realizar algunas tareas relacionadas. Declaramos una clase en Kotlin usando el clase palabra clave-similar a Java.
Libro de clase
El código anterior es la declaración de clase más simple: acabamos de crear una clase vacía llamada Libro. Todavía podemos crear una instancia de esta clase incluso si no contiene un cuerpo utilizando su constructor predeterminado.
libro val = Libro ()
Como puede observar en el código anterior, no usamos el nuevo palabra clave para crear una instancia de esta clase como es habitual en otros lenguajes de programación. nuevo no es una palabra clave en Kotlin. Esto hace que nuestro código fuente sea conciso al crear una instancia de clase. Pero tenga en cuenta que la creación de instancias de una clase Kotlin en Java requerirá la nuevo palabra clave.
// En un libro de archivos de Java libro = nuevo libro ()
Veamos cómo agregar un constructor y propiedades a nuestra clase. Pero primero, veamos una clase típica en Java:
/ * Java * / public class Book título privado de la cadena; largo privado isbn; Libro público (Título de cadena, Long isbn) this.title = title; this.isbn = isbn; public String getTitle () return title; public void setTitle (String title) this.title = title; public Long getIsbn () return isbn; público void setIsbn (Long isbn) this.isbn = isbn;
Mirando a nuestro Libro modelo de clase anterior, tenemos los siguientes:
Accentsconagua
título y Isbn Ahora veamos cómo podemos escribir el código anterior en Kotlin en su lugar:
/ * Kotlin * / class Book var title: String var isbn: Long constructor (title: String, isbn: Long) this.title = title this.isbn = isbn
Una clase bastante ordenada! Ahora hemos reducido el número de líneas de código de 20 a solo 9. El constructor() función se llama una constructor secundario en Kotlin. Este constructor es equivalente al constructor de Java al que llamamos al crear una instancia de una clase.
En Kotlin, no hay un concepto de campo como el que puede estar familiarizado; en su lugar, utiliza el concepto de "propiedades". Por ejemplo, tenemos dos propiedades mutables (lectura-escritura) declaradas con el var palabra clave: título y Isbn en el Libro clase. (Si necesita una actualización de las variables en Kotlin, visite la primera publicación de esta serie: Variables, Tipos básicos y Arreglos).
Una cosa sorprendente es que el compilador de Kotlin genera automáticamente para nosotros los captadores y definidores de estas propiedades bajo el capó. Tenga en cuenta que no hemos especificado ningún modificador de visibilidad en estas propiedades, por lo que, de forma predeterminada, son públicos. En otras palabras, se puede acceder desde cualquier lugar..
Veamos otra versión de la misma clase en Kotlin:
constructor del libro de clase (título: String, isbn: Long) var title: String var isbn: Long init this.title = title this.isbn = isbn
En este código, hemos eliminado el constructor secundario. En su lugar, declaramos un constructor en el encabezado de la clase llamado constructor primario. Un constructor principal no tiene ningún lugar para poner un bloque de código, por lo que utilizamos el en eso Modificador para inicializar los parámetros entrantes desde el constructor primario. Tenga en cuenta que el en eso el bloque de código se ejecuta inmediatamente cuando se crea la instancia de clase.
Como puede ver, nuestro código todavía tiene un montón de repetitivo. Vamos a reducirlo aún más:
Clase de constructor de libros (título var: String, var isbn: largo)
Nuestro Libro clase es ahora solo una linea de codigo ¡Eso es realmente genial! Observe que en la lista de parámetros del constructor primario, definimos nuestras propiedades mutables: título y Isbn directamente dentro del constructor primario con el var palabra clave.
También podemos agregar valores predeterminados a cualquiera de las propiedades de la clase dentro del constructor.
constructor de la clase de libro (var title: String = "valor predeterminado", var isbn: Long)
De hecho, también podemos omitir el constructor palabra clave, pero solo si no tiene ningún modificador de visibilidad (público, privado, o protegido) o cualquier anotación.
Class Book (var title: String = "valor predeterminado", var isbn: Long)
Una clase muy pulcra, debo decir.!
Ahora podemos crear una instancia de clase como esta:
val book = Libro ("Una canción de hielo y fuego", 9780007477159) val book2 = Libro (1234) // utiliza el valor predeterminado de la propiedad del títuloEn Kotlin, podemos obtener una propiedad por el objeto de clase libro, seguido de un separador de puntos ., entonces el nombre de la propiedad título. Este estilo conciso de acceso a las propiedades se llama sintaxis de acceso a la propiedad. En otras palabras, no tenemos que llamar al método de obtención de propiedades para acceder o llamar al configurador para establecer una propiedad en Kotlin, como lo hacemos en Java.
println (book.title) // "Una canción de hielo y fuego"
Porque el Isbn la propiedad se declara con el var palabra clave (lectura-escritura), también podemos cambiar el valor de la propiedad mediante el operador de asignación =.
book.isbn = 1234 println (book.isbn) // 1234
Veamos otro ejemplo:
class Book (var title: String, val isbn: Long) val book = Book ("A Song of Ice and Fire", 9780007477159) book.isbn = 1234 // error: propiedad de solo lectura book.title = "Things Fall Apart "// título reasignado con valorAquí, actualizamos el Isbn parámetro para ser inmutable (solo lectura) en lugar de utilizar el val palabra clave. Creamos una instancia de clase libro y reasignado el título Propiedad del valor "Las cosas se deshacen". Tenga en cuenta que cuando intentamos reasignar el Isbn valor de propiedad para 1234, el compilador se quejó. Esto se debe a que la propiedad es inmutable, habiendo sido definida con el val palabra clave.
Tenga en cuenta que al declarar un parámetro con la var modificador dentro del constructor primario, el compilador Kotlin (detrás de la escena) nos ha ayudado a generar los accesores de propiedades: getter y setter. Si utiliza val, solo generará el captador.
/ * Kotlin * / class Book (var title: String, val isbn: Long)
Esto significa que los llamadores de Java pueden simplemente obtener o establecer el campo de propiedad llamando al método de establecimiento o obtención de la propiedad respectivamente. Recuerde, esto depende del modificador usado para definir la propiedad de Kotlin: var o val.
/ * Java * / Libro = nuevo libro ("Canción de hielo y fuego", 9780385474542) println (book.getTitle ()) // "Canción de hielo y fuego" book.setTitle ("Things Fall Apart") // establece el nuevo valor println (book.getTitle ()) // "Things Fall Apart" book.getIsbn () // 9780385474542 book.setIsbn (4545454) // no compilaráEn esta sección, le mostraré cómo crear accesores personalizados (getters y setters) para una propiedad en Kotlin, si así lo desea. Crear un configurador personalizado puede ser útil si desea validar o verificar un valor antes de configurarlo en una propiedad de clase. Y un captador de propiedades personalizadas puede ser útil cuando desea cambiar o modificar el valor que debe devolverse.
Debido a que queremos crear nuestro propio captador o definidor personalizado para una propiedad, tenemos que definir esa propiedad en el cuerpo de la clase en lugar del encabezado del constructor.
libro de clases (val isbn: largo) var title = "valor predeterminado"
Por eso movimos el mutable (lectura-escritura). título propiedad en el cuerpo de la clase y le dio un valor predeterminado (o de lo contrario no se compilaría).
class Book (val isbn: Long) var title = "valor predeterminado" set (value) if (! value.isNotEmpty ()) throw IllegalArgumentException ("El título no debe estar vacío") campo = valorPuedes ver que definimos nuestro propio método setter. valor ajustado) Para el título justo debajo de la nota de definición de propiedad que no puede modificar esto conjunto() firma del método porque esto es lo que el compilador espera como una función de establecimiento de propiedades personalizadas.
El parámetro valor pasado a la conjunto El método representa el valor real que los usuarios asignaron a la propiedad. Puede cambiar el nombre del parámetro si lo desea, pero valor es mucho más preferido. Validamos el valor comprobando si el valor está vacío. Si está vacío, detenga la ejecución y lance una excepción; de lo contrario, reasignar el valor a un especial campo variable.
Este especial campo campo variable dentro del conjunto método es un alias para el campo de respaldo de la propiedad; un campo de respaldo es solo un campo que utilizan las propiedades cuando desea modificar o usar los datos de ese campo. diferente a valor, no puedes renombrar este especial campo variable.
Es muy fácil crear un captador personalizado para una propiedad en Kotlin.
libro de clases (val isbn: largo) var title = "valor predeterminado" // ... establecer método get () return field.toUpperCase ()
Dentro de obtener Método, simplemente devolvemos una modificación. campo-En nuestro caso, devolvimos el título del libro en mayúsculas..
val book = Libro (9780007477159) book.title = "Una canción de hielo y fuego" println (book.title) // "UNA CANCIÓN DE HIELO Y FUEGO" println (book.isbn) // 9780007477159
Tenga en cuenta que cada vez que configuramos un valor a la título propiedad, su conjunto Se ejecuta el bloque de método, lo mismo ocurre con el obtener Método cada vez que lo recuperamos.
Si desea obtener información sobre las funciones de miembro para una clase de Kotlin (el tipo de función que se define dentro de una clase, objeto o interfaz), visite la publicación Más diversión con funciones de esta serie..
Como mencioné anteriormente, tenemos dos tipos de constructores en Kotlin: primario y secundario. Tenemos la libertad de combinar ambos en una sola clase, como puede ver en el siguiente ejemplo:
clase Car (nombre val: String, val plateNo: String) var new: Boolean = verdadero constructor (nombre: String, plateNo: String, nuevo: Boolean)) this (name, plateNo) this.new = new
Tenga en cuenta que no podemos declarar propiedades dentro de un constructor secundario, como hicimos con el constructor primario. Si queremos hacer esto, debemos declararlo dentro del cuerpo de la clase y luego inicializarlo en el constructor secundario..
En el código anterior, establecemos el valor predeterminado de nuevo propiedad para la clase Coche (recuerda, nuevo no es una palabra clave en Kotlin), entonces podemos usar el constructor secundario para cambiarlo si queremos. En Kotlin, cada constructor secundario debe llamar al constructor primario, o llamar a otro constructor secundario que llame al constructor primario: usamos el esta palabra clave para lograr eso.
Tenga en cuenta también que podemos tener varios constructores secundarios dentro de una clase.
clase Car (nombre de val: String, placa de valNo: String) var new: Boolean? = nulo var color: String = "" constructor (nombre: String, plateNo: String, nuevo: Boolean): este (nombre, plateNo) this.new = new constructor (nombre: String, plateNo: String, nuevo: Booleano , color: String): este (nombre, placaNo, nuevo) this.colour = color
Si una clase extiende una superclase, entonces podemos usar la súper palabra clave (similar a Java) para llamar al constructor de la superclase (veremos la herencia en Kotlin en una publicación futura).
// llama directamente al constructor primario val car1 = Car ("Peugeot 504", "XYZ234") // llama directamente a la primera sec. constructor val car2 = Car ("Peugeot 504", "XYZ234", falso) // llama directamente a la última sec. constructor val car3 = Car ("Peugeot 504", "XYZ234", falso, "gris") Como dije anteriormente, para que incluyamos explícitamente un modificador de visibilidad a un constructor en una clase, debemos incluir el constructor palabra clave-por defecto, los constructores son públicos.
clase Constructor privado de automóviles (nombre de val: String, placa de valNo: String) // ...
Aquí, hicimos el constructor privado, esto significa que los usuarios no pueden crear una instancia de un objeto utilizando su constructor directamente. Esto puede ser útil si desea que los usuarios llamen a otro método (un método de fábrica) para hacer la creación de objetos indirectamente.
En Kotlin, el tipo más alto en la jerarquía de tipos se llama Alguna. Esto es equivalente a la de Java. Objeto tipo. Esto significa que todas las clases en Kotlin heredan explícitamente de la Alguna tipo, incluyendo Cuerda, En t, Doble, y así. los Alguna tipo contiene tres métodos: es igual a, Encadenar, y código hash.
También podemos utilizar el Nada clase en Kotlin en funciones que siempre devuelven una excepción; en otras palabras, para funciones que no terminan normalmente. Cuando una función vuelve Nada, entonces sabemos que va a lanzar una excepción. No existe un tipo equivalente de este tipo en Java.
fun throwException (): Nothing throw Exception ("Mensaje de excepción)Esto puede ser útil al probar el comportamiento de manejo de errores en sus pruebas unitarias.
Los modificadores de visibilidad nos ayudan a restringir la accesibilidad de nuestra API al público. Podemos proporcionar diferentes modificadores de visibilidad a nuestras clases, interfaces, objetos, métodos o propiedades. Kotlin nos proporciona cuatro modificadores de visibilidad:
Este es el valor predeterminado, y se puede acceder a cualquier clase, función, propiedad, interfaz u objeto que tenga este modificador desde cualquier lugar.
Una función, interfaz o clase de nivel superior que se declara como privado Se puede acceder solo dentro del mismo archivo.
Cualquier función o propiedad que se declare. privado dentro de una clase, objeto o interfaz solo puede ser visible para otros miembros de esa misma clase, objeto o interfaz.
Cuenta de clase cantidad de valor privado: Doble = 0.0
los protegido el modificador solo se puede aplicar a propiedades o funciones dentro de una clase, objeto o interfaz, no se puede aplicar a funciones, clases o interfaces de nivel superior. Las propiedades o funciones con este modificador solo son accesibles dentro de la clase que lo define y cualquier subclase.
En un proyecto que tiene un módulo (módulo Gradle o Maven), una clase, objeto, interfaz o función especificada con el interno El modificador declarado dentro de ese módulo solo es accesible desde ese módulo.
Cuenta interna de clase cantidad val: Doble = 0.0
Casting significa tomar un objeto de otro tipo y convertirlo en otro tipo de objeto. Por ejemplo, en Java, usamos el en vez de operador para determinar si un tipo de objeto en particular es de otro tipo antes de que luego lo lancemos.
/ * Java * / if (shape instanceof Circle) Circle circle = (Circle) shape; circle.calCircumference (3.5);
Como puedes ver, verificamos si forma instancia es Circulo, y luego tenemos que emitir explícitamente el forma referencia a un Circulo Escriba para que podamos llamar métodos de la circulo tipo.
Otra cosa impresionante acerca de Kotlin es la inteligencia de su compilador cuando se trata de casting. Veamos ahora una versión en Kotlin..
/ * Kotlin * / if (la forma es un círculo) shape.calCircumference (3.5)
¡Con buena pinta! El compilador es inteligente saber que el Si bloque se ejecutará sólo si el forma objeto es una instancia de Circulo-Así que el mecanismo de fundición se realiza bajo el capó para nosotros. Ahora podemos llamar fácilmente propiedades o funciones del Circulo escriba dentro de Si bloquear.
if (forma es Círculo && forma.hasRadio ()) println ("El radio del círculo es forma.radio")Aquí, la última condición después de la && en el Si el encabezado será llamado solo cuando la primera condición es cierto. Si el forma no es un Circulo, entonces la última condición no será evaluada.
Podemos usar el como operador (o reparto inseguro operador) para convertir explícitamente una referencia de un tipo a otro tipo en Kotlin.
círculo val = forma como círculo círculo.calcircunferencia (4)
Si la operación de lanzamiento explícito es ilegal, tenga en cuenta que un ClassCastException será arrojado. Para evitar que se lance una excepción al lanzar, podemos usar el reparto seguro operador (o operador de nullable) como?.
circulo val: circulo? = forma como? Circulo
los como? operador tratará de lanzar al tipo deseado, y devuelve nulo Si el valor no se puede convertir en lugar de lanzar una excepción. Recuerde que un mecanismo similar se discutió en la sección Nulabilidad en Nulabilidad, Bucles y Condiciones publicadas en esta serie. Lee allí para un repaso.
Los objetos en Kotlin son más similares a los objetos de JavaScript que a los objetos de Java. Tenga en cuenta que un objeto en Kotlin no es una instancia de una clase específica!
Los objetos son muy similares a las clases. Estas son algunas de las características de los objetos en Kotlin:
en eso bloquear.Vamos a profundizar en cómo crear un objeto.
objeto Singleton fun myFunc (): Unit // hacer algo
Colocamos el objeto palabra clave antes del nombre del objeto que queremos crear. De hecho, estamos creando singletons cuando creamos objetos en Kotlin usando el objeto construir, porque solo existe una instancia de un objeto. Aprenderás más sobre esto cuando discutamos la interoperabilidad de objetos con Java.
Un singleton es un patrón de diseño de software que garantiza que una clase solo tiene una instancia y que esa clase proporciona un punto de acceso global. Cada vez que varias clases o clientes solicitan la clase, obtienen la misma instancia de la clase. Puedes ver mi publicación sobre el patrón de singleton en Java para obtener más información al respecto..
Puede acceder al objeto o singleton en cualquier parte de su proyecto, siempre que importe su paquete..
Singleton.myFunc ()
Si eres un codificador Java, así es como normalmente creamos singletons:
clase pública Singleton private static Singleton INSTANCE = null; // otras variables de instancia pueden ser privadas aquí Singleton () ; Singleton público estático sincronizado getInstance () if (INSTANCE == null) INSTANCE = new Singleton (); retorno (INSTANCIA); // otros métodos de instancia pueden seguir
Como puedes ver, usando el Kotlin. objeto la construcción hace que sea conciso y más fácil de crear singletons.
Los objetos en Kotlin pueden utilizarse también para crear constantes. Normalmente en Java, creamos constantes en una clase al convertirlo en un campo final estático público como este:
APIConstants finales públicos de clase public static final String baseUrl = "http://www.myapi.com/"; APIConstantes privados ()
Este código en Java se puede convertir a Kotlin más sucintamente de esta manera:
paquete com.chike.kotlin.constants objeto APIConstants val baseUrl: String = "http://www.myapi.com/"
Aquí declaramos la constante. APIConstantes con una propiedad baseUrl dentro de un paquete com.chike.kotlin.constants. Bajo el capó, un miembro final estático privado de Java baseUrl se crea para nosotros y se inicializa con la cadena URL.
Para usar esta constante en otro paquete en Kotlin, simplemente importe el paquete.
importar com.chike.kotlin.constants.APIConstants APIConstants.baseUrl
Kotlin convierte un objeto en una clase Java final bajo el capó. Esta clase tiene un campo estático privado. EJEMPLO que contiene una sola instancia (un singleton) de la clase. El siguiente código muestra cómo los usuarios pueden llamar a un objeto Kotlin desde Java.
/ * Java * / Singleton.INSTANCE.myFunc ()
Aquí, una clase de Java llamada Semifallo fue generado con un miembro final público estático EJEMPLO, incluyendo una función final pública myFunc ().
Para hacer que la función o propiedad del objeto en Kotlin sea un miembro estático de la clase Java generada, usamos el @JvmStatic anotación. Aquí está cómo usarlo:
objeto Singleton @JvmStatic fun myFunc (): Unit // hacer algo
Aplicando el @JvmStatic anotación a myFunc (), El compilador lo ha convertido en una función estática..
Ahora los llamadores de Java pueden llamarlo como una llamada normal de miembro estático. Tenga en cuenta que utilizando el EJEMPLO campo estático para llamar a los miembros todavía funcionará.
/ * Java * / Singleton.myFunc ()
Ahora que hemos entendido qué objetos hay en Kotlin, vamos a sumergirnos en otro tipo de objetos llamados objetos complementarios..
Como Kotlin no admite clases estáticas, métodos o propiedades como las que tenemos en Java, el equipo de Kotlin nos brindó una alternativa más poderosa llamada objetos complementarios. Un objeto complementario es básicamente un objeto que pertenece a una clase: esta clase se conoce como la clase complementaria del objeto. Esto también significa que las características que mencioné para los objetos también se aplican a los objetos complementarios..
Similar a los métodos estáticos en Java, un objeto complementario no está asociado con una instancia de clase sino con la clase en sí, por ejemplo, un método estático de fábrica, que tiene el trabajo de crear una instancia de clase.
clase Persona constructor privado (var firstName: String, var lastName: String) objeto complementario fun create (firstName: String, lastName: String): Person = Person (firstName, lastName)
Aquí, hicimos el constructor. privado-esto significa que los usuarios fuera de la clase no pueden crear una instancia directamente. Dentro de nuestro bloque de objeto compañero, tenemos una función crear(), que crea un Persona objeto y lo devuelve.
compañero La instanciación del objeto es perezosa. En otras palabras, se creará una instancia solo cuando sea necesario la primera vez. La instanciación de un compañero objeto ocurre cuando una instancia de la compañero se crea la clase o la compañero los miembros objeto son accedidos.
Veamos cómo invocar una función de objeto complementario en Kotlin..
val person = Person.create ("Cersei", "Lannister") println (person.firstName) // imprime "Cersei"Como puede ver, esto es como invocar un método estático en Java como de costumbre. En otras palabras, solo llamamos a la clase y luego llamamos al miembro. Tenga en cuenta que, aparte de las funciones, también podemos tener propiedades dentro de nuestro objeto complementario.
clase Persona constructor privado (var firstName: String, var lastName: String) init count ++ objeto complementario var count: Int = 0 fun create (firstName: String, lastName: String): Person = Person (firstName, lastName) init println ("Objeto compañero de persona creado")Tenga en cuenta también que la compañero la clase tiene acceso sin restricciones a todas las propiedades y funciones declaradas en su objeto complementario, mientras que un objeto complementario no puede acceder a los miembros de la clase. Podemos tener un en eso bloque de código dentro de un compañero objeto: esto se llama inmediatamente cuando se crea el objeto complementario.
Person.create ("Arya", "Stark") Person.create ("Daenerys", "Targaryen") println (Person.count)El resultado de ejecutar el código anterior será:
Objeto compañero de persona creado 2
Recuerda, solo una instancia de una clase. compañero el objeto puede existir.
También somos libres de proporcionar a nuestro objeto compañero un nombre.
// ... objeto complementario Factory var count: Int = 0 fun create (firstName: String, lastName: String): Person = Person (firstName, lastName) // ...
Aquí, le dimos un nombre llamado Fábrica. Entonces podemos llamarlo así en Kotlin:
Person.Factory.create ("Petyr", "Baelish")Este estilo es detallado, por lo que es mucho más preferible atenerse a la forma anterior. Pero esto puede ser útil cuando se llama a una función o propiedad de objeto complementario desde Java.
Como dije anteriormente, al igual que los objetos, los objetos complementarios también pueden incluir propiedades o funciones, implementar interfaces e incluso extender una clase..
interfaz PersonFactory fun create (firstName: String, lastName: String): Person class Person constructor privado (var firstName: String, var lastName: String) objeto complementario: PersonFactory override fun create (firstName: String, lastName: String) : Person return Person (firstName, lastName)
Aquí tenemos una interfaz. PersonFactory con solo una crear() función. Mirando nuestro nuevo modificado compañero objeto, ahora implementa esta interfaz (aprenderá acerca de las interfaces y la herencia en Kotlin en una publicación posterior).
Bajo el capó, los objetos complementarios se compilan de manera similar a la forma en que se compila un objeto Kotlin. En nuestro caso, se generan dos clases para nosotros: una final. Persona clase y una clase final interna estática Persona $ Compañero.
los Persona clase contiene un miembro estático final llamado Compañero-Este campo estático es un objeto de la Persona $ Compañero clase interna los Persona $ Compañero La clase interna también tiene sus propios miembros, y uno de ellos es una función final pública llamada crear().
Tenga en cuenta que no le dimos un nombre a nuestro objeto compañero, por lo que la clase interna estática generada fue Compañero. Si le hubiéramos dado un nombre, entonces el nombre generado sería el nombre que le dimos en Kotlin.
/ * Java * / Person person = Person.Companion.create ("Jon", "Snow"); Aquí, el objeto complementario en Kotlin no tiene nombre, así que usamos el nombre Compañero proporcionado por el compilador para los llamadores de Java para llamarlo.
los @JvmStatic la anotación aplicada en un miembro objeto complementario funciona de manera similar a como funciona para un objeto regular.
De manera similar a cómo las funciones de extensión pueden extender la funcionalidad de una clase, también podemos extender la funcionalidad de un objeto complementario. (Si desea actualizar las funciones de extensión en Kotlin, visite el tutorial de funciones avanzadas de esta serie).
class ClassA objeto complementario divertido ClassA.Companion.extFunc () //… do implementación ClassA.extFunc ()
Aquí, definimos una función de extensión. extFunc () en el objeto compañero ClassA.Companion. En otras palabras, extfunc () Es una extensión del objeto compañero. Luego podemos llamar a la extensión como si fuera una función miembro (¡no lo es!) Del objeto complementario.
Detrás de escena, el compilador creará una función de utilidad estática. extFunc (). El objeto receptor como argumento para esta función de utilidad es Compañero ClassA $.
En este tutorial, aprendiste sobre clases y objetos básicos en Kotlin. Cubrimos lo siguiente sobre las clases:
Además, aprendió cómo los objetos y los objetos complementarios en Kotlin pueden reemplazar fácilmente sus métodos estáticos, constantes y singletons que codifica en Java. ¡Pero eso no es todo! Todavía hay más que aprender acerca de las clases en Kotlin. En la próxima publicación, te mostraré características aún más geniales que Kotlin tiene para la programación orientada a objetos. Te veo pronto!
Para obtener más información sobre el idioma Kotlin, recomiendo visitar la documentación de Kotlin. O echa un vistazo a algunas de nuestras otras publicaciones de desarrollo de aplicaciones para Android aquí en Envato Tuts+!
