PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS
Transferir como DOC, PDF0 gostou1,816 visualizações
Este documento apresenta um resumo da monografia "Programação Declarativa com JAVAFX: Um Paradigma na Construção de Interfaces Gráficas de Sistemas" de Eder Carlos de Oliveira Nogueira Serrano. O documento: 1) Apresenta o contexto e motivação para o desenvolvimento da tecnologia JavaFX, incluindo a demanda por interfaces gráficas mais ricas e a perda de espaço da plataforma Java neste mercado. 2) Descreve os objetivos da pesquisa, que incluem apresentar o paradigma
![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](https://image.slidesharecdn.com/tccederdefesa22-140416194342-phpapp02/85/PROGRAMACAO-DECLARATIVA-COM-JAVAFX-UM-PARADIGMA-NA-CONSTRUCAO-DE-INTERFACES-GRAFICAS-DE-SISTEMAS-20-320.jpg)
![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](https://image.slidesharecdn.com/tccederdefesa22-140416194342-phpapp02/85/PROGRAMACAO-DECLARATIVA-COM-JAVAFX-UM-PARADIGMA-NA-CONSTRUCAO-DE-INTERFACES-GRAFICAS-DE-SISTEMAS-21-320.jpg)
![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](https://image.slidesharecdn.com/tccederdefesa22-140416194342-phpapp02/85/PROGRAMACAO-DECLARATIVA-COM-JAVAFX-UM-PARADIGMA-NA-CONSTRUCAO-DE-INTERFACES-GRAFICAS-DE-SISTEMAS-22-320.jpg)
![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](https://image.slidesharecdn.com/tccederdefesa22-140416194342-phpapp02/85/PROGRAMACAO-DECLARATIVA-COM-JAVAFX-UM-PARADIGMA-NA-CONSTRUCAO-DE-INTERFACES-GRAFICAS-DE-SISTEMAS-23-320.jpg)
![. 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:](https://image.slidesharecdn.com/tccederdefesa22-140416194342-phpapp02/85/PROGRAMACAO-DECLARATIVA-COM-JAVAFX-UM-PARADIGMA-NA-CONSTRUCAO-DE-INTERFACES-GRAFICAS-DE-SISTEMAS-25-320.jpg)
![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;}](https://image.slidesharecdn.com/tccederdefesa22-140416194342-phpapp02/85/PROGRAMACAO-DECLARATIVA-COM-JAVAFX-UM-PARADIGMA-NA-CONSTRUCAO-DE-INTERFACES-GRAFICAS-DE-SISTEMAS-27-320.jpg)
![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](https://image.slidesharecdn.com/tccederdefesa22-140416194342-phpapp02/85/PROGRAMACAO-DECLARATIVA-COM-JAVAFX-UM-PARADIGMA-NA-CONSTRUCAO-DE-INTERFACES-GRAFICAS-DE-SISTEMAS-28-320.jpg)
![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:](https://image.slidesharecdn.com/tccederdefesa22-140416194342-phpapp02/85/PROGRAMACAO-DECLARATIVA-COM-JAVAFX-UM-PARADIGMA-NA-CONSTRUCAO-DE-INTERFACES-GRAFICAS-DE-SISTEMAS-29-320.jpg)
![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;](https://image.slidesharecdn.com/tccederdefesa22-140416194342-phpapp02/85/PROGRAMACAO-DECLARATIVA-COM-JAVAFX-UM-PARADIGMA-NA-CONSTRUCAO-DE-INTERFACES-GRAFICAS-DE-SISTEMAS-31-320.jpg)
PROGRAMAÇÃO DECLARATIVA COM JAVAFX: UM PARADIGMA NA CONSTRUÇÃO DE INTERFACES GRÁFICAS DE SISTEMAS
- 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>