¿Cuáles son algunas diferencias importantes entre Java y Kotlin?

⚔️ Kotlin Vs Java

• Seguridad Trabajando con nulo . El sistema tipo Kotlin está construido de manera de minimizar la posibilidad de aparición de NullPointerException. Hablaremos de eso en un momento.
• No hay excepciones marcadas. La eficiencia y la ineficiencia de las excepciones marcadas es un tema de los argumentos interminables. Sin embargo, imponer el procesamiento de errores a menudo puede dar lugar a la aparición del código repetitivo.
• Tipos de funciones A diferencia de Java, Kotlin tiene la capacidad de pasar una función como parámetro a otra función sin recurrir a las interfaces SAM (Método abstracto único) como Runnable, Callable, etc.
• Array Invariance. Las matrices en Java son covariantes, mientras que en Kotlin son invariantes. Un simple ejemplo de Java:

Número [] números = nuevo Número [1];
Objeto [] objetos = números;
objetos [0] = “hola”;

Podemos asignar el valor Número [] a la variable Objeto [] debido a la covarianza de las matrices Java. No habrá ningún error durante la compilación, pero aparecerá durante la ejecución.

• No hay tipos sin procesar. Antes de la aparición de los genéricos en Java, los llamados tipos crudos se usaban ampliamente. Aquí hay un ejemplo problemático:

Lista rawList = new ArrayList ();
rawList.add (nuevo Object ());
List strings = rawList;
System.out.println (strings.get (0));

La nueva clase ArrayList () crea una lista con un tipo sin formato. Una vez más, aparece un error en la ejecución, no compilando.

• El sistema genérico reelaborado . Los creadores de Kotlin intentaron resolver algunos de los problemas con los genéricos encontrados en Java. Sin embargo, el sistema genérico todavía está, desafortunadamente, trabajando en la etapa de compilación como Java y no en el tiempo de ejecución.

Fortalezas de Kotlin

Las principales ventajas de Kotlin se encuentran donde no hay un equivalente de Java. Esto es lo que pude detectar:

1. Las funciones de orden superior, expresiones lambda y funciones en línea.

Como dije, las funciones de Kotlin ganaron la capacidad de aceptar otras funciones como argumentos. Estas funciones se denominan funciones de orden superior. Además de eso, Kotlin tiene implementado un conveniente sistema de expresiones lambda.

Según los acuerdos de Kotlin:

• Puede mover u omitir los paréntesis en un método si la lambda está en la última posición o es el único argumento en el método. Por ejemplo, en lugar de clients.filter ({customer -> customer.city == search}), puede escribir customers.filter {customer -> customer.city == search}.
• Si decidió no declarar un argumento de una lambda de un argumento, se declarará implícitamente bajo su nombre. El ejemplo anterior se puede reescribir así: customers.filter {it.city == search}.

Las expresiones Lambda nos permiten escribir código funcional de manera segura, breve y expresiva:

// Devuelve el producto más caro entre todos los productos entregados
pedidos
.filter {it.isDelivered}
.flatMap {it.products}
.maxBy {it.price}

2. Extensiones

En Kotlin existen las llamadas extensiones que permiten agregar nuevas funciones y propiedades a las clases antiguas sin afectar su código fuente.

diversión String.lastChar () = get (longitud – 1)
…
“abc” .lastChar ()

Además, en Kotlin puede llamar a una expresión lambda para un objeto receptor específico. Dentro de dicha expresión, puede acceder a los campos y funciones de los objetos sin ningún calificador. Esto nos permite crear los llamados constructores de estilo Groovy de tipo seguro.

html {
cuerpo {
div {
a (” http: //kotlinlang.org&quot 😉 {
target = ATarget.blank
+ “Sitio principal”
}
}
}
}

3. Tipo inteligente de fundición

El compilador de Kotlin rastrea la lógica del código y ejecuta un casting inteligente.

if (obj es String) {
print (obj.length) // obj se convierte automáticamente en String
}

4. Seguridad nula

Como mencioné anteriormente, Kotlin ha implementado la seguridad nula mediante la introducción de la separación de tipo nulable y no nula. Por defecto, los tipos no permiten nulo pero pueden modificarse para hacerlo si agregamos?. Kotlin ejecuta verificaciones forzadas durante la compilación y evita el uso de las variables anulables sin la verificación nula. Por lo tanto, no hay peligro de NullPointerException. Además, no puede asignar nulo a una variable declarada como no anulable.

Un tipo no nulo:

var a: String = “abc”
a = nulo // error de compilación
val l = a.length // se garantiza que no causará un NPE

Acceder a cualquier campo de la función a es seguro porque tiene el tipo no nulo.

Un tipo anulable:

var a: String = “abc”
a = nulo // error de compilación
val l = a.length // se garantiza que no causará un NPE

El compilador de Kotlin no permitirá el acceso directo a los campos de función b, ya que puede ser nulo. Tenemos algunas opciones sobre cómo ejecutar este acceso:

• Puede verificar el valor antes de acceder. Con esto, después de la comprobación (b! = Null), el tipo b se especificará automáticamente como el tipo de String no nulo:

val l = if (b! = null) b.length else -1

• Puedes usar el? operador para un acceso seguro:

val l = b? .length

El resultado de esta expresión tiene el Int? escriba y es igual a b.length si b no es nulo o nulo en el caso contrario.

• Si estamos buscando recibir NullPointerException, podemos usar el !! operador. ¡¡El b!! La expresión restablecerá el tipo de cadena a no nulo si b! = nulo, de lo contrario aparecerá la excepción NullPointerException.

val l = b !!. longitud

Nota: De hecho, la aparición de NullPointerException solo es posible en los siguientes casos:

• El error se llama intencionalmente: lanzar NullPointerException () o el !! Se utiliza el operador.
• El NPE aparece en el lado del código Java.
• El error aparece como resultado del incumplimiento de los datos de inicialización. Por ejemplo, el subinicializado se usa en alguna parte:

clase Foo {
val c: String

en eso {
bar()
c = “”
}

fun bar () = println (c.length) // NPE aquí
}

5. Valores predeterminados de funciones

Una práctica común en Java es sobrecargar métodos y constructores para la implementación de argumentos de valor predeterminado. Kotlin tiene los argumentos predeterminados para eso.

lectura divertida (b: matriz , desactivada: Int = 0, len: Int = tamaño b) {
…
}

De hecho, los argumentos predeterminados nos permiten deshacernos de casi todos los casos de sobrecarga de métodos y constructores, lo que ayuda a evitar este tipo de código repetitivo.

6. Plantillas de cadena

En Kotlin, las cadenas pueden contener plantillas de cadena, en otras palabras, el código resultante se concatenará en la cadena.

val s = “abc”
val str = “$ s.length is $ {s.length}” // se evalúa como “abc.length is 3”

7. El sistema extendido de propiedades y campos

Las cadenas de Kotlin pueden tener campos y propiedades con funcionalidad extendida, incluidos captadores y establecedores personalizables:

var stringRepresentation: String
get () = this.toString ()
valor ajustado) {
setDataFromString (value) // analiza la cadena y asigna valores a otras propiedades
}

Una de las tareas súper comunes es implementar una propiedad que se concatena una vez en el primer acceso, la llamada ‘propiedad perezosa’. En Kotlin, dicho campo se puede crear fácilmente:

val lazyValue: String by lazy {
println (“calculado!”)
“Hola”
}

Implementado con la ayuda de las propiedades delegadas :

Ejemplo de clase {
var p: Cadena por delegado ()
}

La expresión after by es el delegado que procesa (get () y set ()). El delegado no necesariamente tiene que implementar alguna interfaz de usuario, es suficiente para que tenga los métodos get () y set () con una firma específica.

La biblioteca estándar de Kotlin muestra varios tipos útiles de delegados: propiedades diferidas , propiedades observables y las propiedades almacenadas en un mapa .

8. Inferencia de tipo automatizada

Kotlin tiene la capacidad de realizar inferencia de tipos por sí solo.

val resultado = secuencia de (10) .map {it.toString ()} .flatMap {it.toCharArray (). asSequence ()} .toList ()

También sabe que el resultado de la expresión tiene el tipo de Lista .

9. Singletons a nivel de idioma

Un singleton es un patrón de uso frecuente en la programación. Se puede declarar fácilmente en Kotlin mediante la palabra clave object:

objeto DataProviderManager {
fun registerDataProvider (proveedor: DataProvider) {
// …
}
val allDataProviders: Colección
get () = // …
}

10. Corutinas (coprogramas)

El uso de corutinas nos permite escribir secuencialmente código asíncrono para que la lógica en el código sea síncrona mientras funciona como asíncrono. Dicho esto, un hilo no se bloquea sino que se suspende.

Si tuviera la oportunidad de implementar una secuencia de operaciones asincrónicas, podría estar familiarizado con un término de Callback Hell . Es el fenómeno de las devoluciones de llamada anidadas dentro de otras devoluciones de llamada de varios niveles de profundidad. Cuanto más larga sea la cadena de operaciones asincrónicas, más devoluciones de llamadas anidadas habrá. Esto hace que el código sea ilegible y susceptible de errores. Ingrese las rutinas que ayudan a evitar este problema.

divertido sendEmailAsync () = async (CommonPool) {
val emailTask ​​= async (CommonPool) {
Thread.sleep (500)
” [correo electrónico protegido] ”
}

val messageTask = async (CommonPool) {
Thread.sleep (200)
“El mensaje”
}

sendEmail (emailTask.await (), messageTask.await ())
}

En pocas palabras, las corutinas son una especie de “hilos ligeros” que requieren un esfuerzo mínimo para crear y mantener. Al mismo tiempo, crear hilos nativos es un proceso costoso, por ejemplo:

fun main (args: Array ) = runBlocking {
val jobs = List (100_000) {// crea muchas rutinas y enumera sus trabajos
lanzamiento (CommonPool) {
retraso (1000L)
impresión(“.”)
}
}
jobs.forEach {it.join ()} // espera a que se completen todos los trabajos
}

Este código lanza rutinas de 100K y después de 1 segundo cada una imprime un punto. El código es fácil de iniciar y se ejecuta rápidamente. Volver a representar esto con hilos nativos es bastante problemático.

Coroutines es una potente funcionalidad que nos permite utilizar diferentes enfoques para escribir código competitivo. Puede usar las soluciones estándar de la biblioteca kotlinx.coroutine o implementar la suya propia.

Aquí hay un ejemplo rápido para demostrar el amplio espectro de corutinas con una relativa facilidad de uso. Digamos que tenemos las funciones poco confiables (susceptibles a errores de red) de f1 y f2. Necesitamos obtener la suma de estas funciones llamándolas varias veces con un tiempo de espera predefinido pero sin exceder el número dado de intentos:

suspender diversión f1 (i: Int): Int {
retraso (si (i! = 2) 2000L más 200L)
volver 1
}

suspender diversión f2 (i: Int): Int {
retraso (si (i! = 2) 2000L más 200L)
volver 2
}

diversión en línea reintentar (n: Int, bloque: (Int) -> T): T {
var ex: ¿Lanzable? = nulo
repetir (n) {i ->
intente {return block (i)}
catch (e: Throwable) {
println (“Falló con $ e”)
ex = e
}
}
tirar ex !! / * volver a lanzar el último fallo * /
}

fun asyncRetry (n: Int, tiempo: Long, bloque: suspender (Int) -> T) =
asíncrono (CommonPool) {
reintentar (n) {i ->
withTimeout (tiempo) {
bloque (i)
}
}
}

suspender diversión coroutineExample () {
val retryCount = 3
tiempo de espera val = 500
val v1 = asyncRetry (retryCount, timeout) {i -> f1 (i)}
val v2 = asyncRetry (retryCount, timeout) {i -> f2 (i)}
println (r1.await () + r2.await ())
}

Completar una tarea similar en Java habría requerido escribir mucho más código. Quizás RxJava podría haber ayudado un poco, pero apenas puede proporcionar la misma simplicidad y legibilidad.

Kotlin

Cuestiones

Matices

En aras de la integridad, tengo ganas de tirar un par de problemas que encontré en mi experimento del proyecto Kotlin. Debería decir no problemas, sino los matices del uso del lenguaje.

Autoconversión de código Java

Android Studio, así como IntelliJ IDEA, permiten la conversión automática de código Java a Kotlin, incluidos todos los archivos y fragmentos en copiar / pegar. La conversión funciona bastante bien, sin embargo, el código convertido aún requiere una verificación. En mi caso, algunas constantes de cadena se perdieron durante la conversión.

Tipo de fundición

Kotlin es extremadamente estricto cuando se trata de lanzar. El siguiente código no se compilará:

var longValue = 1L
…
if (longValue == 0) println (“zero”) // error en tiempo de compilación

No podremos comparar la variable Long con el valor Int de 0. Tenemos que compararlo con el valor Long de 0L. Sin embargo, el compilador permite esta comparación (al menos la versión 1.1 lo hace):

if (longValue> 0) println (“positivo”)

Inconsistencia en su máxima expresión ‍♂️

El var Variables Uso Rigor

El compilador es riguroso al acceder a las variables mutables, esperando que la variable se use en un contexto multiproceso. Un ejemplo exagerado:

valor var: cadena? = nulo

fun foo (): Int {
if (valor! = nulo) {
println (“La longitud es: $ {value.length}”) // ошибка компиляции
}
}

El compilador arroja un error: la conversión inteligente a ‘String’ es imposible, porque ‘value’ es una propiedad mutable que podría haber sido modificada en este momento .

En este caso, es mejor escribir:

valor? .let {
println (“La longitud es: $ {it.length}”)
}

El modificado para bucle

El C y Java familiar para la construcción de las acciones en bucle se modificó en Kotlin:

para (paso en 0..10) println (paso)

Esto significa que la construcción solo funciona con iteradores. En este caso, 0..10 es un rango que tiene un iterador.

• Tiempo de compilación nulo-seguridad. Las variables, las propiedades, los parámetros y los tipos de retorno deben declararse explícitamente como anulables y deben manejarse valores potencialmente nulos.
• Esto tiene el beneficio adicional de hacer que los tipos anulables sean una versión de Optional compatible con versiones anteriores sin ninguno de los gastos generales sintácticos o de tiempo de ejecución encontrados en Java o Scala. .
• Funciones de primera clase que no tienen que ser declaradas en una clase.
• Lambdas con algunas características superiores a las de Java 8, como la capacidad de declarar un receptor.
• Corutinas para una multitarea muy eficiente.
• Tipos de valores declarativos simples sin necesidad de implementadores getterplate, setters, equals y hash necesarios en Java.
• Inferencia de tipos y tipificación de flujo, por lo que no necesita la excesiva especificación excesiva de la información de tipo típica en Java y muy rara vez necesita convertir tipos.
• Un enfoque en la inmutabilidad por defecto para que las declaraciones variables y los tipos de colección sean inmutables a menos que se especifique lo contrario
• Funciones de extensión con alcance que proporcionan una alternativa mucho más ordenada a los métodos de utilidad estática y también permiten DSLs realmente seguros de tipo impresionante (vea la biblioteca de prueba de Spek, por ejemplo).
• Cuerdas templadas.
• Argumentos de método predeterminados y argumentos de método con nombre.
• Genéricos reified sobre métodos (¿alguna vez quisiste poder referirme al tipo de tiempo de ejecución de un genérico?)

“Y mientras estamos agregando Kotlin como idioma oficial de Android, también estamos ampliando nuestra inversión en nuestros idiomas existentes”. – Kotlin y Android

No es el idioma oficial, se ha convertido en uno de los oficialmente compatibles (C ++, JAVA).

Kotlin es casi como Swift. Se reduce la verbosidad de Java y las referencias nulas están controladas por el sistema de tipos, entre muchas ventajas.

Comparación con Java: lenguaje de programación Kotlin

¡Hola! ¿Leíste este artículo? También se describe la diferencia entre Java y Kotlin en palabras simples que incluso yo, como niña rubia, puedo entender))

¡Mejor!