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

contato@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