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() !
// 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 !
// 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)
// 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 ”.
// 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!
GO TO FULL VERSION