TCC apresentado em 22.08.2008 sobre a tecnologia JAVAFX

1. 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ó)
Natal (RN), agosto de 2008

2. 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ó)
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.

3. 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 12
1.2. OBJETIVOS ESPECÍFICOS 12
1.3. METODOLOGIA 13
1.4. ESTRUTURA DO TRABALHO 13
2. FUNDAMENTAÇÃO TEÓRICA 14
2.1 ESTADO DA ARTE 14
2.1.1 PRINCIPAIS TECNOLOGIAS CONCORRENTES 14
2.1.2 PROGRAMAÇÃO DECLARATIVA E JAVA 16
2.2 JAVAFX SCRIPT 18
2.2.1 TIPOS BÁSICOS, ATRIBUTOS E VARIÁVEIS 18
2.2.2 ARRAYS, STRINGS, IDENTIFICADORES, SEQÜÊNCIAS NUMÉRICAS
E FORMATAÇÃO 20
2.2.3 ENTENDENDO A ESTRUTURA DE UMA CLASSE: FUNÇÕES, OPERAÇÕES,
EXPRESSÕES E DECLARAÇÃO DE OBJETOS 24
2.2.4 DECLARAÇÃO DE OBJETOS, OPERADOR BIND E REFLEXÃO 29
2.2.5 PRINCIPAIS CLASSES DA API JAVAFX 31
2.2.6 AMBIENTE DE DESENVOLVIMENTO JAVAFX 32
3. FUNDAMENTAÇÃO TEÓRICA 34
3.1 CASO DE USO 36
3.2 VALIDAÇÃO DAS TECNOLOGIAS 36
3.2.1 JAVA SWING: PROJETO AGENDASWING 36
3.2.2 JAVAFX: PROJETO AGENDAFX 39
3.2.3 COMPARATIVO AGENDASWING VS. AGENDAFX 41
4. CONSIDERAÇÕES FINAIS 43
4.1 CONCLUSÃO 43
4.2 SUGESTÕES E RECOMENDAÇÕES 43
REFERÊNCIAS BIBLIOGRÁFICAS 44

4. LISTA DE ABREVIATURAS
TCC Trabalho de Conclusão de Curso
CEFET-RN Centro Federal de Educação Tecnológica do Rio Grande do Norte
HTML
RIAs
JVM
MVC
XML
JDBC
HyperText Markup Language
Rich Internet Applications
Java Virtual Machine
Model-View-Controller
Extensible Markup Language
Java DataBase Connectivity

5. 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

6. 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

7. 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

8. 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.

9. 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

10. 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.

11. 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:

12. 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.

13. 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.

14. 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
então compartilhar os dados requisitados.
”(Grane, Passarelo e James, 2005)

15. 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
WebServices, Tratamento de Mídia, 2D, Animação, entre outros (McDonald,2007).

16. 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
desenvolvimento foi criada para uma necessidade crescente de conteúdo rico para

17. 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.

18. 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 Literal
Valor “Default” do
Atributo
Correspondente 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

19. 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

20. 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ão
Significado
? 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

21. 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

22. variável ou atributo, enquanto as outras duas referem-se a alguns dos elementos do
Array que satisfazem a expressão booleana (predicado).
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

23. 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

24. 2.2.3 Entendendo a estrutura de uma classe: Funções, Operações,
Expressões e Declaração de Objetos
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

25. . Acesso a atributo ou a contexto
bind [lazy] Atualização incremental da variável na
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:

26. Tabela 04. Todas as expressões da linguagem JavaFX
Expressão Descrição
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:

27. 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;}

28. 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

29. 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:

30. 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,

31. atributo bind cumpre este papel.Já o atributo bind lazy “atraza” a última atualização de
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;

32. 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;

33.  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.

34. 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

35. 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.

36. 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

37. (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:

38. Figura 10: Funcionalidades Incluir Contato e Remover Contato
Figura 11: Funcionalidades Listar Contato, Editar Contato e Buscar Contato

39. 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

40. 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:

41. 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);

42. 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
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.

43. 4. CONSIDERAÇÕES FINAIS
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.

44. 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
Applications”, 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>