Objetivos:

• Entender o funcionamento de arrays em Java

• Aprender a utilização de caixas de diálogo

1. Arrays

Assim como na maioria das linguagens modernas (C, Pascal, etc) os arrays em Java são estruturas de dados que armazenam diversas coisas do mesmo tipo. Essas coisas podem ser tipos primitivos (int, char, etc) ou objetos.

A declaração de um array em Java é realizada da seguinte maneira:

   int valores[] = new int[20];

No exemplo acima, será criado um array com 20 posições, numeradas de 0 a 19. Cada posição pode ser acessada individualmente, utilizando o operador [ ].

É possível também inicializar automaticamente um array com valores determinados:

   int valores[] = { 1, 2, 4, 8, 16, 32, 64, 128 };

Este tipo de inicialização só funciona para tipos primitivos e Strings:

   String nomes[] = { "Ana", "Carlos", "Felipe", "Pedro" };

Observe que uma vez inicializado, o tamanho de um array não pode ser alterado!

Arrays são inteligentes: sabem seu tamanho. Isso é fundamental, pois é essencial haver uma maneira de descobrir o espaço solicitado para o array:

   int tam_array = nomes.length;

Lembre-se: arrays são objetos. Se forem passados como parâmetros para algum método, a passagem é sempre por referência (igual a qualquer outro objeto).

Detalhe importante: se for declarado um array de objetos, cada elemento deverá ser instanciado separadamente. Por exemplo, imagine que queremos declarar um array para armazenar 20 instâncias da classe Pessoa:

   Pesssoa funcs[] = new Pessoa[20];

   funcs[0] = new Pessoa("Eduardo", 19, 'M');
   funcs[1] = new Pessoa("Debora", 23, 'F');
   ...
   funcs[19]= new Pessoa("Zé", 30, 'M');

Se esquecermos de fazer isso, cada objeto armazenará uma referência nula: o valor null. De uma forma geral, todo objeto (não apenas em arrays) não inicializado armazena null.

2. Diálogos: interagindo com o usuário

Até agora utilizamos o método System.out.println para escrever informações na tela. Porém, vimos que esta prática não é 100% portável, pois há sistemas que não dispoem de um console de texto. A linguagem Java oferece diversas formas de interação com o usuário, a grande maioria em janelas. Para evitar a criação de uma interface completa, pode-se utilizar as chamadas caixas de diálogo.

Se olharmos com atenção na documentação da API, observaremos que as classes estão agrupadas em pacotes (packages). Os pacotes servem para reunir um conjunto de classes com função semelhante. Então, se quisermos utilizar uma classe específica, devemos informar ao compilador Java onde (em qual pacote) essa classe deve ser encontrada.

A classe que implementa as caixas de diálogo, JOptionPane, se encontra no pacote javax.swing, que contém diversas outras classes para interface com o usuário. Para utilizar essa classe, utiliza-se o comando import:

import javax.swing.JOptionPane;

Obs: algumas classes como String, System, Integer e outras são parte de um pacote especial, denominado java.lang. Esse pacote nunca precisa ser importado, pois são as classes primitivas que compõem a linguagem Java.

A classe JOptionPane oferece diversos métodos, para criar diversos tipos de caixas de diálogo. Por exemplo, se quisermos exibir uma caixa de mensagem para informar o usuário, usamos o método showMessageDialog(...):

import javax.swing.JOptionPane;

public class TestaDialogo
{
   public static void main(String args[])
   {
      JOptionPane.showMessageDialog(null,"Este é um diálogo simples");
      System.exit(0);
   }
}

O primeiro parâmetro por enquanto deve ser null. Repare que o método showMessageDialog(...) é um método estático (de classe) de JOptionPane! Por esse motivo, não é necessário instanciar objetos a partir de JOptionPane. Observe também a chamada para o método System.exit(0): este método é geralmente utilizado para encerrar um programa que utilize interface gráfica.

Há uma outra forma de chamada para o método showMessageDialog, a qual permite melhorarmos o visual da caixa de mensagem:

JOptionPane.showMessageDialog(null,"Esta é uma mensagem","Atenção",
    JOptionPane.WARNING_MESSAGE);

O terceiro parâmetro é o título que será exibido na janela (ao invés de "Message")

O quarto parâmetro controla o ícone apresentado à esquerda da janela:

• JOptionPane.PLAIN_MESSAGE - nenhum ícone
• JOptionPane.ERROR_MESSAGE - ícone de erro
• JOptionPane.INFORMATION_MESSAGE - ícone de informação
• JOptionPane.WARNING_MESSAGE - ícone de aviso
• JOptionPane.QUESTION_MESSAGE - ícone de interrogação

Existe um método para exibir uma caixa de entrada: showInputDialog. Esse método retorna sempre a String que foi digitada pelo usuário. Exemplo:

import javax.swing.JOptionPane;

public class TestaDialogo
{
   public static void main(String args[])
   {
      String nome;
      nome = JOptionPane.showInputDialog("Digite o seu nome");
      JOptionPane.showMessageDialog(null,"Seu nome é "+nome);
      System.exit(0);
   }
}

Assim como no método showMessageDialog, há uma variação mais completa:

nome = JOptionPane.showInputDialog(null,"Por favor, digite o seu nome","Atenção",
    JOptionPane.WARNING_MESSAGE);

Se você estiver curioso, consulte a documentação. Há MUITAS outras variações, tanto para entrada como para saída.

Você deve estar se perguntando: mas eu vou fazer programas baseados somente em caixas de diálogo ? Isso não é meio chato para o usuário ? Sim, com certeza! A interação baseada em diálogos é útil quando queremos informar o usuário de uma situação urgente ou quando se deseja chamar a atenção, mas não deve ser utilizada excessivamente.

Normalmente o que temos é uma interface gráfica o tempo todo na tela, na forma de uma ou mais janelas com diversos componentes, como botões, listas, etc. Como ainda é cedo para fazermos isso, está disponível uma classe para exibição de mensagens na tela, denominada JanelaBasica. Esta classe apresenta simplesmente uma janela onde existe uma área de texto, com o objetivo de substituir o console.

Para utilizá-la, primeiramente copie o arquivo JanelaBasica.java para o diretório onde estão as classes do seu projeto atual. Se você quiser olhar este arquivo, fique à vontade. Note que não serão dadas explicações sobre o conteúdo deste arquivo, pelo menos por enquanto. Coisas da vida, mas é para o bem de vocês.

A utilização é extremamente simples: crie uma instância de JanelaBasica, utilizando o seguinte construtor:

 JanelaBasica tela = new JanelaBasica("Título");

O primeiro parâmetro é o título da janela que será exibida. A classe oferece dois métodos para a exibição de mensagens: print(...) e println(...), cujas utilizações são óbvias...

Exemplo: criaremos um programa super-útil para somar dois números. A entrada de dados será realizada através de caixas de diálogo.

import javax.swing.JOptionPane;

public class Soma
{
   public static void main(String args[])
   {
      String str_num1,str_num2;
      int num1,num2;
      JanelaBasica tela = new JanelaBasica("Soma");
      str_num1 = JOptionPane.showInputDialog("Digite um número");
      str_num2 = JOptionPane.showInputDialog("Digite outro número");
      num1 = Integer.parseInt(str_num1);
      num2 = Integer.parseInt(str_num2);
      tela.println("A soma é: "+(num1+num2));
   }
}

O aluno(a) mais atento(a) irá notar o desaparecimento da chamada System.exit(0). Há um bom motivo: como estamos utilizando uma janela gráfica não modal, isto é, que permanece o tempo todo na tela, a única forma de encerrar o programa é fechando-se a janela. Se houvesse a chamada para exit(0) no final do programa, não seria possível enxergar a resposta a tempo.