Kotlin algunas diferencias con Java

Veamos algunas diferencias entre Kotlin y Java para quienes estamos empezando con Kotlin

El punto y coma no es necesario en Kotlin

La primer diferencia es la falta de uso de punto y comas. En Kotlin no es requisito agregar punto y coma al finalizar cada línea.

val name = "Jhon"  // ; no necesario 
var otherName = String // ; no necesario

No es necesario llamar al get en los arrays

En Kotlin un array se declara así.

// arrays
var names = arrayListOf("Jhon", "Jane", "Robert")

Si quisiéramos acceder al primer elemento pensaríamos en esto

println(names.get(0)) // access using get(index)

Sin embargo en Kotlin es preferible acceder directamente al indice sin usar get(index)

println(names[0]) // better access 

Kotlin maneja su propia clase String

Kotlin maneja su propia clase String la cual puedes observar es bastante extensa. Este es un punto importante a tener en cuenta. Te encontraras con métodos distintos y algunos nuevos.

Observa, por ejemplo, que en Java para verificar la longitud accedes al método length().

String surname = "Einstein";
System.out.println(surname.length());

En Kotlin para verificar la longitud accedes a la propiedad length.

val surname = "Einstein"
println(surname.length) 

Kotlin no maneja Excepciones checked / unchecked

Sabemos que en Java existen excepciones que estamos obligados a capturar checked exceptions y otras que no estamos obligados a capturarlas unchecked exceptions.

Recordando en Java: Las excepciones que heredan de Exception debemos forzadamente capturarlas o relanzarlas. Es decir no podemos ignorarlas.
Las excepciones que heredan de RuntimeException no estamos obligados a capturarlas.

Pero… en Kotlin no existe el criterio de checked / unchecked .

Todas las excepciones en Kotlin son unchecked.
Por esta razón, nunca veras en Kotlin un método que tenga un throw.

En Java si lanzamos una Exception debemos manejarla con un try / catch.

public static void main(String[] args) {
    try {
        System.out.println("result" +  calculate(1,0));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public static int calculate(int i, int j) throws Exception {
    if(j == 0) {
        throw new Exception("Invalid param");
    }
    return i / j;
}

En Kotlin, no se agrega throws en el método que lanza, tampoco es obligatorio capturar la excepción con try / catch .

fun main() {
    println("result " + calculate(1, 0))
}

fun calculate(i: Int, j: Int): Int {
    if (j == 0) {
        throw Exception("Invalid param")
    }
    return i / j
}

Kotlin no tiene el operador ternario if

Conocemos en Java el uso del operador ternario (ternary operator) o también conocido con if en línea (inline if)

int x = 1;
// ..
int j = x == 1 ? 10 : 20;

En Kotlin no existe este operador. Si deseamos escribir lo mismo que arriba lo haríamos así.
A mi criterio se ve más claro como lo resuelve Kotlin.

val x = 1
// ..
val j = if (x == 1) 10 else 20

El loop tradicional en Kotlin no existe

El Java conocemos que para hacer bucle de modo tradicional hacemos

// traditional loop 
for (int i = 0; i < 10; i++ ) {
    System.out.println("value of i " + i);
}

No existe este bucle tradicional en Kotlin. En Kotlin, los bucles for se usan para iterar cualquier cosa que proporcione un iterator, como es el caso de rangos, matrices, mapas, etc. La sintaxis del bucle for en Kotlin es:

// loop range
for (i in 0..9) {
    println(i)
}

Kotlin no tiene static

Kotlin no maneja la palabra “static” con la que tanto estamos familiarizados en Java.

public static void example() {
    System.out.println("This is static");
}

En Kotlin este keyword static no existe.

fun example() {
    println("This is static")
}

En Kotlin no es necesario palabra new para crear una instancia

En Kotlin no es necesario utilizar new para crear una instancia.

public class Person {

    private String name;

    public PersonJ(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Para crear una instancia de esta clase

// instance with new in Java
Person person = new Person("Jhon");

Hacemos esto mismo en Kotlin

class PersonK(name: String) {}
// instance in kotlin
val person = PersonK("Jhon")

Conclusión

Vimos de rápidamente algunas diferencias entre Kotlin y Java para los que venimos desde el mundo Java.

Kotlin diferencias Java

Kotlin