Estive presente no JustJava2008 e aos poucos vou postar aqui algumas das coisas interessantes que vi. Para começar, vou falar um pouco da linguagem Scala, que roda na JVM e que está ficando cada vez mais conhecida.
Há algum tempo, pesquisando sobre Groovy, encontrei este post que fala sobre Scala. Depois disso me interessei e pesquisei um pouquinho sobre Scala mas não evoluí muito no assunto.Porém depois da apresentação feita pelo Michael Nascimento no JJ08, me animei a brincar com Scala mais um pouco e, agora que já tinha um norte, ficou muito mais fácil conseguir fazer algumas coisas com essa linguagem.
Primeiramente gostaria de dizer que não sou um expert em Scala, só estou compartilhando o que tenho aprendido nos últimos dias. Como já disse, esse post foi basicamente inspirado na apresentação do Mr. M no JJ, e assim que as apresentações estiverem disponíveis vou colocar um link aqui. Outras fontes para esse artigo (e os próximos) é a série Roundup: Scala for Java Refugees, além da própria documentação do Scala.
Scala é um “mix” de linguagem OO e linguagem funcional. Em Scala tudo é objeto, não há primitivos, mas isso a gente ve mais pra frente. O nome Scala vem de “scalable language”. A idéia foi projetar uma linguagem que service bem para trabalhos simples como um pequeno script, até o desenvolvimento de grandes aplicações como fazemos hoje em Java com a “segurança de uma linguagem fortemente tipada”. Hoje em dia se fala muito sobre linguagens dinamicas que rodam na JVM, mas apesar de não parecer (pois olhando o código realmente as vezes não parece), Scala é fortemente tipada assim como Java. A diferença é que pelo fato do Scala usar de forma muito eficiente a inferencia de tipos, acabamos nao tendo aquela sintaxe carregada do Java onde temos que dizer o tipo em todos os lugares e ainda algumas vezes de forma repetida.
Entes de continuar, só para convencionar (mas não quero gerar polemica), chamei de dinamica uma linguagem não tipada.
Para os exemplos, eu usei o plugin do eclipse, mas voces podem ver os plugins disponíveis e usar sua IDE preferida.
Agora um exemplo das diferenças na hora da tipagem
List<String> lista = new ArrayList<String>();
em Java temos que informar duas vezes que estaremos trabalhando com uma List que guarda Strings.
var lista = List("A", "B")
//ou para ficar mais parecido com Java...
var lista = new ArrayBuffer[String]Note que nao foi necessário delarar a variável lista como uma coleção de Strings, isso porque o compilador do Scala, assim como nós, ao ler essa linha percebe que a lista referencia uma coleção de Strings. E se eu tentar adicionar qualquer outra coisa que não seja uma String vou ter um erro de compilação. Além disso como Scala não nos obriga a usar ‘;’ (ponto e vírgula) no final das intruções. Então olhando um código sem definições de tipos em muitos casos, e sem ‘;’, às vezes da a impressão que estamos trabalhando com uma “linguagem dinamica” como Groovy por exemplo, já que tem o “estilão” Java de nomearmos as coisas.
Para rodar um código Scala podemos começar de tres formas:
1 – script:
scala> println("Olá mundo!")
Olá mundo!2 – extendendo a “classe” Application (mais pra frente explico melhor porque coloquei classe entre aspas, mas basicamente é porque Application não é de um tipo Java como class ou interface)
object Main extends Application {
println("Olá mundo!")
}3 – ou ainda usando o já conhecido método main
object Main2 {
def main(args:Array[String]) = {
println("Olá mundo!")
}
}Com esses exemplos ja podemos perceber muitas diferenças em relação ao Java. Talvez a primeira coisa seja o object antes de Main e Main2. Em Java não temos como definir diretamente um object, apenas podemos declarar class e interface. Mas object nada mais é do que uma forma que a própria linguagem nós de definirmos um singleton. Na prática, todos os métodos de um object são acessíveis como métodos estáticos, mas internamente a execução é delegada para um singleton dessa “classe”. Por isso mesmo no exemplo 3 não precisamos definir o método main como estático.
Outra coisa que percebemos é que primeiro declaramos a variável, e depois (se for necessário) informamos o tipo. Isso não tem nada demais mas para quem está acostumado com Java como eu vai querer declarar “String s” algumas vezes antes de acostumar com “s : String” 
Outra coisa que pode ter passado batido no exemplo 2 é que o println está no corpo do nosso objeto, sem nenhum método em volta dele. Isso acontece porque Application tem um método main que nesse caso serve apenas para podermos executar nossa Main, mas na verdade quem executa o println da linha 2 do segundo exemplo é o contrutor do nosso objeto. Vamos a outro exemplo para ficar mais claro.
object Main3 {
println("antes")
def main(args:Array[String]) = {
println("durante")
}
println("depois")
}A saída do código acima é
Isso se deve ao fato de em Scala, o contrutor padrão de um objeto ser o corpo da classe (obviamente declaracoes de métodos não entram aqui). É como a inicialização estatica em java, que executa antes do contrutor, a diferença é que aqui o que seria essa inicliazação estatica é o contrutor. Mas vamos entrar mais a fundo nisso depois.
Vamos a mais um exemplo
object Main4 {
def main(args:Array[String]) = {
def éPar(i : Int) = {
i % 2 == 0
}
println( éPar(10) )
}
}A saída do trecho de código acima é true. Mas nesse exemplo podemos ver muitas outas coisas interessantes. Primeiramente dentro de um método podemos declarar outro método (além de diversas outras coisas, inclusive fazer imports visíveis dó naquele escopo). Em Java também podemos fazer algo parecido, usando uma classe interna anonima. Inclusive é isso que o Scala vai gerar no bytecode, mas isso já é outra história.
Só abrindo um parenteses, eu falo muito em método pois sou um programador Java, falando pra outros programadores Java, mas muita gente pode achar ruim pois talvez o correto seria eu falar function, lembrando que Scala é uma linguagem funcional. Fecha parenteses
Também não precisamos declarar o tipo de retorno do nosso método pois o Scala consegue inferir isso pra gente. Assim como eu posso olhar e perceber que isso vai retornar um Boolean, o compilador do Scala também pode.
Essa delcaracao seria o mesmo de
def éPar(i : Int) : Boolean = { ... }Assim como na definição da main eu poderia colocar asssim
def main(args:Array[String]) : Unit = { ... }Em Scala, o correspondente para o void do Java é Unit.
Outra coisa que não precisamos colocar explicitamente é o return, poi o Scala considera como o retorno de um método a sua última linha. No entanto em alguns casos, como no uso de recursão ou quando descobrimos antecipadamente o que deve ser retornado, acabamos precisando explicitar o return, aí nesse caso precisamos deixar explicito também o tipo de retorno do método.
Como a maioria das linguagens de script, Scala permite que chamemos um método de uma forma diferente, sem o ‘.’ e os “(…)” o que possibilita que possamos usar
em vez de usar o equivalente
Isso mesmo, pode parecer meio estranho mas isso é assim. Em Scala não existem primitivos, e também não existe sobrecarga de operadores (o que seria dos professores de POO com C++ que só sabiam dar isso de matéria se o Scala virasse padrão nessas instituições hein….). O que ocorre é que em Scala “%” e “==” são nomes válidos para métodos. Assim como praticamente qualquer coisa que podemos escrever como <<, >;=, +=, *, etc.
Esse primeiro post foi mais para dar uma idéia de como começar a brincar com Scala, mas nos próximos vou entrar em mais aspectos da linguagem como objetos imutáveis, traits, closures, etc.
Qualquer gafe minha voces postem um comentário que eu corrijo ok? Até o próximo.
Recent Comments