Hoje em discussão com colegas aqui na empresa percebi que existe algo interessante na linguagem Scala que merece ser citado, aproveitando o raciocínio de ontem: a Conversão Implicita.
A melhor forma de apresentar isto é fazendo uma demonstração. Então criamos duas classes que se referem ao tipo geral, automóvel (conceitualmente), porém não correlacionadas diretamente (através herança, por exemplo), logo é de se supor que seja possível criar algo do tipo:
def fiatUnoMy(b:FiatUno){
...
println(b.my())
}
onde,
class Automovel() {
val name = "FiatUno"
def my():String = "Is my FiatUno"
}
class FiatUno(name:String) {
def getName() = name
}
Bem... então a primeira vista algum pode até imaginar que a linguagem é possui alguma inteligência ou que o método my() é um membro de qualquer classe. Porém, nenhum destes pensamentos é verídico. Esse fato expetacular ocorre porque o FiatUno é convertido implicitamente em um Automóvel. Como? Ai está o legal da história! Utilizando-se do mecanismo de "Implicit Convertion". Explicando em miudos: através deste mecanismo é possivel ter uma classe A (de automóvel) que possui um método x, cuja instrução A.x é possível. Uma outra classe, independente de A, chamada de F (de fiat uno), não poderá, então realizar a operação F.x, dado que x mão é um membro de F. Para isto é necessário transformar A em F, ou seja, tornar A = T(F) . E isto é feito através de uma função chamada implicitamente pelo compilador, levando a situação T(F).x. Será que este assunto não é familiar para você? (para quem estudou Algebra, com certeza!). Em Scala, esta transformação é feita da seguinte maneira:
...
implicit def convertToAutomovel(f: FiatUno) = new Automovel()
implicit def convertToFiatUno(a: Automovel) = new FiatUno("New Fiat Uno")
...
Com isto é possível termos:
def fiatUnoMy(b:FiatUno){
println(b.getName)// print: New Fiat Uno
println(b.name)//print: Fiat Uno
println(b.my())//print: Is my FiatUno
}
Isto é show demais!!
Bem, por agora é só! Até a próxima.
Nenhum comentário:
Postar um comentário