KotlinRush: faz sentido continuar escrevendo em Java?

Olá, aluno JavaRush, antes que você seja completamente absorvido por Java, gostaria de expandir seus horizontes e chamar a atenção para a cada vez mais popular linguagem Kotlin ! Kotlin é uma linguagem bastante jovem desenvolvida pela JetBrains . Sim, sim, a mesma empresa que desenvolveu nosso IDE favorito: IntelliJ IDEA. Kotlin é uma linguagem JVM e é totalmente compatível com Java , ou seja, a partir do código Kotlin você pode acessar facilmente bibliotecas Java familiares. E quanto às bibliotecas: as classes Kotlin e Java podem coexistir em um pacote! Kotlin era tão popular entre a comunidade de programação que o Google o reconheceu como a linguagem oficial de desenvolvimento para Android e, recentemente, Kotlin começou a ganhar popularidade em projetos empresariais. Neste artigo, gostaria de dar vários exemplos comparativos de código escrito em Kotlin e Java e tirar algumas conclusões. Ir! Vamos começar, como sempre, com "Hello World"

// 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!")
}

Olhando para o exemplo do Kotlin, podemos notar imediatamente o seguinte:

• não há necessidade de escrever ponto e vírgula no final da linha;
• todos os métodos são descritos pela palavra-chave fun ;
• Para imprimir uma linha, basta uma palavra - println() !

Criando uma instância

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

// Kotlin
val application = Application()

Diferenças de Kotlin:

• não há necessidade de declarar o tipo de uma variável se estiver claro na instância;
• em vez do tipo de variável - val (imutável) ou var (alterável);
• Você não precisa escrever a nova palavra-chave para criar uma instância !

Descrição dos métodos

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

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

Diferenças de Kotlin:

• se algo precisa ser retornado de um método, “ :Int ” é adicionado à assinatura, onde Int é o tipo de retorno;
• descrição dos parâmetros do método: primeiro o nome da variável, depois o tipo;
• como o corpo do método consiste em apenas uma linha, você pode omitir o return :
  

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

Saída de string formatada

// 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 suporta interpolação de strings, basta usar o símbolo “$” no início da variável. Essa notação melhora significativamente a limpeza e a legibilidade do código. Comparação de instâncias

// Java
object1.equals(object2)

// Kotlin
object1 == object2

No Kotlin, a comparação " ==" para tipos de objetos é traduzida para equals! E para comparar links, " ===" é usado. Exceções

// 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)
}

Não há exceções verificadas no Kotlin ; agora você não precisa lançar exceções indefinidamente em todo o aplicativo ou criar exceções de vários níveis try-catch. Segurança 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 cuidou do problema do NPE e introduziu uma série de requisitos:

• todos os campos e variáveis ​​da classe devem ser inicializados;
• Você pode escrever “null” em um campo ou variável, mas então você deve dizer explicitamente que sua variável é Nullable (escreva o sinal “?”);
• O operador Elvis "?:" funciona assim: se houver Nulo à esquerda, pegue o que está à direita. No caso do nosso exemplo, quando a variável valor não for inicializada, será assumido o valor “ indefinido ”.

Campos de classe e acesso a eles

// 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")
     }
}

No Kotlin, basta simplesmente descrever um campo e pronto: ele já possui getters e setters implícitos (hello lombok ), que podem ser substituídos a qualquer momento, se desejar. Ao mesmo tempo, lemos e modificamos o valor do campo simplesmente acessando-o diretamente e, nos bastidores, ele é chamado de 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 forneceu uma sintaxe conveniente e uniforme para percorrer sequências: você simplesmente usa uma variável à esquerda , uma sequência à direita e a palavra-chave “ in ” no meio, o tipo é determinado automaticamente pelo conteúdo. Solteiro

// 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
    }
}

O conhecido padrão “ singler ” é usado com bastante frequência na prática, então Kotlin decidiu criar uma palavra-chave separada “ object ”, que é escrita em vez de “ class ” e significa que a classe é um singleton; quando usada, você nem precisa precisa chamar o construtor ou qualquer outro método! Parâmetros de método nomeado e valores padrão

// 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")
}

Acontece que nem todos os parâmetros de um método ou construtor devem ser obrigatórios, e em Java estamos acostumados a criar um conjunto de métodos ou construtores para cada combinação possível de parâmetros. Parâmetros padrão foram introduzidos no Kotlin, o que permite declarar 1 método e passar o conjunto necessário de parâmetros para ele, dependendo da situação. Fluxos

// 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) }
}

A introdução do stream no Java 8 tornou-se uma funcionalidade integral ao trabalhar com coleções. No Kotlin, os streams se tornaram ainda mais convenientes e funcionais: cada coleção já possui um conjunto de métodos convenientes e usados ​​com frequência para trabalhar com dados. Além disso, observe a expressão lambda dentro do primeiro método: se um literal de função tiver exatamente um parâmetro, sua declaração pode ser removida (junto com ->) e chamada de  it . É hora de encerrar... Demonstrei apenas uma pequena parte básica da funcionalidade, mas tenho certeza que você já quer experimentar o Kotlin! Da minha experiência posso tirar as seguintes conclusões:

• É muito fácil para um desenvolvedor Java dominar a sintaxe Kotlin e começar a escrever código;
• Kotlin é totalmente compatível com Java e você já pode testá-lo em seus projetos existentes, por exemplo, em testes;
• O código Kotlin é mais limpo e legível, você não precisa escrever um monte de clichês ;
• IDEA possui um conversor automático de Java para Kotlin, você pode pegar o código Java pronto e convertê-lo automaticamente para Kotlin;
• um novo projeto precisa ser escrito em Kotlin, porque do ponto de vista de infraestrutura é o mesmo Java, mas em termos de uso é melhor e mais conveniente!

Se você gostou do artigo e geralmente é relevante em um recurso sobre Java, posso continuar escrevendo sobre a experiência de usar Kotlin em um projeto empresarial real. Links Úteis:

• Tente escrever algo em Kotlin online
• Aprendendo Kotlin - um conjunto e uma descrição de vários exemplos interativos
• Plugin para IDEA para treinamento com validação (como mini-JavaRush)
• Site oficial do Kotlin
• Site Kotlin russo