Efetiva Serviços e Tecnologia LTDA
Av. José Tozzi, 2003, Térreo. Sala 02.
Centro, São Mateus/ES
Fone: (27) 3767-2750
www.efetivavirtual.com.br
FVC
JAVABEANS Desenvolvimento de componentes em Java – Abordagem pratica
Prof: Douglas Tybel
07/03/2012
2
SUMÁRIO
INTRODUÇÃO ................................................................................................... 3
JAVABEAN – APRESENTAÇÃO E RECURSOS ............................................... 5
EXEMPLO INICIAL ......................................................................................... 6
REGRAS E CONVENÇÕES DE NOMECLATURA ......................................... 7
ESCOPO – VISIBILIDADE DE SEU CÓDIGO ................................................ 9
CONSTRUTORES E DESTRUTORES ......................................................... 10
NETBEANS – PREPARANDO O AMBIENTE .................................................. 11
PRIMEIRO JAVABEANS NA PRATICA COM NETBEANS ............................. 12
INSTALAR JAVABENS COMO COMPONENTE SWING NO NETBEANS .. 18
TESTANDO O COMPONENTE RETANGULO RECEM-CRIADO ................ 20
Instanciando o componente JavaBean e obtendo resultados .................... 21
ICONE EM UM JAVABEAN ............................................................................. 25
CONSIDERAÇÕES FINAIS ............................................................................. 28
BIBLIOGRAFIA ................................................................................................ 29
3
INTRODUÇÃO
Quando falamos de componente, muitas pessoas ficam sem entender o que
vem a ser na prática, ou até mesmo constitui uma definição errônea em sua
mente, afinal o que vem a ser um componente? Em busca desta resposta, o
autor (FUKS & PIMENTEL, 2011) em seu livro sobre sistemas colaborativos,
define componente sendo um pedaço de software executável, com um escopo
de funcionamento bem definido, e que esteja em conformidade com um modelo
de componentes.
Aparentemente não mudou em nada nossa agonia, pois parece que ainda não
ficou claro o que vem a ser realmente, neste sentido, o autor tenta exemplificar
componentes realizando uma comparação com plugins de navegadores web
usados para estender o suporte à visualização de conteúdo, como animações
em flash e documentos pdf. Ufa, parece que agora sim, começamos a ter uma
melhor visão do que vem a ser componente.
Seguindo a ideia acima, então quer dizer que podemos desenvolver pequenos
softwares usando os modelos de componentes existentes e aplicarmos em
outros sistemas? De acordo com o autor, podemos sim. Isso abre muito o
leque na área de desenvolvimento, depois porque, o numero de empresas
focadas neste nicho vem aumentando, como por exemplo, a empresa
DevExpress (devexpress.com) que aposta em mais recursos para os
componentes básicos já existentes com uma interface mais amigável e
elegante.
A forma como os componentes são dispostos nas IDE 1 vem a ser a grande
sacada deste recurso, uma vez que estas ferramentas de desenvolvimento
onde os componentes estão presentes possibilita um recurso de “puxar e
arrastar” o que agiliza e muito o trabalho do desenvolvedor. Para facilitar o
entendimento, vamos assumir como analogia que para um pedreiro construir
um muro, basta que ele faça a massa e cada bloco pode ser colocado
individualmente e comprado individualmente, assim como o componente.
Atualmente um componente que vem chamando atenção é o famoso widget,
uma vez que ele empacota vários recursos como telas, botões, menus e muitos
1 IDE (Integrated Development Environment), um ambiente integrado para desenvolvimento de software
4
outros, quase que um programa completo empacotado, deste modo reduz
muito o custo com setores de desenvolvimento, afinal (SCHACH, 2009) fala
muito bem sobre isso quando diz que para estimar custos vários componentes
geralmente é mais rápido e preciso do que para um único grande componente.
Neste sentido o aumento de pequenos componentes vem chegando para ficar.
Para quem acha que componente só é usado em programação pode ficar de
boca aberta quando souber que na área de designer os componentes também
estão presentes, para aqueles que gostam de realizar sites ou softwares web e
adora aqueles layouts bem clean e futurista sem precisar criar tudo do zero,
com certeza usará o nosso grande aliado componente. Sendo assim consulte
sobre o projeto JQuery (jquery.com) que veio para ficar.
5
JAVABEAN – APRESENTAÇÃO E RECURSOS
Porque começarmos a aprender desenvolvimento de componentes em Java a
partir do Javabean ? A resposta a essa pergunta é bem fácil, isso porque esse
modelo de componente é o mais simples, neste sentido será um ótimo ponto
de partida para nosso aprendizado. Mas não podemos confundir Javabeans
com Enterprise JavaBeans (EJB), uma vez de acordo com a própria (Oracle,
Enterprise JavaBeans Technology, 2013) esse recurso é uma arquitetura de
componentes do lado do servidor para a plataforma Java Enterprise Edition
(Java EE). A tecnologia EJB permite o desenvolvimento simplificado e rápido
de aplicativos distribuídos, transacionais, seguros e portáteis baseados na
tecnologia Java. De toda essa especificação podemos entender que o
JavaBean existe dentro do EJB, não o oposto.
No livro Big Java (Horstmann, 2004, p. 952) existe a definição do Javabean
como sendo uma classe com um construtor default que expõe propriedades
através de seus métodos get e set.
Este componente é bem similar à estrutura de uma classe, mas a grande
diferença é que seu construtor deve ser publico e não ter parâmetros de
entrada.
Algumas pessoas por curiosidade fazem a tradução da palavra Bean em busca
de um melhor entendimento do que vem a ser, mas ao pé da letra o significado
seria algo como “feijão”, sim, você entendeu bem, mas agora a pergunta a
seguir seria – o que tem haver feijão com programação? Bom, a resposta a
essa pergunta tem base nas diversas traduções para a palavra, uma vez que
Bean também pode ser “botão” ou até mesmo “componente”. Agora sim, a
palavra que estávamos esperando, ainda assim podemos concluir que se estes
componentes podem ser “puxados” e “arrastados” para um container
(formulário), então como eu comunico um Bean com outro? Pois bem, essa é
uma grande pergunta que pode complicar a vida de muito profissional da área
ao tentar explicar, até porque o próprio IDE na maioria das vezes realiza esse
trabalho para nós, de modo geral para os recursos do JavaBean são usados
eventos para comunicar uns com os outros.
6
EXEMPLO INICIAL
Vamos então visualizar a estrutura básica de um Javabean simples:
public class Pessoas{
private int id;
private String nome;
public Pessoa(){}
public int getId(){
return id;
}
public void setId (int id){
this.id = id;
}
public String getNome(){
return nome;
}
public void setNome(String nome){
this.nome = nome;
}
}
Tabela 1 - Javabean Pessoas Fonte: Própria (2013)
Para (MELO, 2004, p. 31) é indiscutível que Unified Modeling Language (UML)
é um padrão de mercado para modelagem de sistemas no paradigma da
orientação a objetos com diversos diagramas que nos auxiliam na visualização
destas classes e funcionalidades, por esse motivo vamos ver abaixo como está
disposta a visualização do Javabeans Pessoas na versão diagrama de classe
da UML:
7
Figura 1 - Diagrama classe - Pessoas Fonte: Própria (2013)
A Figura 1 ilustra muito bem o Javabean da classe Pessoas descrita em
códigos acima na Tabela 1.
O Bean devido sua característica similar à classe, nos possibilita realizar
comparações bem sucedidas sem perder o foco. Devemos inicialmente levar
em conta três divisões de uma classe, aqui estão elas:
• O nome;
• As propriedades;
• E os eventos.
Na Figura 1 acima, veja que a classe Pessoas é dividida respectivamente
em três partes horizontais nesta ordem.
REGRAS E CONVENÇÕES DE NOMECLATURA
Ao criar uma classe Javabean devemos seguir as mesmas regras que
seguiríamos no caso de criar uma classe em Java, isso facilita pelo fato deste
conhecimento ser considerado básico para a maioria dos desenvolvedores,
naturalmente essa semelhança ajuda no fato de não precisarmos aprender
algo totalmente novo e sim apenas adequar o que já conhecemos a bastante
tempo. Como base para conhecimento, vamos listar algumas das regras
básicas descritas muito bem por (Xavier, 2013) que são:
• Toda classe deve começar com uma letra maiúscula e, de preferência,
não pode conter letras não ASCII (caracteres de língua de origem latina,
8
como caracteres acentuados). Portanto, não é possível declarar uma
classe com qualquer caracter especial (@, #, $, %, &, *, _, etc...) ou
número.
• Caso o nome de uma classe seja composto por mais de uma palavra, a
primeira letra de cada palavra deve ser em maiúscula.
Veja que acima temos algumas regras que não devem ser deixadas de lado,
pois podem causar erros na hora do desenvolvimento e, para economizarmos
erros, vamos a um exemplo de declaração de classe – Para a classe Pessoas,
repare que a letra inicial é maiúscula enquanto as demais são minúsculas,
assim ocorre à aplicação da primeira regra e, para fechar, vamos supor que
queremos criar uma classe com nomes compostos, do tipo: Nota do aluno,
para isso, vamos sempre deixar em maiúscula as inicias das palavras
compostas, desta forma ficaria: NotaAluno.
As convenções para o segundo e terceiro item que é propriedade e eventos,
seguimos as mesmas regras para a declaração de variavel, que por sua vez
segundo (BERG & FIGUEIRÓ, 2006, pp. 34-35), a declaração de uma variável
consiste em:
• nome que a diferencia das demais;
• tipo de dado associado, que indica o tipo de informação que poderá ser
armazenada na variável;
• conteúdo, que é o dado guardado na variável;
• endereço, que a localiza na memória;
O autor faz observações relevantes sobre as variáveis:
1) O nome de uma variável é único em um algoritmo.
2) O conteúdo de uma variável poderá ser um dado todo tipo usado na sua
criação.
3) O conteúdo de uma variável é substituído por outro conteúdo que lhe
venha a ser atribuído.
4) O uso do nome de uma variável em uma expressão significa o uso do
seu conteúdo (naquele momento) dentro da expressão.
5) O uso de um conteúdo de variável em uma expressão não modifica seu
valor.
9
Para a declaração da variável, de modo geral, basta definir seu tipo e nome,
onde se tem certa liberdade na nomenclatura, todavia, existem alguns limites
básicos a serem observados para que sua variável não seja confundida com
comandos internos.
Cada linguagem de programação tem suas próprias regras para formação do
nome de uma variável, de modo geral, a regra comum é: Nome de uma
variável pode ser composto por letras sem espaço, dígitos e até mesmo o
underline (_), sendo que o primeiro caractere deve ser uma letra.
ESCOPO – VISIBILIDADE DE SEU CÓDIGO
Observe na Figura 1 que pouco antes das propriedades ou eventos, contem
um sinal de subtração ou adição, essa declaração em UML diz se o campo é
privado ou publico, sendo o sinal de subtração a visibilidade private e adição a
visibilidade public. Os atributos e variáveis fazem parte de um escopo que é
utilizado para definir o tipo de acesso que terá determinado atributo, classe ou
objeto. Uma parte ficará totalmente escondida e restrita, e a outra servirá
apenas ao pacote de classes que a classe que o definiu pertence, e uma última
parte tem seu acesso tratado com as seguintes palavras-chave:
• public: Qualquer classe, de qualquer pacote, tem acesso a este. • protected: Apenas as classes do mesmo pacote possuem acesso a
este. • private: Apenas a própria classe poderá acessar este.
Veja como definir variáveis ou atributos com escopo:
public int c; //Atributo público de nome c do tipo inteiro.
protected double b; //Atributo protegido de nome b do tipo double.
private boolean a; //Atributo particular de nome a do tipo boolean
A sintaxe completa da definição de um atributo ou declaração de uma variável
em Java é:
escopo tipoPrimitivo nomeVariavel = valorInicial;
10
CONSTRUTORES E DESTRUTORES
Segundo (DALL 'OGLIO, 2007, p. 96), o destrutor ou finalizador é um método
especial executado automaticamente quando o objeto é deslocado da
memória, quando atribuímos o valor NULL ao objeto, quando utilizamos a
função para destruir sobre o mesmo ou, em ultima instancia, quando o
programa é finalizado. O método destrutor pode ser utilizado para finalizar
conexões, apagar os arquivos temporários criados durante o ciclo de vida do
objeto, dentre outros circunstâncias. Em PHP para definir um método destrutor
em uma determinada classe basta declarar o método __destruct() ou para o
construtor __construct(), mas em Java a classe é destruída automaticamente
por um recursos da linguagem chamada Garbage Collector, por esse motivo os
desenvolvedores em Java não se preocupam com a destruição do objeto, mas
para a criação ainda é necessário um método construtor.
De modo geral, são métodos que serão executados automaticamente em dois
momentos do ciclo de vida do objeto, ao criar o objeto; então ao final da vida do
objeto. A fim de podermos executar funções automaticamente ao criar e ao
destruir o objeto.
Em Java, nas classes e até mesmo nos Javabeans será necessário criar um
método construtor sem passagem de parâmetros de entrada, abaixo veja um
recorte da classe da Tabela 1, focando apenas no construtor.
public class Pessoas{
[ Atributos suprimidos]
public Pessoa(){
//Código que será executado ao criar objeto
}
[ Encapsulamentos suprimidos]
}
Tabela 2 - Recorte classe pessoas – Construtor Fonte: Própria (2013)
Observe que o método construtor é constituído apenas da visibilidade, nome
classe sem parâmetro entre os parênteses e um espaço para códigos em Java
que possa vir a ser executado ao criar uma instancia da classe.
11
NETBEANS – PREPARANDO O AMBIENTE
Para iniciar nossos testes, a primeira coisa que devemos fazer é preparar o
ambiente de desenvolvimento. Podemos comparar com um escritório montado
para poder realizar o serviço de papelada. Por esse motivo, escolher as
ferramentas mais produtivas, conta e muito quando diz respeito a custos e
prazos.
Por motivos didáticos, realizaremos os testes no IDE Netbeans versão superior
a versão 6. Para quem nunca ouviu falar, (GONÇALVES, 2006, p. 23),
conceitua o Netbeans como sendo um ambiente de desenvolvimento, IDE
(Interface Development Environment), open-source, isso quer dizer, de código-
aberto escrito totalmente em Java. O Autor completa ainda com a história do
Netbeans e diz que foi fundado pela Sun Microsystems em junho de 2000 e,
ainda nos dias de hoje continua sendo seu principal patrocinador.
Para que essa ferramenta funcione adequadamente, teremos que instalar
previamente o Software Development Kit (SDK) e Java Runtime Environment
(JRE). O JDK pode ser baixado juntamente com a instalação do Netbeans.
Existem outras IDE, as mais conhecidas são: JCreator da Xinon Software, o
Eclipse da IBM, JBuilder da Borland e JDeveloper da Oracle, todos eles
oferecem recursos semelhantes na hora de desenvolver seu software para
Java. Além disso, também fornecem acesso rápido e fácil para
desenvolvimento em Java, porem como não foi encontrado nenhum estudo que
indique qual é a mais produtiva ou com mais recursos, após varrer a internet,
foi verificado que duas delas se destacam e a maioria dos desenvolvedores
tem essa indecisão na hora de dizer qual é o melhor, pois parece que alguns
benefícios presentes em um, estão ausente no outro, portanto uma é o
Netbeans e a outra é o Eclipse. Então para quem quer se aventurar em outra
ferramenta, fique a vontade, mas para o estudo usaremos o Netbeans.
Abaixo a lista dos itens necessários para iniciarmos:
1. SDK atualizado.
2. JRE atualizado.
3. Netbeans versão 6 ou superior.
12
PRIMEIRO JAVABEANS NA PRATICA COM NETBEANS
Para criarmos um Javabeans, começamos como se fossemos criar um projeto
normal no Netbeans, acessando o menu “Arquivo >> Novo projeto...”, a tela a
seguir será apresentada:
Figura 2 - Tela Novo Projeto no Netbeans Fonte: Própria(2013)
Como o Netbeans é uma IDE com suporte a outras linguagens além do Java,
por esse motivo em categorias escola a pasta “Java” e em Projetos escolha
“Aplicação Java”.
Para continuar, basta clicar no botão próximo e seguir as instruções. Para
minimizar erros, assumiremos o seguinte nome para o projeto:
“PrimeiroJavaBean”. O restante das informações é preenchido
automaticamente não sendo necessária alteração. Próximo passo é clicar no
botão “Finalizar” e concluir o assistente.
Seu projeto foi criado, neste sentido, continuaremos com o próximo passo que
será criar a classe Javabeans, para isso, clique sobre o pacote
“primeirojavabean”, (uma pasta amarela) e com botão direito escolha no menu
suspenso “Novo >> Outros”. Em categoria marque Objetos JavaBeans, e “Tipo
de arquivos” defina como “Componente JavaBeans”, clique no botão próximo,
neste sentido defina o nome do seu bean como Retangulo, e para fechar,
clique em concluir. A tela final do assistente será algo do tipo:
13
Figura 3 - Tela New Componente JavaBeans Fonte: Própria(2013)
Abaixo segue a estrutura esquelética de um Bean modelo para que você possa
se basear:
public class Retangulo implements Serializable {
public static final String PROP_SAMPLE_PROPERTY = "sampleProperty";
private String sampleProperty;
private PropertyChangeSupport propertySupport;
public Retangulo() {
propertySupport = new PropertyChangeSupport(this);
}
public String getSampleProperty() {
return sampleProperty;
}
public void setSampleProperty(String value) {
String oldValue = sampleProperty;
sampleProperty = value;
propertySupport.firePropertyChange(PROP_SAMPLE_PROPERTY, oldValue,
sampleProperty);
}
public void addPropertyChangeListener(PropertyChangeListener listener) {
propertySupport.addPropertyChangeListener(listener);
}
14
public void removePropertyChangeListener(PropertyChangeListener listener) {
propertySupport.removePropertyChangeListener(listener);
}
}
Tabela 3 - Estrutura base de um JavaBean Fonte: Própria (2013)
Ao visualizar tanto código não fique assustado, pois a maioria do código ai
trata-se do resultado dos encapsulamentos e foram e serão gerados
automaticamente pela IDE.
Vamos personalizar nosso retângulo criando três campos que são:
1. Base
2. Altura
3. Area
Os campos nos auxiliarão na manipulação deste Bean. Funcionará da seguinte
maneira:
Quando o usuário arrastar nosso bean para o Frame do seu projeto, poderá
definir os atributos base e também altura e obter a área calculada.
Para realizar essa tarefa teremos que criar os campos Base e Altura com as
capsulas get e set, contudo o atributo Area será apenas a capsula get, uma vez
que será somente leitura para o usuário, desta forma o usuário não poderá
alterar este Bean diretamente, apenas a partir dos atributos Base e Altura.
Procure pelo construtor do Bean “public Retangulo()”, então no espaço vazio
acima desta linha, clique com botão direito do mouse e escolha “Inserir
Código...”.
Tabela 4 - Opção Inserir código... Fonte: Própria (2013)
15
Role a barra até a ultima opção “Adicionar propriedade...”, na tela “Adicionar
Propriedade” preencha com nome do atributo e seu tipo, deixe o padrão para
Gerar getter e setter conforme informado acima e clique no botão OK:
Figura 4 - Tela Adicionar Propriedade Fonte: Própria (2013)
Faça o mesmo para o campo altura e para o campo Area marque apenas a
opção “Gerar getter”, uma vez que este campo será somente leitura para o
usuário.
O resultado será algo do tipo:
public class Retangulo implements Serializable {
public static final String PROP_SAMPLE_PROPERTY = "sampleProperty";
private String sampleProperty;
private PropertyChangeSupport propertySupport;
private float base;
/**
* Get the value of base
*
* @return the value of base
*/
public float getBase() {
16
return base;
}
/**
* Set the value of base
*
* @param base new value of base
*/
public void setBase(float base) {
this.base = base;
}
private float altura;
/**
* Get the value of altura
*
* @return the value of altura
*/
public float getAltura() {
return altura;
}
/**
* Set the value of altura
*
* @param altura new value of altura
*/
public void setAltura(float altura) {
this.altura = altura;
}
private float area;
/**
* Get the value of area
*
* @return the value of area
*/
public float getArea() {
return area;
}
public Retangulo() {
propertySupport = new PropertyChangeSupport(this);
}
public String getSampleProperty() {
return sampleProperty;
}
public void setSampleProperty(String value) {
String oldValue = sampleProperty;
sampleProperty = value;
17
propertySupport.firePropertyChange(PROP_SAMPLE_PROPERTY, oldValue,
sampleProperty);
}
public void addPropertyChangeListener(PropertyChangeListener listener) {
propertySupport.addPropertyChangeListener(listener);
}
public void removePropertyChangeListener(PropertyChangeListener listener) {
propertySupport.removePropertyChangeListener(listener);
}
}
Tabela 5 - JavaBean Retangulo Fonte: Própria (2013)
O acabamento será uma pequena modificação que faremos no método: “public float getArea()”. Isso porque o retorno desse método deve ser o calculo da área do retângulo. Como é de conhecimento de todo estudante, a área do retângulo é calculada com a multiplicação da base pela altura. Essa formula seria: A = b * h. Uma vez que A = área, b= Base e h = Altura.
public float getArea() {
return area;
}
Tabela 6 - Método getArea antes da alteração Fonte: Própria (2013)
Alteração do método com o calculo:
public float getArea() {
this.area = (this.base*this.altura);
return area;
}
Tabela 7 - Método getArea após alteração Fonte: Própria (2013)
Após a alteração do encapsulamento getArea para o calculo da área, devemos
então complicar o projeto para testar. Clique com botão direito sobre o projeto e
escolha >> Limpar e construir. Na caixa de saída será informado o diretório no
qual o “.jar” do componente foi gerado, algo do tipo:
“Documents\NetBeansProjects\PrimeiroJavaBean\dist\PrimeiroJavaBean.jar”.
Anote esse caminho, pois para instalar seu componente no Netbeans será
necessário direcionar para esse arquivo.
18
INSTALAR JAVABENS COMO COMPONENTE SWING NO NETBEANS
Para a instalação do JavaBean na paleta de componentes swing do Netbeans
basta ir até o menu Ferramentas >> Paleta >> Componentes Swing/AWT. Na
tela Gerenciador de Paleta clique no botão Nova categoria e crie uma categoria
chamada “Terceiros” para abrigar seu novo componente.
Figura 5 - Gerenciador de Paleta Fonte: Própria (2013)
Clique no botão “Adicionar do JAR” e procure pelo caminho do “.jar” criado no
passo anterior.
Figura 6 - Tela Instalar componente na paleta (Selecionar arquivo JAR) Fonte: Própria (2013)
19
Clique sobre o botão avançar e na segunda fase da instalação escolha a classe
recém-criada, chamada: Retangulo.
Figura 7 - Fase selecionar Componentes Fonte: Própria (2013)
O ultimo passo é apontar a categoria que deseja que seu componente seja
instalado, neste sentido, direcione para a categoria criada anteriormente
chamada: “Terceiros”.
Figura 8 - Fase Selecionar Categoria da Paleta Fonte: Própria (2013)
20
Pronto, agora quando estiver em um projeto e desejar adicionar um
componente que calcula a área do retângulo basta puxar e arrastar o
componente novo para seu frame.
TESTANDO O COMPONENTE RETANGULO RECEM-CRIADO
Crie um novo projeto de teste, pode ser um aplicativo Java normal. Crie um
novo frame como formulário.
Figura 9 - Arrastando o JavaBean para o Frame Fonte: Própria (2013)
Não fique assustado se no momento em que tiver arrastado e soltado o
JavaBean no frame, nada tenha acontecido, isso porque os beans
naturalmente são não visuais, para que seja visual, será necessário herdar
alguns comportamentos ou melhor sua implementação, neste sentido, para
localiza-lo e utiliza-lo, vá até a parte esquerda do Netbeans no Inspetor de
Objetos, repare na categoria “Outros componentes” e perceberá a existência
do nosso JavaBean.
Figura 10 - Inspetor de Objetos do Netbeans Fonte: Própria (2013)
21
Para visualizar as propriedades que criamos, clique com o botão direito do
mouse sobre o Javabean retangulo1 que se encontra na categoria “Outros
componentes” do Inspetor de objetos e escolha a opção “Propriedades” no
menu suspenso.
Figura 11 - Propriedade do JavaBean Retangulo Fonte: Própria (2013)
Observe com atenção a presença das propriedades criadas por nós como
“base, altura e área”. Veja também que o atributo “área” está apagado,
impossibilitando definição de valores, isso porque ao criar essa propriedade,
deixamos definidos apenas a capsula Getter, que vem a ser obtenção de dados
e não definição de dados como o Setter, enquanto os outros foram definidos
com ambas as capsulas.
Instanciando o componente JavaBean e obtendo resultados
Para iniciar, vá até o Frame de teste que você criou e adicione três
componentes Label(JLabel), mais três componentes Campo Formatado
(JFormattedTextField) e por fim um Botão (JButton). Ficará conforme imagens
abaixo:
22
Tabela 8 - Imagens construção formulário teste Fonte: Própria (2013)
Para os jLabel’s, altere o rótulo respectivamente para “Base:”, “Altura:” e
“Área:”.
Para os jFormattedText’s edite os texto e deixem em brancos e altere os
nomes respectivamente para: “basejFormattedTextField”,”
alturajFormattedTextField” e “areajFormattedTextField”, observe na imagem
acima o resultado.
O botão altere o rótulo para “Calcular”.
Clique com botão direito sobre o botão “Calcular” vá até Events >> Action >>
actionPerformed.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}
Tabela 9 - ActionPerformed do jButton1 Fonte: Própria (2013)
Acima segue o trecho do evento que ocorrerá quando o usuário clicar sobre o
botão, neste caso como não tem código, significa que nada acontecerá.
Nosso objetivo é que quando o usuário informar a base e a altura, ao clicar
sobre o botão “Calcular” no campo área será informado o resultado, tudo isso
sem realizar calculo, usando o recurso disponível no componente que criamos.
23
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
//Para facilitar o entendimento, definiremos três variáveis.
float base;
float altura;
float area;
//Obter o texto digitado pelo usuário no campo,
//converter para float e atribuir a variavel base
base = Float.parseFloat( basejFormattedTextField.getText() );
altura = Float.parseFloat( alturajFormattedTextField.getText() );
//Definir as propriedades do componente retângulo
//com as variáveis obtidas
retangulo1.setBase(base);
retangulo1.setAltura(altura);
//Obter o valor da área do método getArea do Retangulo
area = retangulo1.getArea();
//Atribuir valor ao componente na tela para o usuário
areajFormattedTextField.setValue(area);
}
Tabela 10 – Código do ActionPerformed do jButton1 Fonte: Própria (2013)
O código acima apresentado na tabela “Código do ActionPerformed JButton1”
traduz muito bem a facilidade de usar um componente e como ele pode ser útil
e descomplicar a vida do programador, isso porque, você pode perceber que
não foi usado nenhum calculo, uma vez que todo a matemática está
encapsulada no componente Retangulo. Em pequena escala assim, pode não
parecer grande coisa, mas para componentes maiores isso vem a ser um
diferencial com um grande poder de produtividade. Podemos ver exemplos de
componentes capazes de gerar boletos para diversos bancos, enviar e receber
remessa e o que o programador tem que fazer é apenas passar os dados de
cedente, banco, títulos e outros. Todo o código está encapsulado com o poder
de reuso.
Veja abaixo o resultado da tela após preencher os dados da base com 6 e
altura com 3, ao clicar sobre o botão calcular, obtivemos o valor 18.
24
Figura 12 - Tela de calculo da área retângulo Fonte: Própria (2013)
25
ICONE EM UM JAVABEAN
Quando criamos um JavaBean, precisaremos definir um ícone para que
tenhamos por completo criado nosso componente.
Normalmente quando se cria um componente e usa as técnicas de herança,
que não foram abordados neste artigo, uma vez que essa parte trata-se de
tópicos avançadas, tempos o ícone herdado do pai que concedeu o
comportamento, por esse motivo, como o JavaBean não recebe herança,
devemos definir nosso próprio ícone.
Para definirmos algumas características do JavaBean, devemos fazer o uso da
classe BeanInfo, que está associada ao seu Bean. Características como ícone
e outros é totalmente configurável por essa classe.
De acordo com a (Oracle, Using a BeanInfo), um BeanInfo é uma classe que
muda a forma como o componente aparece em uma ferramenta de criação. A
ferramenta construtor pode consultar o BeanInfo para descobrir quais as
propriedades que deve exibir em primeiro lugar e que deve ser escondido.
A classe BeanInfo para o componente deve ter o mesmo nome que a classe
principal, com BeanInfo anexado. Por exemplo, a classe Retangulo tem uma
classe RetanguloBeanInfo correspondente que descreve.
Embora seja possível implementar uma classe BeanInfo "à mão", você vai
achar que é muito mais fácil usar uma ferramenta como o NetBeans para editar
o BeanInfo.
Para iniciarmos a criação da classe BeanInfo através do Netbeans, vamos
começar clicando com botão direito do mouse sobre a classe do componente,
no nosso caso chama-se: “Retangulo”, conforme imagem abaixo:
26
Figura 13 - Menu suspenso - Editor BeanInfo Fonte: Própria (2013)
Ao clicar sobre a opção para gerar o BeanInfo, uma caixa de dialogo de
confirmação será solicitada, clique em “Sim” para confirmar a criação.
Figura 14 - Pergunta - Confirmar criação Fonte: Própria (2013)
Após esse processo, uma classe chamada “RetanguloBeanInfo” será criada
pronta para ser configurada.
27
Figura 15 - View Designer Fonte: Própria (2013)
Clique sobre o botão “View Designer” para visualizar a parte visual da classe
BeanInfo.
Figura 16 - Designer – BeanInfo Fonte: Própria (2013) Para alterar o ícone, clique sobre o primeiro item da arvore da esquerda
chamado “BeanInfo”, nas propriedades, em “Cor 16x16 do Ícone”, clique no
botão “...” (três pontinhos) e procure por seu ícone. Após esse processo, basta
compilar e estará pronto.
Assim como o ícone, outras características também podem ser alteradas, basta
ir alterando. Lembrando que essas alterações aparecerão no modo designer ao
desenvolver.
28
CONSIDERAÇÕES FINAIS
Concluímos neste artigo o quão poderoso pode ser um simples componente
JavaBeans, principalmente para aprendermos a realizar algo maior. Existem
diversas empresas que focam apenas na criação de componentes para as
tantas ferramentas espalhadas pelo mundo do desenvolvedor, mas também
existem projetos pela internet como o “ACBr” para Delphi e SwingX (aerith,
swinglabs, kleopatra, Potochkin, Schaefer, & rah003, 2013) para Java.
Outra opção para criação de componentes é as tantas necessidades vindas do
Governo, como notas de serviço, geradores de arquivos Sintegra, sped e
outros. Para quem procura componentes específicos para esse fim,
especialmente para Java, quase não encontra nada. Isso abre muitas
possibilidades e faz com que o componente se fortaleça no universo da
produtividade do desenvolvimento.
29
BIBLIOGRAFIA
aerith, swinglabs, kleopatra, Potochkin, A., Schaefer, K., & rah003. (26 de 04 de
2013). The Source for Java Technology Collaboration. Acesso em 16 de
03 de 2013, disponível em swingx.java.net: https://swingx.java.net
ANSELMO, F. (2005). Aplicando Lógica Orientada a Objeto em Java (2ª ed
ed.). Florianópolis: VisualBooks.
BERG, A., & FIGUEIRÓ, J. P. (2006). Lógica de programação (3ª Edição ed.).
Canoas: ULBRA.
DALL 'OGLIO, P. (2007). PHP: programação com orientação a objetos. São
Paulo: Novatec.
FUKS, H., & PIMENTEL, M. (2011). SISTEMAS COLABORATIVOS. PORTO
ALEGRE: Elsevier Brasil.
GONÇALVES, E. (2006). Dominando o NetBeans. Rio de Janeiro: Ciência
Moderna Ltda.
Horstmann, C. (2004). Big Java. Porto Alegre: Bookman.
MELO, A. C. (2004). Desenvolvendo aplicações com UML 2.0 (2ª Edição ed.).
Rio de Janeiro: Brasport.
OLIVEIRA, M. R. (2005). Administração de Empresa com Access. São Paulo:
Digerati Books.
Oracle. (2013). Enterprise JavaBeans Technology. Acesso em 06 de 02 de
2013, disponível em oracle.com:
http://www.oracle.com/technetwork/java/javaee/ejb/index.html
Oracle. (s.d.). Using a BeanInfo. Acesso em 16 de 02 de 2013, disponível em
docs.oracle.com:
http://docs.oracle.com/javase/tutorial/javabeans/writing/beaninfo.html
PHP. (2012). What is PHP? Acesso em 04 de 03 de 2012, disponível em
php.net: http://www.php.net/
SCHACH, S. R. (2009). Engenharia de Software - Os Paradigmas Clássico e
Orientado a Objetos (7 ed.). Bookman.
Xavier, D. W. (2013). Regras e Convenções de Nomenclatura. Acesso em 02
de 03 de 2013, disponível em tiexpert.net:
http://www.tiexpert.net/programacao/java/nomenclatura.php