KotlinRush: ¿tiene sentido seguir escribiendo en Java?

Hola, estudiante de JavaRush, antes de que Java te absorba por completo, me gustaría ampliar tus horizontes y llamar la atención sobre el cada vez más popular lenguaje Kotlin . Kotlin es un lenguaje bastante joven desarrollado por JetBrains . Sí, sí, la misma empresa que desarrolló nuestro IDE favorito: IntelliJ IDEA. Kotlin es un lenguaje JVM y es totalmente compatible con Java , es decir, desde el código de Kotlin puede acceder fácilmente a bibliotecas Java familiares. ¿Qué pasa con las bibliotecas: las clases de Kotlin y Java pueden coexistir en un solo paquete? Kotlin era tan popular entre la comunidad de programación que Google lo reconoció como el lenguaje de desarrollo oficial para Android y recientemente Kotlin ha comenzado a ganar popularidad en proyectos empresariales. En este artículo, me gustaría dar algunos ejemplos comparativos de código escrito en Kotlin y Java y sacar algunas conclusiones. ¡Ir! Empecemos, como siempre, con "Hola mundo".

// Java
public class Application {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

// Kotlin
class Application
fun main(vararg args: String) {
    println("Hello World!")
}

Si observamos el ejemplo de Kotlin, podemos notar inmediatamente lo siguiente:

• no es necesario escribir un punto y coma al final de la línea;
• todos los métodos se describen con la palabra clave divertida ;
• Para imprimir una línea, basta con una sola palabra: println() .

Creando una instancia

// Java (до 10)
final Application application = new Application();

// Kotlin
val application = Application()

Diferencias de Kotlin:

• no es necesario declarar el tipo de una variable si queda claro en la instancia;
• en lugar del tipo de variable: val (inmutable) o var (cambiable);
• ¡No es necesario escribir la nueva palabra clave para crear una instancia !

Descripción de métodos

// Java
public int sum(int a, int b) {
    return (a + b);
}

// Kotlin
fun sum(a: Int, b: Int): Int {
return (a + b)
}

Diferencias de Kotlin:

• si es necesario devolver algo de un método, se agrega " : Int " a la firma, donde Int es el tipo de retorno;
• descripción de los parámetros del método: primero el nombre de la variable, luego el tipo;
• Dado que el cuerpo del método consta de una sola línea, puedes omitir el retorno :
  

  fun sum(a: Int, b: Int): Int = (a+b)

Salida de cadena formateada

// Java
public int sum(int a, int b) {
    int result = (a + b);
    System.out.printf("Сумма %d и %d равна %d\n", a, b, result);
    return result;
}

// Kotlin
fun sum(a: Int, b: Int): Int {
    val result = (a + b)
    println("Сумма $a и $b равна $result")
    return result
}

Kotlin admite la interpolación de cadenas, simplemente use el símbolo "$" al comienzo de la variable. Esta notación mejora significativamente la limpieza y legibilidad del código. Comparación de instancias

// Java
object1.equals(object2)

// Kotlin
object1 == object2

En Kotlin, la comparación " ==" para tipos de objetos se traduce a equals! Y para comparar enlaces ===se utiliza " ". Excepciones

// Java
public List<String> getFileContent(String file) throws IOException {
    Path path = Paths.get(file);
    return Files.readAllLines(path);
}

// Kotlin
fun getFileContent(file: String): List<String> {
    val path = Paths.get(file)
    return Files.readAllLines(path)
}

No hay excepciones marcadas en Kotlin ; ahora no es necesario lanzar una excepción sin cesar en toda la aplicación o crear excepciones de varios niveles try-catch. Seguridad nula

// Java
public class Data {
    String value;

    String render() {
        if (value == null) {
            return "Value: undefined";
        } else {
            return "Value:" + value.toUpperCase();
        }
    }
}

// Kotlin
class Data {
    var value: String? = null
    fun render(): String =
            "Value: ${value?.toUpperCase() ?: "undefined"}"
}

Kotlin se ocupó del problema de la NPE e introdujo una serie de requisitos:

• todos los campos y variables de clase deben inicializarse;
• Puedes escribir “nulo” en un campo o variable, pero luego debes decir explícitamente que tu variable es anulable (escribe el signo “?”);
• El operador de Elvis "?:" funciona así: si hay Null a la izquierda, toma lo que está a la derecha. En el caso de nuestro ejemplo, cuando la variable de valor no esté inicializada, se tomará el valor “ indefinido ”.

Campos de clase y acceso a ellos.

// Java
public class Data {
    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}
class App {
    void execute() {
           Data data = new Data()
           data.setValue("Foo")
     }
}

// Kotlin
class Data {
    var value: String = ""
}
class App {
    fun execute() {
          val data = Data()
          data.value = "Foo" // Под капотом выполнится data.set("Foo")
     }
}

En Kotlin, basta con describir un campo y listo: ya tiene captadores y definidores implícitos (hola lombok ), que pueden anularse en cualquier momento si se desea. Al mismo tiempo, leemos y modificamos el valor del campo simplemente accediendo a él directamente, y en el fondo se llama get()|set(). Ciclos

// Java
void example() {
    for(int i = 1; i <= 10; i++) {
        System.out.println(i);
    }

    for(String line : "a,b,c".split(",")) {
        System.out.println(line);
    }
}

// Kotlin
fun example() {
    for(i in 1..10) {
        println(i)
    }

    for(line in "a,b,c".split(",")) {
        println(line)
    }
}

Kotlin ha proporcionado una sintaxis conveniente y uniforme para recorrer secuencias: simplemente usa una variable a la izquierda , una secuencia a la derecha y la palabra clave " en " en el medio, el tipo se determina automáticamente por el contenido. único

// Java
public class Singleton {
    private static Singleton ourInstance = new Singleton();

    public static Singleton getInstance() {
        return ourInstance;
    }

    private Singleton() {
    }
}
class App {
    void execute() {
         Singleton singleton = Singleton.getInstance()
    }
}

// Kotlin
object Singleton {}

class App {
    fun execute() {
          val singleton = Singleton
    }
}

El patrón familiar " singler " se usa con bastante frecuencia en la práctica, por lo que Kotlin decidió crear una palabra clave separada " objeto ", que se escribe en lugar de " clase " y significa que la clase es un singleton; cuando se usa, ni siquiera ¡Necesito llamar al constructor o cualquier otro método! Parámetros de método con nombre y valores predeterminados

// Java
void setStatus(String code) {
    setStatus(code, "");
}

void setStatus(String code, String desc) {
    this.code = code;
    this.desc = desc;
}

// Kotlin
fun setStatus(code: String, desc: String = "") {
    this.code = code;
    this.desc = desc;
}

fun execute() {
    setStatus("200")
    setStatus(code = "200", desc = "Ok")
}

Sucede que no todos los parámetros de un método o constructor deben ser obligatorios, y en Java estamos acostumbrados a crear un conjunto de métodos o constructores para cada combinación posible de parámetros. Se han introducido parámetros predeterminados en Kotlin, lo que le permite declarar 1 método y pasarle el conjunto de parámetros requerido según la situación. Corrientes

// Java
String getFirst(List<String> strings, String alpha) {
    return strings.stream()
            .filter(x -> x.startsWith(alpha))
            .findFirst()
            .orElse("");
}

// Kotlin
fun getFirst(strings: List<String>, alpha: String): String {
    return strings.first { it.startsWith(alpha) }
}

La introducción del flujo en Java 8 se ha convertido en una funcionalidad integral cuando se trabaja con colecciones. En Kotlin, los flujos se han hecho aún más convenientes y funcionales: cada colección ya tiene un conjunto de métodos convenientes y de uso frecuente para trabajar con datos. Además, observe la expresión lambda dentro del primer método: si una función literal tiene exactamente un parámetro, su declaración se puede eliminar (junto con ->) y  denominarla . Es hora de concluir... Te demostré solo una pequeña parte básica de la funcionalidad, ¡pero estoy seguro de que ya quieres probar Kotlin! De mi experiencia puedo sacar las siguientes conclusiones:

• Es muy fácil para un desarrollador de Java dominar la sintaxis de Kotlin y comenzar a escribir código;
• Kotlin es totalmente compatible con Java y ya puedes probarlo en tus proyectos existentes, por ejemplo, en pruebas;
• El código Kotlin es más limpio y legible, no es necesario escribir un montón de textos repetitivos ;
• IDEA tiene un conversor automático de Java a Kotlin, puede tomar código Java ya preparado y convertirlo automáticamente a Kotlin;
• Es necesario escribir un nuevo proyecto en Kotlin, porque desde el punto de vista de la infraestructura es lo mismo que Java, ¡pero en términos de uso es mejor y más conveniente!

Si le gustó el artículo y, en general, es relevante para un recurso sobre Java, puedo continuar escribiendo sobre la experiencia de usar Kotlin en un proyecto empresarial real. Enlaces útiles:

• Intente escribir algo en Kotlin en línea
• Aprendiendo Kotlin: un conjunto y una descripción de varios ejemplos interactivos
• Complemento para IDEA para entrenamiento con validación (como mini-JavaRush)
• Sitio web oficial de Kotlin
• Sitio ruso de Kotlin