Gilliard Cordeiro

Saiu o segundo rascunho da especificação do JSF 2.0, no entanto ainda não há uma versão da implementação da EDR2 disponível para download como já saiu para a EDR1.

Primeiramente, vou me basear nas diferenças entre as reviews 1 e 2, mas isso não significa que o que vou falar aqui é inédito pois podemos ver na net diversos post comentando o que vem por aí. E também ainda não li tudo, a idéia é compartilhar o que mais me chamou a atenção nesse primeiro contato.

FacesContext

Sem dúvida essa é uma das classes que mais manipulamos no JSF, e nela temos algumas funcionalidades novas interessantes:

• getCurrentPhaseId() – Disponível desde a EDR1, devolve um PhaseId. Pode ser bem útil para fazermos algumas coisas só depois de uma dedeterminada fase.
• getExecutePhaseClientIds() - Devolve uma List<String>. Guarda uma lista com os client ids dos componentes que serão processados na requisição atual. Isso porque o JSF2 tem nativamente o suporte à ajax, e submissão parcial da página.
• getPartialResponseWriter() - Devolve o ResponseWriter para os componentes de uma renderização parcial.
• getRenderPhaseClientIds() - Devolve uma List<String> contendo os client ids dos componentes que serão renderizados em uma renderização parcial.
• isAjaxRequest() - devolve um boolean dizendo se a requisição é ajax (auto explicativa né )
• isExecuteNone() - retorna true se for uma submissão parcial mas nenhum componente precisará ser processado. Seria como dar apenas um reRender usando o ajax4jsf mas sem mandar executar nada.
• isPostback() - método "atalho" para ResponseStateManager.isPostback(FacesContext).
• isRenderAll() - Retorna true se for uma requisição ajax, isRenderNone() retornar falso, e getRenderPhaseClientIds() retornar uma lista vazia.
• isRenderNone() - Retorna true caso for para executar uma renderização parcial, mas a lista de componentes a renderizar for vazia. Imagine uma requisição ajax que só envia dados ao servidor.

Para os métodos get dessa lista, também tem os respectivos set.

Annotations

Uma coisa que todo mundo esperava está disponível no EDR2, que é a possibilidade de anotar nossos managed beans com @ManagedBean, @FacesValidator, @FacesConverter e @FacesComponent entre outros.

Para quem já está habituado com o Seam vai se sentir bem a vontade, pois as anotações seguem o mesmo estilo.

Apesar de no começo parecer estranho esse prefixo "Faces" em todas essas anotações, fica útil para não confundir com as interfaces com o mesmo nome. Sem isso (no Seam é assim), como importamos a anotação e a interface com o mesmo nome, uma das duas tem que ficar com o nome totalmente especificado. Não que seja problema, mas com esse prefixo fica mais "limpinho".

@ManagedBean

• name - nome do managed bean
• scope- escopo. O que não pareceu tão legal é que a gente passa uma String ("request", "session" ou "application"), quando seria mais bacana uma Enum como o Seam faz. O valor default é "none".
• eager - se for true, o managed bean será startado junto com a aplicação, e o "escope" passado será ignorado, e o managed bean será do escopo application. Se for false, fica como é hoje (lazy). O default é false.

@RequestScoped, @SessionScoped, @ApplicationScoped, @NoneScoped, @ViewScoped, @CustomScoped

• Cada uma das anotações representando seus respectivos escopos

@FacesConverter

• value - string que representa o converter-id do conversor
• forClass - passamos o java.lang.Class da classe que queremos registrar o conversor na forma de converter-for-class

@FacesValidator

• value - string que representa o validator-id do validador

@FacesComponent

• value - string que representa o component-type do UIComponente

Facelets 2

O outro assunto que de cara me interessou foi a integração do JSF com o Facelets, pois já uso Facelets há um bom tempo e nem me imagino fazendo uma aplicação em JSF sem ele. Tanto que até escrevi uma matéria pra a MundoJava sobre Facelets e as novidades do JSF 1.2. Na época eu comentei sobre a versão 1.2 do Facelets que nunca chegou a sair, talvez porque o pessoal passou a investir no JSFTemplating ou quem sabe viram que compensaria partir logo para um 2.0. Mas no Facelets 1.2 já podíamos ver o que provavelmente foi a base da API de Ajax para o JSF2.

No JSF2 temos o chamado PDL (Page Declaration Language), que é uma abstração para os mecanismos de definição de páginas disponíveis para o JSF, que até agora são JSP e Facelets. Porém se a gente der uma espiadinha no projeto JSFTemplating, podemos ver que existe a possibilidade de usarmos outras coisas, como Groovy por exemplo. Então é bem possível que vejamos coisas parecidas para o JSF2. Só para concluir a idéia, já é possivel usar Groovy em vez de xhtml para construir telas com Facelets, usando Gracelets. É bem bacana e eu já fiz uns testes que depois vou postar aqui também. Mas vamos voltar ao assunto.

Na EDR2 é explicado como será mantida a compatibilidade retroativa com as aplicações que usam Facelets. Basicamente será procurando dentro das classes da nossa aplicação ou das dependencias dela se existe alguma dependencia de classes do pacote com.sun.facelets e/ou dos seus subpacotes. Se houver, o Facelets embarcado no JSF não vai rodar, e as coisas vão continuar como estão, onde quem roda é o facelets que está no jar da nossa aplicação. Agora se não houver dependencia com as classes do Facelets atual, o Facelets2 entra em ação.

Composition Component com JSF/Facelets 2

Primeiramente, seria interessante dar uma olhada no suporte a recursos do JSF2 para entendermos melhor como tudo vai funcionar. Vou seguir o exemplo da documentação para facilitar.

Um composition component vai ser definifo usando o suporte a resources do JSF2. Imagine que o source do nosso componente é o foo.xhtml que está dentro da pasta ezcomp que por sua vez fica dentro da pasta de resources do JSF. Para usarmos esse componente nao precisamos mais de um arquivo taglib.xml, bastara chamarmos assim:

1
2
3
4
5
6
7
8
9
10
11
12

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml"
 xmlns:h="http://java.sun.com/jsf/html"
 xmlns:f="http://java.sun.com/jsf/core"
 xmlns:ui="http://java.sun.com/jsf/facelets"
 xmlns:ez="http://java.sun.com/jsf/composite/ezcomp">
 
   ...
   <ez:foo />
   ...
</html>

Como podemos ver nossos componentes ficam automaticamente visíveis usando o padrão http://java.sun.com/jsf/composite/<composite-library-name> onde <composite-library-name> é o nome da nossa pasta dentro do resources do JSF. E cada xhtml dentro dessa pasta pode ser acessado como um componente. Vimos aqui um bom exemplo de CoC no JSF2. Agora se quisermos usar um padrão diferente de nomenclatura para nossos componentes, basta usar o bom e velho arquivo de configuração de taglibs do facelets.

Agora ainda seguindo o exemplo disponível na versão snapshot (e provavelmente será a mesma do EDR2), vamos ver como fica o código de um componente definido em um arquivo chamado loginPanel.xhtml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:composite="http://java.sun.com/jsf/composite">
<head>
<title>Not present in rendered output</title>
</head>
<body>
 
<composite:interface name="loginPanel"
                     displayName="Very Simple Login Panel"
                     preferred="true"
                     expert="false"
                     shortDescription="An illustration of the composite component feature">
 
  <composite:attribute name="model" required="true">
 
    <composite:attribute name="loginAction" required="true">
      <composite:deferred-method>
        <composite:method-signature>
                    java.lang.Object action()
        </composite:method-signature>
      </composite:deferred-method>
     </composite:attribute>
 
   </composite:attribute>
 
 
  <composite:editableValueHolder name="username" />
  <composite:actionSource name="loginEvent" />
  <composite:actionSource name="cancelEvent" />
  <composite:actionSource name="allEvents" targets="loginEvent,cancelEvent" />
 
  <composite:facet name="header" />
 
</composite:interface>
 
<composite:implementation>
 
<table border="1">
  <thead>
    <tr>
      <th>
     <composite:insertFacet name="header" />
      </th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>
      <p>
         <h:inputText id="username" />
      </p>
      <p>
	<h:commandButton id="loginEvent" value="Login" action="#{compositeComponent.attributes.model.loginAction}">
 
	</h:commandButton>
	<h:commandButton id="cancelEvent" value="Cancel" action="cancel">
	</h:commandButton>
      </p>
      </td>
    </tr>
    <tr>
      <td>
     <p>This is the login panel footer</p>
     <composite:insertChildren />
      </td>
    </tr>
  </tbody>
</table>
</composite:implementation>
</body>
</html>

Coloquei o código todo, mas o mais importante é da linha 12 até a linha 41, que é onde definimos as características do nosso componente. Isso deve facilitar que ferramentas deem suporte aos nossos componentes, e também a quem for usar esses componentes, pois damos mais informações a respeito das propriedades que ele precisa. A documentação diz que em muitos casos será possível construir componentes sem prover essas informações, deixando mais parecido com o que é hoje, mas diz também que falta definir um limite de até onde pode ser feito um componente sem especificar esse "contrato de uso".

Uma coisa interessante que pode ser vista nesse exemplo é a exigencia de um método chamado loginAction com uma assinatura específica dentro do objeto que for passado no atributo model.

O código que usa esse componente pode ser visto a seguir

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:ez="http://java.sun.com/jsf/composite/ezcomp">
<h:head>
<title>The Simplest EZComp Demo That Could Possibly Work</title>
</h:head>
<h:body>
<p>Login Panel Component</p>
  <ui:debug hotkey="p" rendered="true"/>
<h:form>
  <div id="compositeComponent" class="grayBox" style="border: 1px solid #090;">
 
    <ez:loginPanel id="loginPanelInConsumingPage" model="#{bean}">
 
      <f:valueChangeListener for="username" binding="#{bean.useridValueChangeListener}" />
      <f:actionListener for="loginEvent" binding="#{bean.loginEventListener}" />
      <f:actionListener for="cancelEvent" binding="#{bean.cancelEventListener}" />
      <f:actionListener for="allEvents" binding="#{bean.allEventsListener}" />
 
      <f:facet name="header">
         <h:panelGroup id="headerFacetInConsumingPage">
          <h:outputText value="this is the header facet in the consuming page" />
         </h:panelGroup>
      </f:facet>
      <h:outputText id="childInConsumingPage" value="this is a child component in the consuming page" />
    </ez:loginPanel>
  </div>
<p><h:commandButton value="reload" /></p>
</h:form>
</h:body>
</html>

Nesse exemplo pode reparar da linha 18 a 21 que usamos os composite:actionSource definidos no componente como ganchos para pendurar nossos listeners.

Só lembrando que esses exemplos são em cima da EDR2 do JSF2, então tudo que foi visto aqui pode não ser igual ao que vai estar na versão final.

Facelets, JSF, JavaEE Facelets, JavaEE, JavaServer Faces, JSF

No post anterior entre outras coisas, comentei de implicit arguments, agora vou comentar um pouco de implicit converters.

Implicit Converters

Outra funcionalidade para os implicits são os conversores implicitos. Essa funcionalidade permite adicionarmos características super dinamicas mas sem deixar que fiquemos com a sensação de não sabermos de onde vem as coisas. O que o compilador do Scala faz é olhar se estamos tentando usar um objeto de um determinado tipo como se fosse de um outro tipo, e então procura uma função que converta um objeto do primeiro tipo para o último.

Por exemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Vaca {
    def mugir() = "muuuuuuu"
}
//...
class Cachorro {
    def latir() = "au!"
}
 
//...
 
var mimosa = new Vaca
 
def passearComCachorro(toto: Cachorro) = {
    toto.latir()
}
 
passearComCachorro(mimosa) // isso vai dar erro?!
 
//a não ser que eu tenha algo assim
class Vacachorro(vaca: Vaca) extends Cachorro {
    override def latir() = "Antes eu fazia " + vaca.mugir() + ", mas agora eu sei latir!"
}
 
//e esse método converte
implicit def funcaoQueConverteVacaEmCachorro(vaca: Vaca) = new Vacachorro(vaca)

Esse código parece bem esquisito mas funciona. Eu dei um exemplo bem esdrúxulo apenas para mostrar a possibilidade que o Scala dá. Obviamente os conversores geralmente são usados para converter um tipo numérico em outro, ou coisas do genero, mas dei um exemplo pouco convencional propositalmente.
Na linha 17 o compilador do Scala procura por uma função que receba uma Vaca e devolva um Cachorro, porque é o tipo de conversão que ele percebe que precisa acontecer. Entao o compilador faz algo assim:

passearComCachorro(funcaoQueConverteVacaEmCachorro(mimosa))

Agora caso o compilador não encontrasse nenhuma, ou mais de uma função desse tipo, ele daria erro de compilação.
Mas fora converter ao chamar uma função, o Scala permite também fazer isso:

mimosa.latir()

Que em tempo de compilação o Scala vai transformar em

funcaoQueConverteVacaEmCachorro(mimosa).latir()

Novamente gostaria de frisar que esse exemplo é mais didático do que funcional. Na prática poderíamos criar um conversor assim

1
2
3

implicit def conversorQualquer(objeto: Any) = new {
        def latir() = "Um objeto qualquer agora passou a latir"
}

Ou então poderíamos ter esses conversores em alguma outra classe e usar “static imports” para importar esses conversores para nosso código.

Lembrando sempre que se se não houver, ou haver mais de um conversor compatível, o compilador vai dar erro de compilação.

Conversores implicitos dão a mesma facilidade de “open classes” com a vantagem que essa conversão só terá efeito no trecho de código onde a função de conversão está visível. Não acontece de adicionarmos uma função em um objeto num canto do sistema e a mesma estar visível em outro, o que é uma desvantagem em potencial das open classes.

Esses conversores são usados muitas vezes pela pelo próprio Scala. Vejam por exemplo a documentação da classe Int onde é dito que existe um conversor implícito que converte uma instancia de Int para RichInt.

Num próximo post vou comentar sobre mixins classes com Scala.

Scala Linguagem JVM, Scala

No post anterior a gente viu algumas coisas de Scala de uma forma mais solta, para irmos acostumando com a inguagem. A partir deste post vou tentar mostrar algumas coisas mais específicas.

Functions

Em Scala, uma função é “first-class value”, isso que dizer que assim como qualquer outro valor elas podem ser passadas como parametro para outras funções e serem valores de retorno de funções.

object Main extends Application {
    def percorreLista[T](lista:List[T], funcao:(T) => Unit)= {
    for (elemento <- lista) {
      funcao(elemento)
    }
  }
 
  def imprimeElemento[T](elemento:T) = {
    println(elemento)
  }
 
  percorreLista(List(2,3,4,5), imprimeElemento)
}

Aqui definimos uma função chamada percorreLista que faz o que o nome diz e para cada elemento ela invoca uma outra função passada como parametro, no caso a função imprimeElemento. Reparem na linha 2 a definição dos tipos dos parametros. O primeiro é uma lista do tipo T, nada demais. O segunda parametro é um pouco mais interessante. Definimos uma variável chamada funcao que é do tipo “função void que recebe T como parametro”. Então na linha 12 passamos a função imprimeElemento como parametro para a função percorreLista. A saída desse trecho de código é a seguinte

2
3
4
5

Da mesma forma que passamos uma função como parametro, poderíamos retornar uma também. Mas para não alongar muito isso fica como tarefinha

O caracter _

Uma das coisas que eu mais estranhei nos códigos feitos com Scala, foi a constante aparição de um “_”, geralmente sendo passado como argumentos de funções. Isso causou mais estranheza pois em Java quase não temos esse caracter. Mas vamos a mais um exemplo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

object Main extends Application {
 
    def escreveString(s:String) = {
    println("Escrevendo->"+s)
  }
 
  def somatorio(i:Int*) = {
    "Soma=" + i.reduceLeft((a: Int, b: Int) => b + a) // executa mas nao faz efeito
    "Soma=" + i.reduceLeft((a,b) => a + b) //executa mas nao faz efeito
    "Soma=" + i.reduceLeft(_+_) //executa mas nao faz efeito
    "Soma=" + i.foldLeft(0)(_+_) //executa mas nao faz efeito
    "Soma=" + (0 /: i)(_+_) // executa e retorna
  }
 
  escreveString(somatorio(1,4,6))
}

Saída

Escrevendo->Soma=11

Como sempre eu já apriveitei o mesmo exemplo para mostrar várias coisas. Só vou falar da função domatorio, já que o resto só usa o que nós já vimos antes. A começar pelo parametro, é assim que definimos varargs em Scala. Então temos uma função que recebe uma lista de Int de tamanho variável. Na prática I é do tipo Seq[Int].

No corpo dessa função eu coloquei de formas diferentes a mesma coisa, porém parti do mais legível para o mais ilegível. As funções reduceLeft e foldLeft trabalham de formas diferentes, mas nesse caso o resultado é o mesmo. Olhando o exemplo da documentação fica fácil entender como elas funcionam.

Como eu já disse antes, o retorno de uma função é sua última instrução. Nesse exemplo da função somatório, apenas a linha 12 retorna, as demais efetuam a mesma operação mas o valor é perdido por ninguem usar. A idéia é mostrar as formas diferentes de fazer a mesma coisa, e assim facilitar o entendimento do uso do caracter “_”.

Da linha 8 até a linha 10 usamos a função reduceLeft, e de cima para baixo eu fui reduzindo a especifidade dos parametros. Na linha 8 eu deixei totamente especificado e inverti o ordem ao somar a e b. Não que isso faça diferença no resultado, mas só para exemplificar que a vantagem de se ter as duas variáveis explicitas é poder saber “quem é quem”. Na linha seguinte eu não informei mais o tipo das variáveis a e b pois o Scala consegue perceber isso pra mim, mas continuo podendo brincar com a ordem os parametros pois ainda sei quem é quem.

A partir da linha 10 eu comecei a usar o caracter “_”. Veja que da linha 9 para a 10, olhando o código nós conseguimos perceber que não é tão útil ter as duas variáveis ali pois simplesmente repassamos elas para a expressao a + b. Olhando dessa forma a sintexe da linha 10 parece fazer mais sentido, pois nessa linha nós dizemos que tanto faz quais são as variáveis, eu só quero somá-las. O problema de usar isso é que a legibilidade do código começa a piorar um pouco.

Agora vamos ver as linhas 11 e 12. Olhando a documentação da função foldLeft vemos que ela recebe mais um parametro que o ponto de partida. Como estamos trabalhando com uma soma, passamos o 0, se fosse uma ultiplicação passaríamos 1, pois queremos que esse parametro não influencie no resultado. Mas apesar de mudarmos de função a sintaxe usada las linhas 10 e 11 são equivalentes. Agora na linha 12 bagunçamos de vez e usamos /:, um alias para a função foldLeft. Novamente o problema do código dessa linha é que fica muito ilegível. Olhando para ela, a sintaxe das linhas 10 e 11 até parece mais simpática

Múltiplas listas de argumento

Em Scala uma função, diferente do que acontece no Java, pode ter diversas listas de argumentos

object Main extends Application {
    def imprimeStrings(s:String)(s2:String) = {
        println(s2 + "-->" + s)
    }
    imprimeStrings("A", "B")

Saída

B-->A

Pode parecer meio estranho, mas essa sintaxe permite que façamos algo interessante com esse último parametro. A seguir continuamos o código de cima.

    def funcaoQueDevolveString(i:Int) = {
        "Número:" + i
    }
    imprimeStrings("A") {
        funcaoQueDevolveString(5)
    }
}

Saída

A-->Número:5

A funcaoQueDevolveString é só para ilustrar que dentro do bloco de código da chamada da função imprimeStrings eu posso fazer qualquer coisa, desde que o retorno desse corpo seja do tipo do parametro que ele substitui.

Implicit parameters

Outra aplicação para mais de uma lista de argumentos é quando queremos ter uma lista de argumentos implicita. Vamos ao exemplo.

object Main2 extends Application {
    implicit var user = "Gilliard"
 
    def executaOperacao(f:()=>Unit)(implicit usuario:String) = {
        println(usuario + " vai executar uma operação")
        f()
        println(usuario + " executou uma operação")
    }
 
    def operacao() = println("Executando operação")
 
    executaOperacao(operacao)
}

Saída

Gilliard vai executar uma operação
Executando operação
Gilliard executou uma operação

Como isso funciona? Definimos uma função executaOperacao que recebe como primeiro parametro uma função. Até aqui nada de novo. Porém definimos uma segunda lista de argumentos com implicit. A palavra reservada implicit deve ser aplicada no início de uma lista de argumentos, e afeta todos os argumentos dessa lista. Além disso essa lista de argumentos deve ser a última. Então caso eu queira ter argumentos “normais” e argumentos implicitos, eu precisaria ter duas listas de argumentos como no exemplo.
Quando o compilador do Scala encontra uma função com parametros implicitos, ele busca por objetos implicitos que sejam compatíveis com esses parametros. Caso encontre, como no nosso exemplo, tudo bem, agora se não houver nenhum objeto implicito compatível teremos um erro de compilação. Mas isso é bem flexível, se eu não tivesse um objeto implícito e quisesse invocar uma função com parametros implícitos é só eu passar explicitamente esses parametros. Um parametro implícito se torna opcional, mas não é proibido colocar um valor explícito. Agora se mais de um valor explícito compatível estiver disponível o compilador não vai tentar adivinhar qual usar, vai dar erro de compilação.

No próximo post vou falar de implicit converters, que na minha opinião (lembrando o pouco conhecimento que tenho) é uma das coisas mais bacanas do Scala. Aí sim a gente começa a ver o poder de uma linguagem escalável, com muito dinamismo mas sem deixar que “vire zona”.

Scala JustJava 2008, Linguagem JVM, Scala

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 lista = new ArrayList();

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 é

antes
depois
durante

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

i % 2 == 0

em vez de usar o equivalente

(i.%(2)).==(0)

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.

Scala Java, JustJava 2008, Linguagem JVM, Scala