Existe alguma diferença entre Kotlin e Java?

Olá a todos. Quero contar algumas coisas básicas sobre a linguagem Kotlin, que serão úteis para iniciantes. Acontece que agora será difícil entrar no desenvolvimento Android com apenas uma linguagem - a maioria dos novos projetos começa a ser escrita em Kotlin, a maioria dos projetos prontos são escritos em Java. No momento tenho 4 projetos em andamento: dois em Kotlin e dois em Java (um grande principal e três pequenos para uso interno). Quando a empresa decidiu escrever novos projetos em Kotlin, essa decisão me pareceu estranha. Por que misturar idiomas diferentes? Deixe outra pessoa escrever em Kotlin, por que precisamos disso? Mas não havia saída, então resolvi experimentar um novo idioma e comecei a estudá-lo. O primeiro código, é claro, foi escrito inteiramente no estilo Java, o que aumentou ainda mais o mal-entendido: por que preciso de uma nova linguagem? Mas à medida que o usei, descobri cada vez mais vantagens e agora (escrevo em Kotlin há quase 2 anos) posso dizer que Kotlin é mais conveniente no desenvolvimento Android. Quero mostrar algumas nuances que não serão óbvias para quem decidiu começar a aprender Kotlin depois de Java. Deixe-me lembrá-lo também que o Android usa Java 8, com a versão atual sendo 14. Então, primeiro - Variáveis : Java:

Int a = 1;
String s = "test";

Kotlin:

val a = 1
var b = 2
val c: Int
val d = "test"

Existem dois tipos de variáveis ​​​​em Kotlin: val (somente leitura) e var (leitura-gravação). Recomenda-se usar val sempre que possível. Não é necessário declarar o tipo de uma variável se a variável já tiver sido inicializada. Segundo - instruções if/else, switch : com que frequência você usa essa cadeia de instruções em Java:

if (вариант 1)
{...}
else if (вариант 2)
{...}
...
else
{...}

Ou assim:

switch(выражениеДляВыбора) {
        case (meaning 1):
                Код1;
                break;
        case (meaning 2):
                Код2;
                break;
...
        case (meaning N):
                КодN;
                break;
        default:
                КодВыбораПоУмолчанию;
                break;
        }

Em Kotlin, o operador when é usado para tais expressões (embora if/else também possa ser usado):

val x = 5
val result = when(x) {
        0, 1 -> "cool"
        2 -> "bad"
        5 -> "normal"
        else -> "error"
}
System.out.println(result)

Aqui não apenas passamos pela cadeia de condições, mas também atribuímos imediatamente a expressão inteira à variável de resultado, o que nos economizou algumas linhas de código. Mas ainda assim, se você tiver apenas duas opções em um branch, recomendo usar o if..else usual. O tempo de construção será mais curto em apenas três variantes. Vamos em frente - Construtores . É um conto de fadas aqui. Basta comparar o código em Java e Kotlin. Java:

public class Person {

    private String firstName;
    private String lastName;
    private int age;

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Kotlin:

class Person(private val firstName: String,
             private val lastName: String,
             private var age: Int) {
}

Pode parecer que algo ficou inacabado no código Kotlin. Mas não, são dois códigos idênticos em idiomas diferentes. Vamos descobrir um pouco. No Kotlin, o construtor pode ser escrito diretamente no corpo do nome da classe (mas se você quiser, pode fazer isso à moda antiga, como em Java). Então, escrevemos três variáveis, em Java criamos um construtor, getters e um setter para a variável idade. No Kotlin, como lembramos, a variável val é somente leitura e, portanto, o setter para essas variáveis ​​não está disponível (o Kotlin implementa getter-setters nos bastidores). A variável var permite que você use um setter. Como resultado, escrevemos quase em uma linha a mesma coisa que ocupava mais de uma dúzia de linhas em Java. Aqui recomendo ler mais sobre classes de dados em Kotlin. Mas não é só nisso que os construtores Kotlin são bons. Mas e se você precisar de dois construtores? E se houver três? Em Java ficaria assim:

public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

public Person(String firstName) {
        this.firstName = firstName;
    }

Nada complicado, apenas quantos designers fossem necessários, foi o que eles fizeram. No Kotlin você pode sobreviver com apenas um construtor. Como? É simples: valores padrão.

class Person(private val firstName: String,
             private val lastName: String? = null,
             private var age: Int = 5) {
}

Atribuímos valores padrão no construtor e agora chamá-los ficará assim:

Person(firstName = "Elon", lastName = "Mask", age = 45)
Person(firstName = "Elon", age = 45)
Person(firstName = "Elon", lastName = "Mask")

Pode surgir a pergunta: o que é isso:

private val lastName: String? = null

Quais são esses outros pontos de interrogação? Sim, se o valor puder ser nulo, então ele está definido ?. Também existe uma opção como esta - !!(se a variável não puder aceitar nulo). Leia você mesmo sobre isso, é tudo simples. E passamos para o próximo ponto. Extensões . Esta é uma ferramenta muito legal em Kotlin que não está disponível em Java. Às vezes, em um projeto, usamos métodos de modelo que são repetidos em muitas classes. Por exemplo, assim:

Toast.makeText(this, "hello world :)", Toast.LENGTH_SHORT).show();

Em Kotlin podemos estender uma classe:

fun Context.toast(message: CharSequence) = Toast.makeText(this, message, Toast.LENGTH_SHORT).show()

E então use assim durante todo o projeto:

context?.toast("hello world")

Fizemos uma extensão para a classe Context. E agora, onde quer que o contexto esteja disponível, seu novo método brinde estará disponível. Isso pode ser feito para qualquer classe: String, Fragment, suas classes customizadas, não há restrições. E o último ponto que veremos é Trabalhando com Strings . Tudo é simples aqui. Em Java está escrito assim:

String s = "friends";
int a = 5;
System.out.println("I have" + a + s + "!");

É mais fácil em Kotlin:

val s = "friends"
val a = 5
println("I have $a $s!")

Essas são as nuances que descobri no início do aprendizado do Kotlin. Espero que isso ajude você.