O que sinto falta em Java, a perspectiva dos desenvolvedores Kotlin

By | Junho 13, 2022

Em Java, a classe é expandida subclassificando:

class Foo {}
class Bar extends Bar {}

A subclasse tem dois problemas principais. O primeiro problema é que algumas classes não permitem: são marcadas com final palavra chave. Existem várias classes JDK amplamente usadas final, por exemplo., String. Outro problema é que, se um método além do nosso controle retornar um tipo, ele ficará preso a esse tipo, independentemente de conter o comportamento desejado ou não.

Para contornar os problemas acima, os desenvolvedores Java inventaram o conceito de classes de serviço, comumente chamadas de XYZUtils para a espécie XYZ. A classe útil é a multidão static métodos são private construtor para que não possa ser instanciado. Este é um namespace celebrado porque Java não permite métodos fora das classes.

Dessa forma, se o método não existir no tipo, a classe de serviço pode fornecer um método que receba o tipo como parâmetro e execute o comportamento necessário.

class StringUtils {                                          (1)

    private StringUtils() {}                                 (2)

    static String capitalize(String string) {                (3)
        return string.substring(0, 1).toUpperCase()
            + string.substring(1);                           (4)
    }
}

String string = randomString();                              (5)
String capitalizedString = StringUtils.capitalize(string);   (6)

1 Classe útil
2 Impedir a instalação de novos objetos deste tipo
3 static método
4 Letras maiúsculas e minúsculas fáceis de usar que não levam em consideração os ângulos
5 o String type não oferece função de maiúsculas e minúsculas
6 Use a classe de serviço para fatorar esse comportamento

Anteriormente, os desenvolvedores criavam essas classes dentro de um projeto. Hoje, o ecossistema oferece bibliotecas de código aberto, como Apache Commons Lang ou Goiaba. Não reinvente a roda!

Kotlin fornece a capacidade de estender uma classe ou interface com novas funcionalidades sem a necessidade de herdar uma classe ou usar padrões de design como Decorador. Podemos conseguir isso através de declarações especiais, as chamadas extensões.

Por exemplo, você pode escrever novas funções para uma classe ou interface de uma biblioteca de terceiros que não pode ser modificada. Tais funções podem ser chamadas da maneira usual como se fossem métodos de classe fonte. Esse mecanismo é chamado de função de extensão.

Para declarar uma função de extensão, adicione o prefixo a ao seu nome receptor type, que se refere ao tipo que está se expandindo.

Além das funções de extensão, o código acima pode ser reescrito como:

fun String.capitalize2(): String {                           (1) (2)
    return substring(0, 1).uppercase() + substring(1);
}

val string = randomString()
val capitalizedString = string.capitalize2()                 (3)

1 Função de flutuação livre, sem necessidade de quebras de classe
2 capitalize() já existe no stdlib do Kotlin
3 Chame a função de extensão como se ela pertencesse String modelo

Observe que as funções de extensão são tratadas “estaticamente”. Na verdade, eles não associam um novo comportamento a um tipo existente; eles fingem fazer isso. O bytecode gerado é muito semelhante (se não o mesmo) a um dos métodos estáticos Java. No entanto, a sintaxe é muito mais clara e permite o encadeamento de funções, o que é impossível com a abordagem do Java.

Deixe uma resposta

O seu endereço de email não será publicado.