Uma breve apresentação do JBuilder

Programação 3: Orientação a Objetos e Java

Parte 1

    1.1 Introdução:

Por que utilizar um ambiente de programação visual?
    O objetivo desta ferramenta é prover um modo mais fácil e interativo de construir e manipular seus programas, proporcionando um conjunto de facilidades que vão desde a rápida visualisação de todos os arquivos contidos no projeto até ferramentas de gerenciamento de trabalho coletivo. Entre as ferramentas básicas estão:
• O class browser, que permite visualizar toda a estrutura de diretórios e arquivos contidos no projeto;
• O debugger, que possibilita um monitoramento mais elegante do funcionamento de um programa, facilitando a detecção e remoção dos erros "lógicos".
• Os wizards, que são "programas" que auxiliam na contrução rápida de aplicações com características iniciais já conhecidas. Por exemplo, um programa que deva possuir uma janela tipo windows e um menu.
    Obs: Para ilustrar o funcionamento do programa utilizaremos um pequeno projeto chamado Util.jpr (arquivo util.zip), que possui apenas uma classe chamada StandarDialogAtencao.java, esta classe possui um boolean indicando o status do componente, bem como métodos para ajuste da mensagem e para o retorno do estado. Qualquer duvida durante o decorrer da apresentação verifique o código da classe, nela existem alguns comentários que podem ser úteis para esclarecimento. Arquivo do projeto:

    1.2 Descrição do ambiente JBuilder:

Neste curso utilizaremos o ambiente de programação JBuilder1.0 Professional da Borland, que será descrito a seguir:
    A janela principal do aplicativo conciste de menus, botões de atalho e paletas de componentes.



1.2.1 Janela do projeto.

    O que é a "janela do projeto" ?
        É a área onde o trabalho de edição será efetivamente realizado. Primeiro apresentaremos seus principais componentes e funcionalidades, na proxima seção mostraremos como criar um projeto.
    Os principais componentes desta janela são mostrados na figura abaixo. Observe bem os comentários.
 



Figura 1.

Pastas disponíveis:

• Project: Nela estão as informações relativas as classes(interfaces,etc), clicando-se nos itens apresentados nesta área o programa automaticamente segue para a linha do código correspondente;
• Opened: Lista todos os arquivos que estão abertos, mas que não pertencem necessariamente ao projeto;
• Directory: Lista os drivers, diretórios e arquivos disponíveis, funciona como um Windows Explorer;
• Source: Nesta pasta é "visualizado" o código da classe ou interface, bem como os arquivos fonte do HTML e os arquivos de texto.
• Design: Para aquelas classes que possuem interface gráfica, ao se selecionar esta pasta o programa vai converter o código no esquema da aplicação e posteriormente irá mostrá-la, para as que não possuem interface esta pasta simplesmente não faz nada e mostra uma mensagem indicando erro.
• Doc: Mostra a documentação disponível para a classe selecionada.
 
1.2.2 Visualização da interface.

    Como foi dito acima esta visualização só é possível para as classes que possuem interface gráfica, para visualizar, escolha o arquivo desejado e clique em Design.
    Na figura abaixo foi selecionado o arquivo StandardDialogAtencao.java que é um componente Dialog, logo possui interface, em seguida a pasta Design foi clicada mostrando assim o componente para a edição gráfica.



Figura 2.   1.2.3 Ajustando as propriedades dos componentes:

    Para o ajuste das propriedades dos componentes da interface existe uma "janela" auxiliar chamada Inspector ,mostrada abaixo, que permite que você tanto modifique as propriedades do componentes - por exemplo o texto que é apresentado em um botão - como "monitorar" o que acontece com os mesmos através da associação de "eventos".Obs: Você só tem acesso a este recurso nas classes que possuem interface, e com a pasta Design selecionada. Caso o Inspector não esteja visível selecione o menu View/Inspector.
    Nesta janela existem duas pastas, a Properties e Events que correspondem as duas funcionalidades descritas acima. Nas figuras abaixo estão as propriedades e eventos associados ao botão OK da classe StandardDialogAtencao. Para selecionar qual o componente que será ajustado clique sobre o mesmo na pasta Design ou na área com a hierarquia dos componentes.
 

Figura 3. Figura 4.

1.2.4 Trabalhando com menus.

    Para a contrução de menus o processo é o mesmo, seleciona-se o arquivo e clica-se em Design.



Figura 5.

    1.3 Criando um projeto:

1.3.1 O que é um projeto?

    Projeto é um conjunto de arquivos que se interrelacionam formando um aplicativo, no caso teremos conjuntos de pacotes e objetos que se agrupam para a execução do programa final, seja ele um PRODOC, LIGAVIRTUAL,NETFOLIA ou SGC.

1.3.2 Criando e salvando projetos.

    Para criar um projeto você deve, no menu File, selecionar a opção New Project... .Feito isto é só seguir os passos do Wizard, escolhendo o diretório em que vai ficar o projeto, autor, etc. Após esta etapa você terá na sua tela uma janela semelhante a da figura 1. Agora é você pode acrescentar seus arquivos e pacotes.
    Para salvar os arquivos utilize sempre o menu File/Save All, e a cada passo importante do seu trabalho não esqueça de salvar seus arquivos pois o JBuilder ainda apresenta alguns bugs que podem repentinamente fechar o aplicativo perdendo assim o que não foi salvo.

1.3.3.Criando e incluindo arquivos.

    Se você selecionar a opção New..., do menu File aparecerá uma janela como:
 

Figura 6

    Nesta janela você pode optar por criar uma classe, applicativo, um novo projeto, um applet, etc. Se quiser apenas criar uma classe selecione o tipo Class.
    Obs: Para cada componente selecionado existe um Wizard(algo tipo um passo a passo), que permitirá que você selecione um conjunto de opções pré-definidas, como centralizar aplicativo no centro da tela, parâmetros do applet, etc. Apenas preencha normalmente as opções que desejar e siga em frente. Caso você queira ver como isto funciona tente seguir o roteiro criandoUmApplet.htm, nele criaremos um applet simples.
    Para incluir arquivos já existentes no seu projeto você deve utilizar os botões de inclusão e remoção, vide figura 1.

1.3.4 Configurando os paths do JBuilder.

    No JBuilder existem duas variáveis associados a idéia de path são eles:

• Classpath: Que corresponde a noção já existente no JDK.
• Outpath: Esta variavel é importantíssima no desenvolvimento de seu projeto pois é ela que vai indicar em que diretório(s) o(s) arquivo(s) .class será(ão) guardado(s).
    Para ajutar tais variáveis você deve selecionar a opção Project Properties... do menu File, em seguida alterar as variáveis como quiser.
    Obs: O ajuste destas variáveis é feito para cada projeto, o ajuste feito em um projeto não é assumido nos outros, a menos que você altere as propriedades do ambiente através do menu Tool/IED Options..., coisa que não é possível pois isto implica em alteração do arquivo de inicialização, coisa que só pode ser feita pelo administrador.

Parte 2

    2.1 Criando uma interface gráfica:

    Para se criar interfaces gráficas a maneira mais trivial é utilizar os Wizards do menu File/New..., provavelmente o ponto de partida do que você deseja fazer está em alguma de suas opções.
    Obs: Sempre que você for acrescentar qualquer componente através do menu File/New... este componente será incluido no projeto atual, caso não haja nenhuma janela de projeto aberta o programa criará automaticamente um novo projeto no qual será incluido este novo componente, mostrando antes o wizard do projeto. Logo não se assuste se você quiser criar um applet,etc e antes disso ele mostrar o wizard de um projeto.
    IMPORTANTE: Caso você tenha um arquivo de um applet, frame, etc. e deseja incluí-lo no projeto você pode fazê-lo sem problemas, porém o JBuilder não será capaz de lhe dar a opcão relativa a pasta Design, isto é, edição gráfica deste aplicativo, pois ele só é capaz de "entender" os arquivos que foram gerados com a sua padronização.

    2.2 Utilização dos layouts:

    A utilização dos layout definidos na AWT é fundamental quando queremos fazer programas realmente portáveis, isto é, interfaces gráficas portáveis. Programas que apresentam-se visualmente bem num PC podem eventualmente se apresentar quase que totalmente "deformados" numa estação de trabalho, o layouts ajudam a minimizar estas diferentes propriedades dos monitores. Talvez isto seja mais bem tratado com o surgimento de aperfeiçoamentos do AWT como a JFC(Swing).
    Apesar de considerar este um item relevante não entraremos em detalhes sobre a utilizacao dos layouts. Material a respeito pode ser encontrado no próprio Help do programa.

    2.3 Desenvolvendo menus para aplicações:

    Utilização do menu designer(figura 3) possibilita a criação, ajuste de propriedades e associação de eventos nos menus do programa, bem como existe a possibilidade de associar teclas de atalho através do Inspector.

    2.4 Associando eventos aos objetos da interface:

    Até este momento falamos muito sobre a associação de eventos aos objectos da interface, mas não detalhamos este processo, tentaremos agora ver como isto funciona.
    Para cada componente gráfico existe uma série de ações que podem ocorrer. Suponhamos que temos um botão na interface como o botão OK da figura 2, pode acontecer o seguinte: o botão ser pressionado, o mouse entrar na área do botão, o mouse ser pressionado sobre o botão, alguém apertar o Enter com o foco em cima do botão, o mouse sair de cima do botão, etc. Todos estes movimentos podem ser acompanhados pelo programa através dos Listeners, que são classes auxiliares que monitoram os componenentes, só que isto fica "transparente" para que está programando, o que importa é o que vai acontecer quando determinada ação ocorrer.
    Vejamos o exemplo do botão OK, observando a figura 4, que mostra a pasta Events , vemos quais são as ações que são relevantes para o botão, isto é, em que condições aquele componente irá disparar um procedimento a ser realizado. Temos dois caso, o button_OK_actionPerformed e o button_OK_keyPressed, o primeiro se refere ao "aperto"do botão, o segundo ao fato de uma tecla ser apertada quando o foco for o botão. Para cada uma destas situações é executado um procedimento respectivo, no caso este procedimento terá sempre os mesmos nome que constam no Inspector, mas isto não é regra, você pode dar os nomes que quiser as seus métodos. Sendo assim no código da classe StandarDialogAtencao.java teremos as linhas:

    // botao OK pressionado
    void button_OK_actionPerformed(ActionEvent e) {
        OK();
        }

    // tecla Enter pressionada "sobre" o botão OK
    void button_OK_keyPressed(KeyEvent e) {
        if( e.getKeyCode() == KeyEvent.VK_ENTER)
            OK();
        }
    private void OK() {
        status = true;
        dispose();
        }

     Com isso foi determinado que quando o botão OK for pressionado, ou uma tecla for pressionada e esta tecla for Enter o método OK() será executado. A exceção do corpo dos métodos, que fica a critério do programador,  o JBuilder constrói os "links" dos nomes do métodos as ações que devem dispará-los automaticamente.
    Para construir estes links você deve selecionar o objeto na interface, em seguida, na janela Inspector, selecionar a pasta Events, verificar que comportamento deste objeto deve ser monitorado, em seguida clicar duar vezes sobre a área cinza lateral ao nome do evento que você desejar, neste momento o JBuilder automaticamente criará tanto o nome do método, como o listener para o componente e mostrará a região do código onde se encontra tal método. Feito isto é só construir o corpo, a deleção de eventos dá-se de forma semelhante, seleciona-se o objeto, na pasta Events, clica-se uma vez no método que se deseja deletar e em seguida pressiona-se a tecla Delete. Importante: Se seu método contiver alguma linha de código que não foi contruída pelo próprio JBuilder, apenas os links com os listener serão apagados ficando a cargo do programador deletar o método correspondente.
    Você pode ver um exemplo bem simples de como fazer isto em criandoUmApplet.htm.

Parte 3

    3.1 Compilando e executando os programas:

    Como foi visto utilizando o JDK, para executar um "arquivo" é preciso que este possua um método main(), o JBuilder permite que você selecione o arquivo principal de um projeto ou que execute individualmente cada arquivo.
    Para indicar qual é o arquivo principal do projeto selecione o menu File/Project Properties... e vá para a pasta Run/Debug no choice do Default Runnable File escolha o arquivo. Para executar o projeto( o arquivo selecionado como principal ) você pode utilizar o menu Run, clicar no botão direito do mouse e selecionar a opção Run, ou pressionar as teclas Shift-F9, para executar um arquivo específico do projeto você só pode utilizar a segunda opção, isto é, o botão direito do mouse.
    Antes de executar o programa, você também tem a opção de compilá-lo para retirar eventuais problemas, caso sua classe apresente problemas, estes serão listados numa área abaixo da área do código, ao clicar-se sobre o erro o JBuilder automaticamente levará o cursor para linha correspondente, isto facilita muito a remoção dos erros.
 

Thiago Santos (tlvls@di.ufpe.br)