PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE...

60
CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DO RIO GRANDE DO NORTE GERÊNCIA EDUCACIONAL DE TECNOLOGIA DA INFORMAÇÃO CURSO SUPERIOR DE TECNOLOGIA EM DESENVOLVIMENTO DE SOFTWARE PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS Eder Carlos de Oliveira Nogueira Serrano Orientador: Ricardo Alexsandro de Medeiros Valentim, Dr. (DACGEM/CEFET-RN/Mossoró)

description

TCC apresentado em 22.08.2008 sobre a tecnologia JAVAFX

Transcript of PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE...

Page 1: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DO RIO GRANDE DO NORTEGERÊNCIA EDUCACIONAL DE TECNOLOGIA DA INFORMAÇÃO

CURSO SUPERIOR DE TECNOLOGIA EM DESENVOLVIMENTO DE SOFTWARE

PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS

DE SISTEMAS

Eder Carlos de Oliveira Nogueira Serrano

Orientador: Ricardo Alexsandro de Medeiros Valentim, Dr. (DACGEM/CEFET-RN/Mossoró)

Natal (RN), agosto de 2008

Page 2: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DO RIO GRANDE DO NORTEGERÊNCIA EDUCACIONAL DE TECNOLOGIA DA INFORMAÇÃO

CURSO SUPERIOR DE TECNOLOGIA EM DESENVOLVIMENTO DE SOFTWARE

PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS

DE SISTEMAS

Eder Carlos de Oliveira Nogueira Serrano

Orientador: Ricardo Alexsandro de Medeiros Valentim, Dr. (DACGEM/CEFET-RN/Mossoró)

Natal (RN), agosto de 2008

Monografia apresentada à Banca Examinadora do Trabalho de Conclusão do Curso de Tecnologia em Desenvolvimento de Software, em cumprimento às exigências legais como requisito parcial à obtenção do título de Tecnólogo em Desenvolvimento de Software.

Page 3: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

SUMÁRIO

LISTA DE ABREVIATURAS 4

LISTA DE FIGURAS 5

LISTA DE TABELAS 6

LISTA DE QUADROS 7

RESUMO 8

ABSTRACT 9

1. INTRODUÇÃO 10

1.1. OBJETIVOS GERAIS 121.2. OBJETIVOS ESPECÍFICOS 121.3. METODOLOGIA 131.4. ESTRUTURA DO TRABALHO 13

2. FUNDAMENTAÇÃO TEÓRICA 14

2.1 ESTADO DA ARTE

142.1.1 PRINCIPAIS TECNOLOGIAS CONCORRENTES 142.1.2 PROGRAMAÇÃO DECLARATIVA E JAVA 162.2 JAVAFX SCRIPT 182.2.1 TIPOS BÁSICOS, ATRIBUTOS E VARIÁVEIS 182.2.2 ARRAYS, STRINGS, IDENTIFICADORES, SEQÜÊNCIAS NUMÉRICAS

E FORMATAÇÃO

202.2.3 ENTENDENDO A ESTRUTURA DE UMA CLASSE: FUNÇÕES, OPERAÇÕES,

EXPRESSÕES E DECLARAÇÃO DE OBJETOS 242.2.4 DECLARAÇÃO DE OBJETOS, OPERADOR BIND E REFLEXÃO

292.2.5 PRINCIPAIS CLASSES DA API JAVAFX 312.2.6 AMBIENTE DE DESENVOLVIMENTO JAVAFX 32

3. FUNDAMENTAÇÃO TEÓRICA 34

3.1 CASO DE USO 363.2 VALIDAÇÃO DAS TECNOLOGIAS 363.2.1 JAVA SWING: PROJETO AGENDASWING 363.2.2 JAVAFX: PROJETO AGENDAFX 393.2.3 COMPARATIVO AGENDASWING VS. AGENDAFX 41

4. CONSIDERAÇÕES FINAIS 43

4.1 CONCLUSÃO 434.2 SUGESTÕES E RECOMENDAÇÕES 43

Page 4: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

REFERÊNCIAS BIBLIOGRÁFICAS 44

LISTA DE ABREVIATURAS

TCC Trabalho de Conclusão de CursoCEFET-RN Centro Federal de Educação Tecnológica do Rio Grande do NorteHTMLRIAsJVMMVCXMLJDBC

HyperText Markup LanguageRich Internet ApplicationsJava Virtual MachineModel-View-ControllerExtensible Markup LanguageJava DataBase Connectivity

Page 5: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

LISTA DE FIGURAS

Figura 01. RIA combina o melhor do Desktop, Web e Comunicações.

Fonte: www.thefocusnetwork.com...................................................................................................................10

Figura 02. Principais Tecnologias RIA.

Fonte: www.ibm.com......................................................................................................................................11

Figura 03. Visão Geral da área de atuação da família JavaFX.

Fonte: www.sun.com......................................................................................................................................12

Figura 04. Comparação entre Java Swing e JavaFX Script.

Fonte: www.sun.com.......................................................................................................................................17

Figura 05. Estrutura de pacotes da API JavaFX..............................................................................................32

Figura 06. Sistema de Agenda AgendaFX......................................................................................................34

Figura 07. Sistema de Agenda AgendaSwing ................................................................................................35

Figura 08. Diagrama de Casos de Uso do Sistema.........................................................................................36

Figura 09. Classe Conexao.java......................................................................................................................37

Figura 10. Funcionalidades Incluir Contato e Remover Contato.....................................................................38

Figura 11. Funcionalidades Listar Contato, Editar Contato e Buscar Contato................................................38

Figura 12. Classe Conexao em AgendaFX.....................................................................................................39

Figura 13. Exemplo de um Frame na classe SearchFrame............................................................................40

Figura 14. Inclusão e Remoção de Contato no AgendaFX.............................................................................41

Page 6: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

LISTA DE TABELAS

Tabela 01. Tipos Primitivos de Dados em JavaFX..........................................................................................18

Tabela 02. Operadores de Cardinalidade em JavaFX....................................................................................20

Tabela 03. Todos os operadores da linguagem JavaFX.................................................................................24

Tabela 04. Todas as expressões da linguagem JavaFX.................................................................................26

Tabela 05. Comparativo AgendaSwing x AgendaFX......................................................................................41

Page 7: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

LISTA DE QUADROS

Quadro 01. Exemplo de uma classe JavaFX e seus valores de saída...........................................................19

Quadro 02. Formas de declaração de variáveis..............................................................................................20

Quadro 03. Formas de declaração de Arrays..................................................................................................20

Quadro 04. Uso de expressões e predicados em Array JavaFX.....................................................................21

Quadro 05. Adicionar elemento no array.........................................................................................................21

Quadro 06. Remover elemento do array.........................................................................................................22

Quadro 07. Compreensão de Lista em JavaFX..............................................................................................22

Quadro 08. Representação de Strings............................................................................................................22

Quadro 09. Uso de Identificadores..................................................................................................................23

Quadro 10. Séries Numéricas em JavaFX......................................................................................................23

Quadro 11. Formatação de Dados em JavaFX...............................................................................................23

Quadro 12. Exemplo de uma função JavaFX..................................................................................................25

Quadro 13. Exemplo de uma classe JavaFX completa...................................................................................27

Quadro 14. Exemplo de Assert Triggers..........................................................................................................28

Quadro 15. Exemplo de Creation Triggers......................................................................................................28

Quadro 16. Exemplo de Replace Triggers......................................................................................................28

Quadro 17. Exemplo 1 de Declaração de Objetos..........................................................................................29

Quadro 18. Exemplo 2 de Declaração de Objetos..........................................................................................29

Quadro 19. Lazy Evaluation e operador bind..................................................................................................30

Quadro 20. Exemplo de Reflexão em JavaFX.................................................................................................31

Page 8: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

RESUMO

Serrano, Eder Carlos Nogueira. Programação Declarativa com JAVAFX: Um

Paradigma na Construção de Interfaces Gráficas de Sistemas. Natal, 2008. f.

Trabalho de Conclusão de Curso (Tecnologia em Desenvolvimento de Software) –

Gerência Educacional de Tecnologia da Informação, Centro Federal de Educação

Tecnológica do Rio Grande do Norte, Natal-RN, 2008.

O aumento na demanda por interfaces cada vez mais interativas com o cliente, seja em

browsers quanto em dispositivos móveis acentua cada vez mais a criação de tecnologias

voltadas a aplicações RIAs – Rich Internet Applications (Aplicações Ricas da Internet). A

plataforma Java oferecia até então seu pacote de desenvolvimento de interfaces gráficas

java.swing que, na maioria das vezes, ocupava o desenvolvedor com sua complexidade e

pouca produtividade.Esse trabalho tem como objetivo apresentar outra solução, mais

prática, produtiva e rica, a JavaFX. A JavaFX Script, linguagem baseada em programação

declarativa, e a interação com a plataforma Java também serão temas abordados. Além

disso, é objetivo deste trabalho a construção de uma aplicação que mostrará todos os

recursos oferecidos pela tecnologia.

Palavras-chave: RIAs, Programação Declarativa, Interfaces Gráficas, JavaFX.

Page 9: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

ABSTRACT

The increase in the demand for interfaces each time more interactive with the customer,

either in browsers how much in devices mobile it accents each time more the creation of

directed technologies the applications RIAs - Rich Internet Applications. The Java platform

offered until then its package of development of graphical interfaces java.swing that, in the

majority of the times, it occupied the developer with its complexity and little productivity.

This work has as objective to present one another solution, more practical, productive and

rich, the JavaFX. The JavaFX Script, language based on declarative programming, and

the interaction with the Java platform will be boarded subjects. Moreover, the construction

of an application is objective of this work that will show to all the resources offered for the

technology.

Keywords: RIAs, Declarative Programming, Graphical Interfaces, JavaFX

Page 10: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

1. INTRODUÇÃO

Desde a chegada dos anos 2000, a busca por interfaces gráficas cada vez mais

ricas e interativas com seus respectivos usuários tem levado ao surgimento de novas

tecnologias. Os softwares desktop cada vez mais migram seus front-ends para a

Internet e as aplicações existentes na web deixam de ser apenas documentos

estáticos HTML para proverem conteúdo dinâmico, interativo e mais próximo dos

recursos encontrados no mundo desktop. A chegada da Web 2.0, oferecendo

conteúdo colaborativo e compartilhado entre pessoas, além da nova gama de

dispositivos móveis capazes de rodar aplicações gráficas influenciam esta tendência.

A plataforma Java desde a sua criação, sempre foi muito relacionada a

aplicativos gráficos, começando desde os simples applets até chegar hoje, onde provê

suporte para desde o desenvolvimento de sistemas distribuídos, dispositivos móveis,

interfaces gráficas, web, entre muitos outros paradigmas e ambientes. Hoje, mais de

90% de todos os pc’s do mundo rodam alguma aplicação sob plataforma Java

(Omniture, 2007), sendo 77% destes a plataforma Java da SUN (Map24.com, 2006).

O surgimento de novas tecnologias no mercado de RIAs (Rich Internet

Applications, ou aplicações ricas para a Internet), acentuou o surgimento de várias

tecnologias (serão abordadas neste trabalho) e apesar da influência de sua

plataforma, Java perdeu espaço no concorrido mercado das “ricas” interfaces gráficas.

Tecnologias concorrentes como AJAX, SilverLight e principalmente as soluções Adobe

como Flash e Flex são as mais largamente utilizadas no cenário atual, ilustrado nas

Figuras 1 e 2 logo abaixo:

Figura 1. RIA combina o melhor do Desktop, Web e Comunicações.

Page 11: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

Figura 2: Principais Tecnologias RIA

Os motivos que levaram a perda de espaço da plataforma Java neste

panorama:

Os desenvolvedores tinham pouca produtividade com as bibliotecas

disponíveis – Applets, Swing, 2D, etc. -, já que possuem estruturas

complexas e com sintaxes poucas enxutas;

A plataforma Java é mais lenta devida a JVM;

Falta de boas ferramentas de desenvolvimento;

Foi focada inicialmente nos programadores e deixou de lado designers e

desenhistas.

Neste intuito, no ano de 2007 foi lançada a JAVAFX, uma família de tecnologias

da Sun baseada em Java para criação de interfaces ricas para diversas plataformas

de desenvolvimento – desde celulares e TVs, até aplicações desktop (ver Figura 3).

Além de atacar o mercado das ricas interfaces gráficas, outras motivações

influenciaram a Sun a lançar esta tecnologia: Segue abaixo:

Tendências de Mercado:

o Redes IP de alta velocidade;

o Dispositivos móveis mais avançados;

o Redução dos custos de desenvolvimento;

o Absorção de Idéias como middleware, web semântica, personalização

de aplicações, etc.;

o Alternativa Open-Source no mercado proprietário

JavaFX Script:

Page 12: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

o Linguagem que veio pra facilitar o desenvolvimento de GUI Java,

tornando mais produtivas suas bibliotecas Swing e Java 2D, além de

mais acessíveis a programadores de script;

Figura 3. Visão Geral da área de atuação da família JavaFX

1.1. Objetivos Gerais

O objetivo geral deste trabalho é apresentar o paradigma de programação

declarativa na construção de interfaces gráficas, usando a tecnologia JavaFX e sua

linguagem de script JavaFX Script. A sua sintaxe declarativa, com estrutura mais

simples e didática em relação a Java Swing é um de seus atrativos para o

desenvolvimento de aplicações RIAs. Cabe lembrar que JavaFX Script roda sobre JRE

e facilmente se agrega a classes Java.

É objetivo deste trabalho também desenvolver uma aplicação que aborde os

recursos oferecidos pela tecnologia no âmbito de interfaces gráficas.

1.2. Objetivos Específicos

Os objetivos específicos deste projeto de pesquisa são:

Pesquisar e fazer uma análise geral sobre as várias tecnologias disponíveis

na esfera da construção de interfaces gráficas;

Abordar em detalhes a tecnologia JavaFX e sua linguagem JavaFX Script;

Modelar uma aplicação gráfica baseada na tecnologia JavaFX;

Desenvolver uma aplicação gráfica baseada na tecnologia JavaFX;

Realizar testes.

Page 13: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

1.3. Metodologia

A metodologia adotada neste trabalho se decompõe em duas partes: a teórica e

a experimental. A primeira consiste numa abordagem detalhada sobre o tema de

estudo deste documento, a fim de que se possa adquirir conhecimento necessário

para a segunda parte. Esta consiste na modelagem e desenvolvimento de uma

aplicação baseada no tema estudado.

1.4. Organização do Trabalho

Este trabalho ainda se divide em mais três capítulos:

O capítulo 2 é formado por toda a fundamentação teórica do tema. São

apresentadas tecnologias de relação direta com o tema, suas vantagens e

desvantagens. Em seguida são apresentados conceitos básicos de programação

declarativa e, finalmente, a sintaxe da linguagem JavaFX Script.

O capítulo 3 apresenta uma aplicação baseada em JavaFX Script, com a

descrição de suas funcionalidades e o código da aplicação. Também será feito uma

análise sobre os ganhos reais com a adoção da tecnologia.

O capítulo 4 apresenta as conclusões do trabalho.

Page 14: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

2. FUNDAMENTAÇÃO TEÓRICA

Neste capítulo, são tratadas todas as pesquisas e estudos feitos para a

elaboração deste trabalho e visa adquirir conhecimento sólido para entendimento do

objeto de estudo da matéria tratada aqui. A seguir, as quatro subdivisões do capítulo:

2.1. Estado da Arte: este tópico trata a respeito das tecnologias e pesquisas

com relação direta ao tema abordado, além das respectivas vantagens e

desvantagens;

2.2. Programação Declarativa e Java: este tópico abordará uma comparação

entre paradigma declarativo e a tecnologia Java: suas semelhanças e diferenças, além

das vantagens e desvantagens de cada uma;

2.3. JavaFX: este tópico abordará esta novíssima família de tecnologias Java,

focando-se na sua linguagem de script, JavaFX Script. Sua sintaxe, suas principais

características, principais potencialidades, assim como seu ambiente e suas principais

ferramentas de desenvolvimento.

2.1O ESTADO DA ARTE

2.1.1 Principais Tecnologias Concorrentes

Faz um tempo que a interação entre o usuário e uma página web deixou de ser

algo monótono e passou a ser uma “experiência” mais interativa e dinâmica para o

usuário. Na vontade de proporcionar mais funcionalidades ao usuário, o termo RIA’s

amadureceu. Afinal, o que pode ser uma interface rica?

“Duas características chaves: são “ricas” e são

“clientes”. “Rica” refere-se ao modelo de

interação do cliente. Um modelo de interação

rica com o usuário é aquele que suporte uma

variedade de métodos de entrada e que

responda intuitivamente e de forma oportuna. (...)

É um “cliente”, pois se trata de um programa que

se comunica com um processo exclusivo e

independente, tipicamente rodando no servidor.

Os clientes permitem os usuários finais verem e

modificarem informações, e se muitos são os

clientes conectados ao servidor, este permite

Page 15: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

então compartilhar os dados requisitados.

”(Grane, Passarelo e James, 2005)

As primeiras soluções criadas neste sentido foram feitas por programadores

que usavam JavaScript. Esta linguagem de script permite a realização de tratamento

de eventos e ações em um código HTML, mas se tornou sozinha inconsistente e de

difícil manutenção já que não se adequava a qualquer navegador web.

Então, uma solução mais robusta surgiu da evolução do JavaScript: o AJAX. O

Asynchronous Javascript And XML é composto por um conjunto de soluções (XHTML,

CSS, DOM, XML, XSLT, HttpXMLRequest) e o já conhecido JavaScript. No modelo

tradicional da web, a maioria dos usuários dispara uma chamada (ou solicitação) ao

servidor web, que processa a solicitação, seja recuperando dados, realizando cálculos,

conversando com outros sistemas e respondendo em forma de página HTML para o

cliente. É a otimização deste processo que se encontra a maior vantagem do AJAX: a

aplicação não precisa mais requisitar sempre ao servidor, já que esta roda no próprio

navegador web. O ambiente se tornou favorável já que a incompatibilidade entre

navegadores diminuiu sensivelmente desde o início do milênio com o lançamento de

navegadores mais modernos como Mozilla Firefox, Internet Explorer 5+, Opera,

Konqueror, Safari, entre outros. Outra vantagem é que possui bibliotecas compatíveis

como linguagens como Java (Ajax4JSF) e PHP (Prototype, entre outros). Mas é neste

ponto que vem perdendo espaço: por depender tanto de suas bibliotecas, força o

usuário a conhecê-las bem se quiser codificar à sua maneira.

Outra solução que surgiu foi o Lazlo (hoje já migrou para o open-source e se

chama OpenLazlo). Segundo Klein, Carlson e MacEwen (2006), Lazlo surgiu da

necessidade de se criar uma ferramenta para manipular arquivos Flash, da empresa

Adobe. Resolveu-se então construir um framework que tratasse um Flash Player como

uma máquina virtual e a criação de um compilador específico para seus arquivos. Daí

surgiu à linguagem LZX, e em 2002 o primeiro release deste framework. No ano de

2007, sua comunidade de desenvolvedores divulgou uma nova funcionalidade: seu

arquivo .lzx pode a partir de então ser compilado para Flash, DHTML/Ajax ou até

mesmo Java/J2ME. Mesmo assim, OpenLazlo ainda passa por uma fase de

maturação e ainda está galgando espaço no mercado.

Uma solução criada pela Microsoft é a Silverlight. Anteriormente chamada de

WPF/E, este recurso tem características semelhantes ao Adobe Flex, já que

disponibiliza plugin instalado diretamente do browser. Possibilita funcionalidades

como: Uso de XML próprio para construção de interfaces (XAML), interação com

Page 16: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

WebServices, Tratamento de Mídia, 2D, Animação, entre outros (McDonald,2007).

Mas é voltada a plataforma .NET , ambiente de desenvolvimento proprietário, forçando

o desenvolvedor a se adaptar a esta tecnologia.

Hoje a solução mais adotada é a Adobe Flex. A presença do Flash Player

chega a 98% dos computadores de todo o mundo e esta é a primeira grande

vantagem desta solução. Outra grande vantagem é que sempre seu player foi

disponibilizado com fácil acesso na rede e são adaptáveis aos melhores navegadores

do mercado, facilitando seu download. Sua preferência se torna explícita em sites de

muito acesso como Youtube.com e MySpace.com onde arquivos flash são

disponibilizados e propagados na rede.

Até poucos anos atrás, o seu desenvolvimento se limitava ao uso da ferramenta

Macromedia Flash, onde arquivos podiam ser construídos e compilados. Mas esta

solução evoluiu passando pelo uso de MXML (baseada em XML) até a criação da

ActionScript (hoje se encontra na versão 3), linguagem da plataforma FLEX. Aí que

está o grande problema desta tecnologia: suas linguagens são pouco conhecidas e

ainda é uma solução proprietária, apesar de que em um futuro próximo seu código-

fonte também será disponibilizado (Fain,Rasputnis e Tartakovsky,2007).

2.1.2 Programação Declarativa e Java

O paradigma orientado a objetos surgiu no meado dos anos 60 na Noruega, no

Centro Norueguês de Computação, através dos estudos de Kristen Nygaard e Ole-

Johan Dahl (1967). Eles criaram a linguagem SIMULA 67, ou Simula, a primeira

linguagem que trabalhou com o conceito de classe e herança. Mais o paradigma só

veio ganhar força com o lançamento de linguagens como Smalltalk, na década de 80 e

Java, na década de 90.

Diferente do paradigma declarativo, a Orientação a Objetos trabalha com os

conceitos de classe, objeto e herança, dentre muitos outros (não é propósito deste

trabalho se aprofundar nestes conceitos) e suas várias linguagens hoje oferecem

soluções em quase todas as áreas da computação. Mas sua solução para interfaces

não conquistou mercado e público esperado até hoje.

A JavaFX Script foi lançada muito recentemente, numa conferência da Sun, a

JavaOne 2007, realizada em maio deste mesmo ano. Na verdade, JavaFX Script faz

parte de uma família de tecnologias chamada JavaFX, na qual faz parte também a

JavaFX Mobile, um sistema operacional feito para dispositivos móveis onde programas

desenvolvidos em JavaFX Script podem ser executados. Esta plataforma de

Page 17: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

desenvolvimento foi criada para uma necessidade crescente de conteúdo rico para

aplicações em desktop, dispositivos móveis, TV e outras plataformas consumidoras. A

linguagem JavaFX (será chamada assim a partir de agora no texto), é, portanto uma

das ferramentas usadas para criar este conteúdo.

Idealizada e criada por Chris Oliver, atualmente engenheiro da Sun

MicroSystems, esta linguagem era chamada de F3 (“Form Follows Function”, ou “a

função segue a forma”) e segundo o próprio criador, “é atualmente uma linguagem de

scripting declarativa Java estaticamente tipada”; ou seja, é uma linguagem orientada a

objetos, já que trabalha com métodos (operações e funções em JavaFX), que suporta

interação com componentes Java como: 2D,Swing,classes e objetos, bem como

animação, além de sintaxe declarativa.

Por interagir com objetos Java, seu código roda na JVM, tem suporte a padrão

MVC de desenvolvimento e possui um rico conjunto de classes específicas para

construção de interfaces, todas baseadas na sintaxe declarativa.

Outro aspecto interessante que será abordado nas próximas seções será o uso

de triggers, substituo direto dos “getters” e “setters” do código Java.

Adotando a linguagem Java para efeito de comparação vemos na figura 04,

logo abaixo, uma comparação entre as soluções orientada a objetos e JavaFX:

Figura 04. Comparação entre Java Swing e JavaFX Script.

Page 18: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

Percebe-se o quanto o uso de sintaxe declarativa “enxuga o código”: esta

propicia um código coeso e fácil de entender, além de um potencial aumento na

produtividade.Cabe lembrar que JavaFX Script é uma linguagem orientada a objetos,

mas com vários aspectos da sintaxe declarativa, ou seja, congrega o tem de melhor no

mundo OO e declarativo.No capítulo 3, um estudo de caso será apresentado e

mostrará com maior atenção a comparação entre Java Swing e JavaFX.

Na próxima seção, JavaFX Script, o principal objeto de estudo deste trabalho,

será apresentada em maiores detalhes.

2.2 . JAVAFX SCRIPT

Esta seção tem como apresentar, de forma minuciosa, todos os aspectos

relevantes quanto à sintaxe e as tecnologias envolvidas com JavaFX. É dividida da

seguinte forma:

Seção 2.3.1: Tipos Básicos, Atributos e Variáveis;

Seção 2.3.2: Arrays, Strings, Identificadores, Seqüências Numéricas e

Formatação

Seção 2.3.3: Entendendo a estrutura de uma classe: Funções, Operações;

Seção 2.3.4: Declaração de Objetos, Operador Bind e Reflexão;

Seção 2.3.5: Principais Classes da API JavaFX.

Seção 2.3.6: Ambiente de Desenvolvimento JavaFX

2.2.1 Tipos Básicos, Atributos e Variáveis

Em JavaFX, existem quatro tipos básicos de dados, apresentados na Tabela 1

a seguir:

Tabela 01. Tipos Primitivos de Dados em JavaFX

Tipo de Dado Exemplo LiteralValor “Default” do

AtributoCorrespondente Java

String “Eu sou uma String” String vazia String

Boolean true/false False Boolean

Integer 30 0 byte,short,int,long,BigInteger

Number 3.14159 0 Number

Page 19: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

Já um atributo em JavaFX nada mais é que um tipo “explícito”: ou seja, quando

declaramos um atributo, escreve-se o termo “attribute” e declara-se seu tipo

primitivo.Veja o código apresentado no Quadro 01, logo abaixo:

Quadro 01. Exemplo de uma classe JavaFX e seus valores de saída

No exemplo acima, a construção de uma classe JavaFX; quando seus atributos

são declarados, cabe lembrar que estes são inicializados com os valores default do

tipo primitivo à qual foi relacionado. Os atributos tipo “class” possuem valor “null” como

default e os tipos string é tem acesso a todos os métodos da classe java.lang.String.

Outra figura bastante comum aparece no exemplo mostrado: as variáveis. São

representadas junto com o termo “var”, mas, diferentemente dos atributos, não

possuem valores default e não requer que seu tipo de dado seja apresentado

explicitamente. Observe o seguinte trecho de código abaixo:

package jfx_book;

class AttributeDefaultValuesExample {

attribute stri:String;

attribute bool:Boolean;

attribute inte:Integer;

attribute numb:Number;

}

// Make an instance of the class and print each attribute's default value

var example = AttributeDefaultValuesExample{};

println("Default values for attributes having primitive data types:");

println("The String attribute has a default value of '{example.stri}'

and example.stri.length() is:{example.stri.length()}");

println("The Boolean attribute has a default value of {example.bool}");

println("The Integer attribute has a default value of {example.inte}");

println("The Number attribute has a default value of {example.numb}");

------------------------------------------------------------------------------------------------------------------------------------------

Os valores de saída são mostrados abaixo:

------------------------------------------------------------------------------------------------------------------------------------------

Default values for attributes having primitive data types:

The String attribute has a default value of ''

and example.stri.length() is:0

The Boolean attribute has a default value of false

The Integer attribute has a default value of 0

The Number attribute has a default value of 0

Page 20: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

var example = AttributeDefaultValuesExample{};

var afirmacao = true;

var numeroafirmacao:Integer = (Math.Pi).intValue();

Quadro 02. Formas de declaração de variáveis

A variável example e afirmacao têm seus tipos representados implicitamente,

por tipo class e boolean, respectivamente. Já a tipagem de numeroafirmacao é feita

explicitamente para o tipo integer.

As variáveis também suportam cardinalidade, outra característica absorvida de

linguagens declarativas. Seus operadores são mostrados na Tabela 02, a seguir:

Tabela 02. Operadores de Cardinalidade em JavaFX

Operador/ExpressãoSignificado

? Opcional (null)

+ Um ou mais

* Zero ou mais

var

numeros:Number*=[1,2,3];

Declaração de uma nova variável chamada

“numeros” que tem como valor zero ou mais

valores do tipo Number

2.2.2 Arrays, Strings, Identificadores, Seqüências Numéricas e Formatação

Os Arrays são outra figura bastante representada em JavaFX. É a principal

estrutura de dado usada em JavaFX e, semelhante a muitas outras linguagens, eles

representam uma seqüência de dados (no caso de JavaFX, objetos). Abaixo, no

Quadro 03, seu formato de representação:

var numeros = [ “um”,”dois”,”três”,”quatro”,”cinco”];

var numerosnaturais = [“zero”, numeros, “seis”, “sete”, “...”];

numeros == numerosnaturais; //retorna false

var n = sizeof números; // n = 5

numerosnaturais [0] == “zero” // retorna true

Quadro 03. Formas de declaração de arrays

Page 21: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

Outras características inerentes de Arrays: seus elementos devem ser todos do

mesmo tipo e indexados e toda expressão dentro dos colchetes “[]” representa uma

expressão booleana ou um predicado utilizado para acessar ou selecionar elementos

do array. No Quadro 04, a seguir, são mostrados exemplos destas expressões:

var nums = [1,2,3,4];

var numsGreaterThanTwo = nums[. > 2]; // yields [3, 4]

umsGreaterThanTwo = nums[n|n > 2];// yelds [3,4]

function car(list) {return list[indexof . == 0];}// yelds list[0];

function cdr(list) {return list[indexof . > 0];}

Quadro 04. Uso de expressões e predicados em Array JavaFX

Os arrays em JavaFX possuem uma sintaxe específica para acessá-los e

modificá-los como ações de adicionar elemento, remover elemento e listar elementos

com o uso das “list comprehension” (compreensão de lista).

Uma inserção, por padrão, é feita depois do ultimo elemento. O termo as first e

as last indicam inserção explícita antes do primeiro elemento e depois do último,

respectivamente. Já as expressões insert …after e insert …before indicam inserção do

elemento antes e depois, respectivamente, em relação ao elemento referenciado. O

Quadro 05 abaixo contém exemplos de inserção de elementos.

insert Expressao1 [as first | as last ] into Expressao2

insert Expressao1 before Expressao2

insert Expressao1 after Expressao2

var x = [1,2,3];

insert 12 into x; // yields [1,2,3,12]

insert 10 as first into x; // yields [10,1,2,3,12]

insert [99,100] as last into x; // yields [10,1,2,3,12,99,100]

var x = [1,2,3];

insert 10 after x[. == 10]; // yields [1,2,3,10]

insert 12 before x[1]; // yields [1,12,2,3,10]

insert 13 after x[. == 2]; // yields [1, 12, 2, 13, 3, 10];

Quadro 05. Adicionar elemento no array

Já a remoção de elementos é expressa de quatro formas básicas, vistas no

Quadro 06: as duas primeiras referem-se à remoção de todos os elementos da

variável ou atributo, enquanto as outras duas referem-se a alguns dos elementos do

Array que satisfazem a expressão booleana (predicado).

Page 22: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

delete variable

delete Expression.attribute

delete variable[predicate]

delete Expression.attribute[predicate]

Quadro 06. Remover elemento do array

A List comprehension (Compreensão de Lista) é uma característica peculiar

presente na sintaxe JavaFX. Presente em linguagens declarativas e funcionais como

Haskell e Miranda (Oliver, 2007), este formato de listar elementos não está presente

em Java. Consiste de uma ou mais listas de entrada, um filtro opcional e um gerador

de expressão (Sun.com, 2007), ou melhor, um construtor de processamento de listas

em linguagem de programação e seu resultado é outra lista com elementos que

satisfazem a condição proposta;

Em JavaFX, usamos as notações select e foreach, para representar uma

compreensão. No Quadro 07 abaixo, alguns exemplos:

select n*n from n in [1..100]

foreach (n in [0..] where n*n > 3)indexof n;

titleTracks = foreach (album in albums,track in album.tracks

where track == album.title)indexof track + 1;

Quadro 07. Compreensão de Lista em JavaFX

As Strings podem ser representadas sob aspas simples ou duplas, podem ser

concatenadas, usadas em expressão booleanas e possuir várias linhas. Um exemplo a

seguir, no Quadro 08:

var e = ‘a’;

var f = “b”;

var g = “c {e}” // g = ‘ca’

var verdade = true;

var everdade = “A verdade é (if verdade then “verdadeira” else

“falsa”)”; // everdade = ‘A verdade é verdadeira’

var variaslinhas = “linha1

linha2”;

Quadro 08. Representação de Strings

Page 23: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

Outra peculiaridade em JavaFX é o uso de identificadores. Representado pelo

símbolo <<>>>> (ver Quadro 09), permite o acesso a outras classes, variáveis,

funções, nomes de atributos e até mesmo métodos Java (Sun.com, 2007).

var <<for>> = 100;

if (resp == <<javax.swing.JOptionPane>>.OK_OPTION) {

wgModel.unplaceWord(wgModel.selectedPlacedWord);

}

Quadro 09. Uso de Identificadores

Semelhante ao XPath , em JavaFX, séries numéricas podem ser representadas

da seguinte forma: [numero1...numero2]. Exemplos no Quadro 10, a seguir:

Var nums = [1..5];

System.out.println(nums == [1,2,3,4,5]); //imprime true

function fac(n) {return product([1..n]);}

var result = sum([1,3..100]);

Quadro 10. Séries Numéricas em JavaFX

A formatação, seja de strings, números ou tipos data, possuem em JavaFX um

operador específico (format as) . O operador format as suporta as seguintes classes

Java para tipo de formatação: java.text.DecimalFormat, java.text.SimpleDateFormat,

and java.util.Formatter; e quando o símbolo % é usado, a classe java.util.Formatter é

chamada (Oliver, 2007). Exemplos no Quadro 11, a seguir:

import java.util.Date;

// yields '100.896000'

100.896 format as <<%f>>;

// yields '1F'

31.intValue() format as <<%02X>>;

var d = new Date();

// yields '2005-10-31T08:04:31.323-0800'

d format as <<yyyy-MM-dd'T'HH:mm:ss.SSSZ>>;

>>; // yields '12.3E-4'

0.00123 format as <<00.###E0

Quadro 11. Formatação de Dados em JavaFX

2.2.3 Entendendo a estrutura de uma classe: Funções, Operações, Expressões e Declaração de Objetos

Page 24: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

Antes de adentrar no entendimento da estrutura de uma classe, é importante

visualizar todos os operadores suportados da linguagem. A relação completa , na

Tabela 03, a seguir:

Tabela 03. Todos os operadores da linguagem JavaFX

Operador Descrição

== Igualdade

<> Diferença

< Menor que

> Maior que

<= Menor ou igual

>= Maior ou igual

and “and(e)” lógico

or “or(ou)” lógico

not Negação lógica

+ Adição

- Subtração

* Multiplicação

/ Divisão

% Resto de divisão

+= Adiciona e seta variável

-= Subtrai e seta variável

*= Multiplica e seta variável

/= Divide e seta variável

%= Calcula o resto da divisão e seta variável

sizeof Tamanho do array

indexof Posição em um array

if a then b else c Expressão condicional

select Compreensão de lista

foreach Compreensão de lista

new Criação de uma instância de classe

op() Função/chamada de operação

a.op() Membro da função/chamada de operação

instanceof Checagem de tipo

this Auto-referência

. Acesso a atributo ou a contexto

bind [lazy] Atualização incremental da variável na

Page 25: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

esquerda com valor da expressão à direita. A opção “lazy” adia a atualização até que a variável à esquerda esteja alcançada.

: Inicialização explícita (eager)

[ ] Seleção de array

format as Formatação de String

<<>> Identificador/Chamada de Métodos Java

{} Expressão String

(expr) Expressão de agrupamento

reverse reverte uma lista

[number1,next...number2] sequência numérica

Em JavaFX, são duas abordagens feitas para funções e operações. As funções

são um subconjunto funcional puro da linguagem, podendo conter no seu corpo

somente uma série de declarações de variáveis e uma indicação de retorno. Segue

um exemplo logo abaixo, no Quadro 12:

function z(a,b) {

var x = a + b;

var y = a - b;

return sq(x) / sq (y);

}

function sq(n) {return n * n;}

function main() { return z(5, 10);}

Quadro 12. Exemplo de uma função JavaFX

Já as operações, representada pelo termo operation, podem conter

expressões como if, while ,try, for, return, throw, break, continue, do e do later (estas

expressões seguem o mesmo formato de Java). Eis, abaixo, a Tabela 04, com todas

as expressões e suas respectivas descrições:

Tabela 04. Todas as expressões da linguagem JavaFX

Expressão Descrição

Page 26: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

return Finaliza uma operação corrente ou uma

“trigger” ou retornando um valor.

if/else Executa a expressão contida no corpo do if se verdadeira.Se existir else, seu corpo será executado quando a cláusula if for falsa.

for Interage com uma seqüência , executando o conteúdo do corpo a cada loop.

while Executa o conteúdo do corpo por loop enquanto a condição for verdadeira.

break Sai de um loop de um while, levando para a próxima linha de execução.

continue Continua executando de um loop for ou while, enquanto a condição do loop for verdadeira.

insert Usado para inserir elementos em uma seqüência.

delete Usado para remover elementos em uma seqüência.

Try/catch/finally Usado para tratamento de exceções, onde o try contém o corpo com as tarefas a serem executadas. Se uma condição de erro ocorrer, a execução do código recai na cláusula catch. A expressão finally é executada não obstante se uma exceção ocorreu.

throw Usada em conjunto no tratamento de exceções, indica que tipo de exceção deve ser lançado caso ocorra erro.

do, do later Usado para processar concorrência.

As operações também têm os parâmetros definidos assim como o tipo de

retorno e tem uma “assinatura” junto à classe. Também, opcionalmente, podem-se

especificar modificadores de acesso para as operações - public, protected e private –

seguindo o mesmo sentido que possuem em Java. O modificador public indica que

seja a classe, operação, função ou atributo, estes podem ser acessados por outra

classe. Já o modificador private indica o acesso somente no escopo da própria classe.

O protected indica que o acesso é permitido dentro do próprio pacote. Quando não

possui o modificador, o acesso é feito por qualquer classe. Veja no Quadro 13, abaixo,

o exemplo de uma classe completa, com todas as estruturas citadas até agora:

Page 27: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

2.2.4 Principais Tecnologias de Desenvolvimento JavaFX

Quadro 13. Exemplo de uma classe JavaFX completa.

Na classe apresentada acima, uma figura nova aparece: a trigger. Semelhante

a trigger do SQL, é uma parte chave da classe em que possibilita o uso do modelo

declarativo e funciona como um método set de uma classe Java, usado para modificar

dados (J.Weaver, 2007). Ela é composta de um cabeçalho e um corpo. O cabeçalho

indica o tipo de evento na qual a trigger aplica-se. O corpo contém um procedimento

que executa enquanto o evento especificado ocorrer.

Em JavaFX, três são os tipos de trigger: assert trigger, creation trigger e replace

trigger. A primeira, usada para testes, é executada de acordo com uma condição

particular (assert) associada a ela. Um exemplo abaixo, no Quadro 14:

package chapter4;

import javafx.ui.*;

class Appointment {

attribute month:Integer;

attribute day:Integer;

attribute year:Integer;

attribute hour:Integer;

attribute pm:Boolean;

attribute durationHours:Number;

operation isConflict(otherAppt:Appointment):Boolean;

private operation getHourIn24HourTime(appt:Appointment):Integer;

private operation isTimeOverlap(hourA:Integer, durationHoursA:Number,

hourB:Integer):Boolean; }

attribute Appointment.month = 1;

MAX_MONTH:Integer = 12;

trigger on Appointment.month[oldMonth] = newMonth {

if (newMonth <= 0 or newMonth > MAX_MONTH:Integer) {

month = oldMonth;} }

trigger on Appointment.day[oldDay] = newDay {//...supply code here...}

trigger on Appointment.hour[oldHour] = newHour {//...supply code here...}

operation Appointment.isConflict(otherAppt) {

var conflict = false;//...supply code here...

return conflict;}

operation Appointment.isTimeOverlap(hourA, durationHoursA, hourB) {

//...supply code here...}

operation Appointment.getHourIn24HourTime(appt) {

var hourIn24hourTime; //...supply code here...

return hourIn24hourTime;}

Page 28: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

assert wordGridModel.placeWord("red") == false;

trigger on assert assertion { //se o assert é verdadeiro

println("Assertion passed!"); }

trigger on not assert assertion { //se o assert é falso

println("Assertion failed!"); }

Quadro 14. Exemplo de Assert Triggers.

Um creation trigger exerce o papel que um construtor java: é executado quando

uma nova instância de sua respectiva classe é criada. Um exemplo abaixo, no Quadro

15:

trigger on new WordGridCell {

cellLetter = SPACE;

// Generate random letter to be used to fill in this cell

// in the case that it doesn't contain a word

fillLetter = Character.forDigit(Math.random() * 26 + 10, 36).

toString().toUpperCase();

wordEntries = []; }

Quadro 15. Exemplo de Creation Triggers

Por último, a replace trigger, é executada quando o atributo nomeado na trigger

for atribuído outro valor. Um exemplo, no Quadro 16, a seguir:

import java.lang.System;

class X {

attribute nums: Number*;

attribute num: Number?; }

trigger on X.nums[oldValue] = newValue {

System.out.println("just replaced {oldValue} with {newValue} at

position {indexof newValue} in X.nums"); }

trigger on X.num[oldValue] = newValue {

System.out.println("X.num: just replaced {oldValue} with {newValue}");

}

var x = X {

nums: [12, 13]

num: 100 };

x.nums[1] = 5;// prints just replaced 13 with 5 at position 1 in X.nums

x.num = 3; // prints X.num: just replaced 100 with 3

x.num = null; // prints X.num: just replaced 3 with null

Quadro 16. Exemplo de Replace Triggers

Page 29: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

2.3.5 Declaração de Objetos, Operador Bind e Reflexão;

Foi exposto anteriormente que uma das formas de se declarar (criar) objetos

JavaFX é através do uso do operador new. Com uma abordagem declarativa, podem-

se declarar objetos da linguagem de outras maneiras. Exemplos, no Quadro 17, a

seguir:

var chris = Person {

name: "Chris"

children:

[Person {

name: "Dee" },

Person {

name: "Candice"

}]

};

Quadro 17. Exemplo 1 de Declaração de Objetos

No exemplo acima, a variável chris tem seu valor associado a uma classe

Person, com os seguintes atributos name e children devidamente inicializados. Já no

próximo exemplo, no Quadro 18, temos a alocação de construtores e objetos Java:

import java.util.Date;

import java.lang.System;

var date1 = new Date(95, 4, 23); // chama o constructor Java

var date2 = Date { // cria uma Data como um objeto Literal

month: 4

date: 23

year: 95

};

System.out.println(date1 == date2); // prints true

Quadro 18. Exemplo 2 de Declaração de Objetos

Também em JavaFX, pode-se utilizar-se dois conceitos de programação

chamados de “Lazy Evaluation” (avaliação preguiçosa) e “Eager Evaluation” (avaliação

ansiosa). Esta característica assegura que os argumentos das funções somente serão

avaliados se necessários. Exemplo, no Quadro 19, a seguir:

Page 30: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

import java.lang.System;

class X {

attribute a: Number;

attribute b: Number;

attribute c: Number;

}

trigger on X.b = newValue {

System.out.println("X.b is now {newValue}");

}

trigger on X.c = newValue {

System.out.println("X.c is now {newValue}");

}

var x1 = X {

a: 1

b: 2 // X.b is now 2 is printed

c: 3 // X.c is now 3 is printed

};

var x2 = X {

a: x1.a // eager, non-incremental

b: bind x1.b // eager, incremental (X.b

is now 2 is printed)

c: bind lazy x1.c // lazy, incremental (nothing is printed yet)

};

System.out.println(x2.a); // prints 1

System.out.println(x2.b); // prints 2

System.out.println(x2.c); // prints X.c is now 3, then prints 3

x1.a = 5;

x1.b = 5; // prints X.b is now 5, twice

x1.c = 5; // prints X.c is now 5, twice

System.out.println(x2.a); // prints 1

System.out.println(x2.b); // prints 5

System.out.println(x2.c); // prints 5

Quadro 19. Lazy Evaluation e operador bind

No exemplo acima, percebe-se a função do operador bind: este assegura que

toda vez que o valor do atributo x1.b for alterado, sua referência em x2.b também será

atualizada. Em atributos de campos value de uma classe JTextField em um Frame,

atributo bind cumpre este papel.Já o atributo bind lazy “atraza” a última atualização de

Page 31: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

x1.c e é muito usado em situações onde se manipula estruturas de dados, como

árvores, por exemplo.

Para finalizar, será abordada uma característica marcante no paradigma OO: a

reflexão. Semelhante a linguagens OO, como Java, tanto classes, como atributos e

membros de função e operação podem ser acessados através de reflexão. Um

exemplo, no Quadro 20, a seguir:

import java.lang.System;

System.out.println(1.class.Name) // imprime "Number"

System.out.println("Hello".class.Name); // imprime "String"

class X {

attribute a: Number;

}

var x = new X();

System.out.println(x.class.Name); // imprime "X"

System.out.println(sizeof x.class.Attributes); // imprime 1

System.out.println(x.class.Attributes[0].Name); // imprime "a"

x.a = 2;

System.out.println(x[x.class.Attributes[Name == 'a']]); // imprime 2

// a expressão acima é equivalente a expressão a seguir

System.out.println(x.a);

System.out.println(:System.Name); // imprime "java.lang.System"

System.out.println(:System.class.Name); // imprime "Class"

Quadro 20. Exemplo de Reflexão em JavaFX

2.3.6 Principais Classes da API JAVAFX.

É disponibilizada para JavaFX uma API no seguinte link:

https://openjfx.dev.java.net/nonav/api/index.html. Seguindo a divisão da própria API, é

dividida em três pacotes básicos (ver Figura 05):

javafx.ui: Pacote principal, que fornece classes para componentes da

interface do usuário. Principais classes: Frame, Font, Color, Canvas, Image,

Label.etc;

javafx.ui.canvas: Fornece classes definindo e executando operações em

objetos gráficos. Principais classes: Text, GridLayout, Layout, Area, etc;

Page 32: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

javafx.ui.filter: Fornece classes que fornecem efeitos gráficos e de

transformação. Principais classes: Light, Filter, etc.

Figura 05. Estrutura de pacotes da API JavaFX

2.3.7 Ambiente de Desenvolvimento JavaFX

Apesar da família JavaFX ter sido lançado há pouco mais de um ano, já conta

com o suporte de várias IDE’s. Abaixo todas as tecnologias envolvidas no ambiente de

desenvolvimento:

JDK:

o Tecnologia indispensável, já que contém o kit de desenvolvimento

Java com a JVM (Java Virtual Machine) inclusa;

o Link: http://java.sun.com/javase/downloads/index.jsp.

JavaFXPad:

o É a mais simples e prática das ferramentas de desenvolvimento

JavaFX. Com ela, o desenvolvedor pode usá-la para uso didático,

escrever e executar seus programas escritos.

o É disponibilizado nos seguintes links:

http://download.java.net/general/openjfx/demos/javafxpad.jnlp:

Sua execução está associada ao uso da Java Web Start,

aplicação Java necessária a execução do programa;

Page 33: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

https://openjfx.dev.java.net/servlets/ProjectDocumentList: Link

do projeto OpenJFX, que permite ao desenvolvedor ter acesso

ao código fonte das classes JavaFX e ao repositório do projeto.

Eclipse IDE + JavaFX plugin:

o Conhecida ferramenta de desenvolvimento Java, é uma opção mais

robusta em relação ao JavaFXPad, já que disponibiliza plugin para

JavaFX;

o Links:

Eclipse IDE: http://www.eclipse.org/downloads/;

JavaFX plugin: https://openjfx.dev.java.net/javafx-eclipse-

plugin-install.html;

NetBeans IDE + JavaFX plugin:

o Outra IDE bastante usada no mundo Java, e que desde sua versão

5.5 disponibiliza acesso ao plugin JavaFX.

o Links:

NetBeans IDE 6.1:

http://download.netbeans.org/netbeans/6.1/final/

JavaFX plugin: https://openjfx.dev.java.net/javafx-nb55-plugin-

install.html.

Page 34: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

3. JAVAFX: UM ESTUDO DE CASO PARA VALIDAÇÃO DE SUA PRODUTIVIDADE

Neste capítulo, será apresentado um estudo de caso para validar os principais

benefícios com a adoção de JavaFX na construção de interfaces, focando o principal

deles: a produtividade. Tecnologia escolhida para objeto de comparação com JavaFX

é a Java Swing, conjunto de bibliotecas Java para construção de interfaces em

ambiente Desktop.

Como estudo de caso, foi implementado um sistema de Agenda, composto de

um caso de uso, Cadastrar Contato, com as opções de: Incluir Contato, Editar

Contato, Remover Contato e Buscar Contato. Para objeto de comparação, foram

implementadas duas versões: AgendaFX, usando-se JavaFX, e AgendaSwing,

usando-se Java Swing (Ver Figuras 06 e 07, logo abaixo). O ambiente de

desenvolvimento escolhido foi o Netbeans IDE, versão 6.0.1, com o respectivo plugin

JavaFX e sua base de Dados foi o Postgres 8.x para ambas as versões.

Figura 06: Sistema de Agenda AgendaFX

Page 35: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

Figura 07: Sistema de Agenda AgendaSwing

O restante do capítulo está dividido da seguinte forma:

Seção 3.1: Caso de Uso: descreve os principais requisitos do caso de uso

do sistema de agenda.

Seção 3.2: Validação das Tecnologias: descreve o estudo de caso sob a

implementação específica do projeto usado as tecnologias Java Swing e

JavaFX.

Subseção 3.2.1: descreve a implementação da versão do sistema usando

Java Swing.

Subseção 3.2.2: descreve a implementação da versão do sistema usando

JavaFX.

Subseção 3.2.3: descrevem uma comparação entre ambas as tecnologias a

nível de código.

Page 36: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

3.1.CASO DE USO

No sistema de Agenda proposto, foi desenvolvido um caso de uso como

mostrado na Figura 08 abaixo:

Figura 08: Diagrama de Casos de Uso do Sistema

O sistema oferece a possibilidade de inclusão, edição, busca e remoção de

dados como nome, telefone e email. Possui, ainda, um campo de busca usando como

atributo o campo telefone, além de listar todos os contatos cadastrados por ordem

alfabética.

3.2. VALIDAÇÃO DAS TECNOLOGIAS

3.2.1. JAVA SWING: PROJETO AGENDASWING

O projeto AgendaSwing foi implementado usando o conjunto de bibliotecas

Java Swing e o framework Swing Application Framework (SAF). O SAF, ou JSR-296,

consiste em um conjunto de bibliotecas que facilitam o desenvolvimento de aplicações

desktop Java, disponibilizando trabalhar com conceitos como ciclo de vida de objeto,

melhor integração com o banco de dados, além de trabalhar com anotações.

O projeto final ficou dividido em três pacotes principais: agendaswing.database,

que contém a classe Conexao.java com todas as informações referentes ao acesso a

base de dados, além de métodos de conexão,desconexão e execução de consultas;

agendaswing.model, que possui duas classes: Contato.java e Contatos.java. As duas

classes representam, respectivamente, o contato e o conjunto de contatos

cadastrados; e agendaswing.view, que possui três classes Frame, uma classe de

execução da aplicação e três arquivos XML. As três classes Frame

Page 37: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

(AgendaSwingBuscar.java, AgendaSwingView.java e AgendaSwingEditar.java)

representam as três telas da aplicação: Tela Principal, Editar Contato e Buscar

Contato. A classe AgendaSwingApp.java é uma classe de “launch” da aplicação,

utilizando-se de bibliotecas SAF. Os três arquivos XML são descritores específicos da

interface utilizada na aplicação, outro recurso também disponibilizado pelo framework

utilizado.

Na classe Conexao.java, usou-se a API JDBC para conexão a banco de dados

em Java, como mostrado na Figura 09:

Figura 09: Classe Conexao.java

Para concluir uma visão geral sobre esta versão do sistema, será mostrado o

caso de uso do sistema. As quatro funcionalidades de Cadastrar Contato são eventos

de objetos jButton que chamam os métodos , assim como mostrados nas Figuras 10 e

11, logo abaixo:

Page 38: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

Figura 10: Funcionalidades Incluir Contato e Remover Contato

Figura 11: Funcionalidades Listar Contato, Editar Contato e Buscar Contato

Page 39: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

3.2.2. JAVAFX: PROJETO AGENDAFX

O projeto AgendaFX foi desenvolvido usando a tecnologia JavaFX, escrito com

sua linguagem de script JavaFX Script. Esta versão do sistema ficou dividida em

apenas um pacote, da seguinte maneira: agendafx.Conexao, que contém a classe

Conexao.fx (ver Figura 12) , com todas as mesmas funcionalidades que sua análoga

no projeto AgendaSwing; agendafx.MainFrame, que contém três classes: Contato.fx e

Contatos.fx, que representam as entidades do sistema, e a classe MainFrame.fx, que

representa a tela principal do sistema; agendafx.EditFrame, que possui a classe

EditFrame.fx, que representa a tela Editar Contato; e finalmente,

agendafx.SearchFrame, contendo a classe SearchFrame.fx, que representa a tela

Buscar Contato.

É importante ressaltar que as classes JavaFX são executadas através do

método principal da classe net.java.javafx.FXShell, localizadas no conjunto de

bibliotecas JavaFX.

Figura 12: Classe Conexao em AgendaFX

A classe Conexao, mostrada na Figura 12, acima, se utiliza de bibliotecas Java

nos seus métodos, mostrando o quão prático pode tornar-se seu código, mesmo com

Page 40: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

classes e métodos Java. Classes do pacote java.sql, como ResultSet, Connection,

entre outras, e até classes de exceção são utilizadas.

Um frame em JavaFX é um exemplo de classe que prova quanto a sintaxe

declarativa “enxuga” o código. Um componente Frame, na verdade, é uma instância

no seguinte formato, visto na Figura 13, a seguir:

Figura 13: Exemplo de um Frame na classe SearchFrame

Já as funcionalidades de Cadastrar Contato são facilmente vinculadas ao

código de uma instância Button. Elas ficam contidas no atributo action sob forma de

operação. Em JavaFX, cada componente de um Frame é uma instância de uma classe

Button, TextField, Label , Menu, dentre muitos outros. Como exemplo, segue a figuras

14, abaixo:

Page 41: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

Figura 14: Inclusão e Remoção de Contato no AgendaFX

3.2.3. COMPARATIVO AGENDASWING VS. AGENDAFX

Nesta subseção, avaliaremos os projetos em nível de produtividade. Durante o

desenvolvimento das duas versões, foram adotados dois parâmetros de comparação

entre as tecnologias: tempo estimado de desenvolvimento e quantidade de linhas de

código produzidas. Sendo assim, chegou-se a tais conclusões:

TABELA 05. COMPARATIVO AGENDASWING X AGENDAFX

Quantidade de Linhas:

AgendaFX: aproximadamente 330 linhas

distribuídas em quatro arquivos .fx;

AgendaSwing: aproximadamente 800 linhas

distribuías em sete arquivos .java;

Tempo de Desenvolvimento:AgendaFX: aproximadamente 8 horas seguidas;

AgendaSwing: aproximadamente 10 horas

seguidas (com componente drag-and-drop);

A Tabela 05, acima, verifica-se que a sintaxe declarativa de JavaFX permite

que o código se torne limpo e “enxuto”. Um exemplo claro é a classe Frame em

Page 42: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

JavaFX (ver Figura 13) em comparação com uma classe Frame em Java Swing. Outra

conclusão é que seu tratamento de eventos, por meio de operations de um botão se

torna mais simples e prático (ver Figura 14) do que o tratamento em Swing. (Figuras

10 e 11).

Em relação ao tempo de desenvolvimento, mesmo com ferramentas drag-and-

drop já consolidadas, o tempo gasto com o desenvolvimento Swing ainda não é

satisfatório para as exigências atuais. Em compensação, o tempo de desenvolvimento

com JavaFX tende a diminuir cada vez mais com a maturidade da tecnologia e

disponibilidade de ferramentas mais poderosas.

4. CONSIDERAÇÕES FINAIS

Page 43: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

4.1.CONCLUSÃO

O objeto de estudo deste trabalho permitiu desenvolver um aplicativo gráfico em

ambiente desktop, demonstrando a produtividade da tecnologia em relação a outras

concorrentes.

Ao final do trabalho, o aplicativo desenvolvido demonstrou ainda que seja

desktop, web ou dispositivo móvel, a tecnologia pode ser aliada a sintaxe e bibliotecas

da linguagem Java, esta já consolidada no mercado atual.

4.2. TRABALHOS FUTUROS

Como trabalhos futuros, podem ser realizados testes de produtividade da

tecnologia em ambiente web e em dispositivos móveis, visto que o foco deste trabalho

era avaliar a produtividade da tecnologia.

Outra proposta de trabalho é implementar um aplicativo demonstrando suas

bibliotecas gráficas principais e avaliá-las sob o contexto de interfaces 2D e RIAs.

Page 44: PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS

REFERÊNCIAS BIBLIOGRÁFICAS

Crane, D., Pascarello, E., James, D.,“Ajax in Action”, New York: Manning, 2005

Weaver, J.L., “JavaFX Script, Dynamic Java™ Scripting for Rich Internet/Client-Side Appli-

cations”, New York: Apress,2007.

MacDonald, M., “Silverlight and ASP.NET Revealed”, New York: Apress,2007

Eckestein, R., Loy M.,Wood D., “Java Swing”, São Paulo: O’Reilly,2001

Klein N., Carlson M., MacEwen G., “Lazlo in Action”. New York: Manning,2008

Tretola R. Barberand S., Erickson R., “Professional Adobe Flex 2”, Indianapolis: Wiley.

2007

Cho I. “Java Scripting: Java FX Script and JRuby”, http://www.sun.com, 2007

Laux, T., Haase C., “Desktop Java Technology”, 2007 JavaOneSM Conference, Session

TS-3160.

Oliver, C., “F3: Form Follows Function”, 2007 JavaOneSM Conference, Session TS-3420.

Furtado, A. A. D., “Introdução ao JavaFX”, XXI Semana Paraense de Informática, 2007

JavaFX. Sun MicroSystems. JavaFX. Disponível em: <

http://www.sun.com/software/javafx >. Acesso em: <10 de Abril de 2008>