Respostas:
Eles são chamados de tipos de plataforma e significam que o Kotlin não sabe se esse valor pode ou não ser null
e cabe a você decidir se é anulável ou não.
Em poucas palavras, o problema é que qualquer referência vinda de Java pode ser nula, e o Kotlin, por ser nulo por design seguro, forçou o usuário a verificar nulos todos os valores Java ou a usar chamadas seguras (
?.
) ou asserções não nulas (!!
) Esses recursos são muito úteis no mundo puro do Kotlin, tendem a se transformar em um desastre quando você precisa usá-los com muita frequência na configuração Kotlin / Java.É por isso que adotamos uma abordagem radical e tornamos o sistema de tipos do Kotlin mais relaxado no que diz respeito à interoperabilidade Java: agora as referências provenientes de Java têm tipos especialmente marcados - Kotlin Blog
É a notação para os tipos de plataforma :
T!
significa " T
ou T?
"
T
significa " T!
ou T?
"
T
foi tornado "não anulável", e o resto foi mais ou menos arbitrário
Um tipo anotado com !
é chamado de tipo de plataforma , que é um tipo proveniente de Java e, portanto, provavelmente pode ser null
. É o que o compilador Kotlin deduz por padrão ao chamar Java (nos casos mais básicos, os métodos Java podem ser anotados para contornar isso). Você deve manipular os tipos de plataforma como tipos anuláveis , a menos que você certamente saiba que a API específica nunca retornará null
. O compilador permite que tipos de plataforma sejam atribuídos a variáveis de tipos anuláveis e não nulos.
Notação para tipos de plataforma
[...]
T!
significa "T or T?
" [...]
Você pode se referir aos tipos de plataforma como "tipos de nulidade desconhecida ". Também é importante saber que você não pode usar o tipo de marca de exclamação para seus próprios tipos, não faz parte da sintaxe do Kotlin, é apenas uma notação .
Os nomes de tipo ou classe que terminam com um único ponto de exclamação !
são chamados de Tipos de plataforma no Kotlin. Você os encontra quando está trabalhando no Kotlin com código Java antigo que não contém informações de nulidade.
Por exemplo:
@Nullable String
em Java é considerado como String?
por Kotlin.
@NotNull String
em Java é considerado como String
por Kotlin.
String
sem anotações em Java é considerado como String!
pelo Kotlin.
Você pode trabalhar com um tipo de plataforma como nulo ou não nulo. O compilador permitirá que você chame todos os métodos nesse tipo. É sua responsabilidade como usá-los. Se você souber que o valor pode ser nulo, compare-o com nulo antes de chamar os métodos. Se você souber que não é nulo, poderá usá-lo diretamente, mas como em Java, você receberá uma exceção se sua suposição sobre a nulidade estiver errada.
Observe que você não pode declarar tipos de plataforma no código Kotlin, eles vêm apenas do código Java.
Ao substituir os métodos Java no código Kotlin, você tem a opção de declarar parâmetros e retornar tipos como nulos ou não nulos. Você precisa escolher isso com sabedoria, porque se você decidir tornar os parâmetros não nulos, o compilador Kotlin gera asserções não nulas para esses parâmetros não nulos. E na próxima vez que você acessar esse código Kotlin de volta do Java e passar um valor nulo, receberá uma exceção.
Espero que ajude a tirar todas as suas dúvidas sobre os Tipos de Plataforma.
Eu já vi isso algumas vezes, especialmente ao usar APIs Java
Como mencionado por s1m0nw1, T!
significa T or T?
. A próxima pergunta é: o que é T?
? Isso está bem documentado em https://kotlinlang.org/docs/reference/null-safety.html . O Kotlin não permite que certos elementos sejam null
, por exemplo String
, diferentes do Java
Para permitir nulos, podemos declarar uma variável como sequência anulável, escrita String ?:
var b: String? = "abc" b = null // ok
[...]
b?.length
Isso retorna b.length se b não for nulo e nulo caso contrário. O tipo de expressão é
Int?
.
Trecho dos tipos de plataforma no Kotlin :
Além de especificar explicitamente um tipo como opcional (por exemplo
Person?
), o Kotlin nos apresenta outro animal, chamadoPlatform Type
, especificado, colocando um único ponto de exclamação (por exemploPerson!
). Esse conceito foi criado por motivos de compatibilidade, ao acessar código de plataformas nulas e não seguras, como Java. Geralmente, ao usar uma biblioteca Java, muitos métodos retornamSomeType!
, pois o compilador Kotlin não pode inferir se o resultado é nulo ou não.
Por exemplo:
(Mutable)Collection<T>!
Significa apenas o seguinte: "A coleção Java de T pode ser mutável ou não, pode ser anulável ou não ".
Espero que isto ajude.
platform types