98
Aprendendo Java www.athanazio.com Hamilton Lima [email protected]

Aprendendo Java

Embed Size (px)

Citation preview

Page 1: Aprendendo Java

Aprendendo Java

www.athanazio.com

Hamilton Lima [email protected]

Page 2: Aprendendo Java

versão de 25 jul 2003

Página 2

Page 3: Aprendendo Java

Índice geralconceitos básicos...................................................................................................................... 7

Configuração do ambiente.................................................................................................... 8instalando e configurando................................................................................................. 8

testando o ambiente............................................................................................................. 8Entendendo a linguagem.................................................................................................... 10

Como funciona o java ?.................................................................................................. 10características da linguagem.......................................................................................... 11

Iniciando a sintaxe.............................................................................................................. 12Entendendo o Ola mundo............................................................................................... 12

Elementos básicos da linguagem....................................................................................... 12regra para nome de identificadores................................................................................ 12palavras reservadas........................................................................................................ 12Comentários................................................................................................................... 13Tipos de dados e declaração de variáveis...................................................................... 13Operadores..................................................................................................................... 15

Estruturas de controle......................................................................................................... 16Interrompendo os fluxos de controle.............................................................................. 16se.................................................................................................................................... 17Variando......................................................................................................................... 18Enquanto........................................................................................................................ 19Caso............................................................................................................................... 19

Classes básicas.................................................................................................................. 21String............................................................................................................................... 21Classes para números.................................................................................................... 22

Vetores................................................................................................................................ 24Lista de exercícios.............................................................................................................. 27

Orientação aObjetos.................................................................................................................................... 29

Conceitos............................................................................................................................ 30Novas palavras, velhas idéias........................................................................................ 30

As novas palavras............................................................................................................... 30Classes........................................................................................................................... 30Atributos.......................................................................................................................... 30Métodos.......................................................................................................................... 30Encapsulamento............................................................................................................. 30Herança.......................................................................................................................... 30

Representando classes....................................................................................................... 31Introdução....................................................................................................................... 31Diagrama de classes...................................................................................................... 31Associação...................................................................................................................... 31Herança.......................................................................................................................... 32OO na prática................................................................................................................. 32

Usando Java........................................................................................................................... 33Classes e objetos................................................................................................................ 33

Page 4: Aprendendo Java

Melhorando as classes....................................................................................................... 34Construtores................................................................................................................... 34Sobrecarga..................................................................................................................... 34Controle de acesso......................................................................................................... 34Constantes...................................................................................................................... 35Elementos classe............................................................................................................ 35

Exercícios Capitulo 2............................................................................................................... 36Orientação a Objetos 2................................................................................................................................. 38

Mais OO.............................................................................................................................. 39Herança............................................................................................................................... 39Anulação............................................................................................................................. 39Verificação de tipo.............................................................................................................. 39

Molde de tipo.................................................................................................................. 39Classes sem objetos........................................................................................................... 41

Classes e métodos abstratos......................................................................................... 41Interfaces........................................................................................................................ 43

Organização da casa.............................................................................................................. 44criação de pacotes.............................................................................................................. 44

tratando erros.......................................................................................................................... 46Tratamento de erros........................................................................................................... 47

banco de dados....................................................................................................................... 49JDBC Conceitos ................................................................................................................. 50Usando JDBC..................................................................................................................... 51JDBC na veia...................................................................................................................... 51

Ola Mundo JDBC............................................................................................................ 51Mais funcionalidades...................................................................................................... 51

Interfaces com usuáriousando AWT........................................................................................................................... 52

Descrição da AWT.............................................................................................................. 53novos nomes....................................................................................................................... 54

Container........................................................................................................................ 54Components................................................................................................................... 54Gerentes de layout.......................................................................................................... 56

Como funciona um aplicação ............................................................................................. 57Gerentes de layout.............................................................................................................. 59

FlowLayout...................................................................................................................... 59BorderLayout.................................................................................................................. 61GridLayout...................................................................................................................... 63

Combinando gerentes de layout......................................................................................... 64Desenhando na tela............................................................................................................ 66Componentes visuais.......................................................................................................... 68Tratando Eventos................................................................................................................ 71

Como funciona ?............................................................................................................. 71Eventos de janelas.......................................................................................................... 74

Criando menus.................................................................................................................... 77exemplos de soluções............................................................................................................. 80

Capitulo 1, exercício 1......................................................................................................... 81

Página 4

Page 5: Aprendendo Java

Capitulo 1, exercício 2......................................................................................................... 83Capitulo 1, exercício 3......................................................................................................... 84Capitulo 1, exercício 4......................................................................................................... 85Capitulo 1, exercício 5......................................................................................................... 86Capitulo 1, exercício 6......................................................................................................... 87Capitulo 1, exercício 7......................................................................................................... 88Capitulo 1, exercício 8......................................................................................................... 89Capitulo 1, exercício 9......................................................................................................... 90Capitulo 1, exercício 10....................................................................................................... 92

exemplo de Aplicação MDI..................................................................................................... 94

Page 6: Aprendendo Java

Legenda

Dica ou granderecomendação

Não use software piratause software livre, este

indicará alternativas livresde software

Atividades extras,consultas, exercícios,

pesquisas

Indicação de problemascomuns, que devem ser

evitados

Controle de versões

25/07/2003 – adicionados instruções e exemplos de JDBC28/06/2003 – reunidos todos os documentos em um só30/10/2002 – criado novo documento “o início”11/10/2002 – revisão geral e migração de sgml para openoffice01/10/2002 – adicionado controle de eventos ActionEvent25/09/2002 – versão inicial, capítulo de AWT14/10/2001 – concluído Orientação a objetos 2 e Manipulação de arquivos08/10/2001 – conclusão de Orientação a objetos 1 e Orientação a objetos 2, até interfaces01/10/2001 – Orientação a objetos 1 melhorando as classes e lista de exercicios15/09/2001 – conclusão de Orientação a objetos 1 e remodelagem sem AWT21/07/2001 – Orientação a objetos 1

Feito com

Página 6

Page 7: Aprendendo Java

C O N C E I T O SC O N C E I T O SB Á S I C O SB Á S I C O S

Page 8: Aprendendo Java

Configuração do ambiente

instalando e configurandoPara usar os programas descritos nesta documentação você irá precisar do kit de desenvolvimento da linguagemJava. Existem alguns tipos destes kits, nós iremos usar inicialmente o J2SE (Java 2 Standard Edition)

Para obter o J2SE acesse http://java.sun.com/j2se/ e realize o download da última versão estável (versão estávelé a última que não estiver em testes, ou seja, no período de aprendizado não recomendamos versões alfa, beta,pré-release, etc ).

Após o download basta realizar a instalação seguindo os passos sugeridos pela instalação.

Apesar de na maioria das vezes não lermos os avisos de instaladores, é um bom hábito,fazê-lo, evitando assim que ações inesperadas ocorram durante a instalação, como porexemplo instalar um software em um disco rígido que está quase sem espaço.

Depois de instalado, precisaremos configurar uma variável de ambiente, para o funcionamento correto docompilador Java. Quando o compilador for executado o mesmo precisará saber onde encontrar as bibliotecas dalinguagem Java e possíveis bibliotecas criadas pelo programador.

A biblioteca Java é encontrada automaticamente, porém as desenvolvidas - precisamos indicar onde encontraratravés de definição da variável de ambiente CLASSPATH, esta variável define o caminho para encontrarclasses usadas por um programa, iremos configurar o nosso caminho de procura para o diretório atual, noPrompt do Ms-DOS com os seguintes comandos:

c:\>set CLASSPATH=. c:\> c:\>echo %CLASSPATH% . c:\>

configurando CLASSPATH

Nota: Observar que ao executar a linha acima do set CLASSPATH=. iremos definir a variávelde ambiente somente para a sessão do Ms-DOS que estiver aberta no momento. para garantir queesta configuração esteja disponível para todas as sessões do Ms-DOS que utilizarmos a linha dedefinição set CLASSPATH=. deverá ser incluída no final do arquivo autoexec.bat

Página 8

Page 9: Aprendendo Java

testando o ambientePara criar seu primeiro arquivo utilize qualquer editor de textos ASCII puro, por exemplo o bloco de notas dowindows (notepad.exe), ou o edit do DOS.

Crie uma arquivo conforme o exemplo abaixo :

class olamundo{ public static void main ( String args[] ){ System.out.println( "Olá mundo" ); } }

olamundo.java

Para salvar arquivos com extensão diferente de .txt no bloco de notas, será necessáriocolocar o nome do arquivo entre aspas, por exemplo: "olamundo.java"

Nosso teste de ambiente consistirá em compilar e executar o olamundo.java recém criado, no diretório ondefoi criado olamundo.java siga os comandos abaixo:

c:\>javac olamundo.java

c:\>java olamundo Ola mundo

c:\>

Compilando e executando um programa

Nota: javac olamundo.java realiza a compilação do arquivo fonte .java e cria umarquivo .class que será executado pelo comando java olamundo. Observar que ocompilador javac precisa que seja informada a extensão do arquivo, e o interpretador javanão, pois assume a extensão .class

Page 10: Aprendendo Java

Entendendo a linguagem

Como funciona o java ?Com a proposta de "write once, run anywhere" (programe uma vez, e execute em qualquer lugar) a linguagenjava tinha um desafio pela frente: como lidar com os diferentes sistemas operacionais (SO), e diversosambientes computacionais existentes ? A solução até poderia ser criar um compilador para cada ambiente egerar versões do programa para as diversas plataformas, mas isto iria gerar a dificuldade de manter estruturas dearquivos diferentes, formatos diferentes, fora o esforço para geração contínua de novos e novos arquivos...

Com esta necessidade surgiu a idéia de possuir uma camada intermediária entre o SO e o programa em java aser executado, esta camada chama-se Java Virtual Machine, a imagem abaixo mostra sue funcionamento

Ilustração 1 vistual machine

A Virtual Machine garante o funcionamento de programas Java em diversas plataformas, desde servidorescorporativos a dispositivos portáteis. Isto permite uma flexibilidade e economia enorme, pois torna possível"write once, run anywhere".

Página 10

Page 11: Aprendendo Java

A criação de um programa Java™ pode ser dividida em 3 etapas:

etapa 1. codificação do programa em um arquivo .java

etapa 2. compilação do programa usando javac nomearquivo.javaetapa 3. execução do bytecode, que é o arquivo .class usando java nomearquivo

características da linguagemQualificando a linguagem Java™ podemos citar as seguintes características:

Simples

Independente de Plataforma

Orientada a Objetos

Distribuída

Robusta

"Multithreaded"

segura

A Linguagem Java™ possui uma grande diversidade de recursos:

Recursos essenciais de uma linguagem - Objetos, Strings, Threads, data e hora, estruturas de controle,armazenamento de dados, entrada e saída, etc ...

Applets - criação de aplicações embutidas em páginas html que são executadas no cliente

Recursos de Rede - comunicação via TCP/IP, UDP, etc ...

Componentes de Software - chamados JavaBeans

Java Database Connectivity (JDBC™) - Conexão a praticamente todos bancos de dados do mercado

Page 12: Aprendendo Java

Iniciando a sintaxe

Entendendo o Ola mundo

Código fonte Explicaçãoclass olamundo define o nome da classe, observar que todo programa

em java é uma classe, e que o nome da classe deve sero mesmo nome do arquivo

Os elementos da classe em questão estão delimitadospelas chaves "{..}"

public static void main(String args[]) Cria o método main da aplicação java, osqualificadores antes do nome main serão discutidosem lições posteriores.

String args[] Todo método main deve estar pronto para receber osparâmetros da linha de comando que o executou, destaforma é criado um vetor de String chamado args quecontém os parâmetros recebidos na execução doprograma

System.out.println( "Olá mundo" ); o método println, é um procedimento da ClasseSystem, e exibe os parâmetros que recebe na saídapadrão do ambiente de execução java em questão

Elementos básicos da linguagem

regra para nome de identificadores Permite letras e números

Começa com uma letra "$" ou "_"

Possui tamanho ilimitado

Não pode ser uma das palavras reservadas

É "Case sensitive" , diferencia maiúsculas de minúsculas

palavras reservadasabstract - boolean - break - byte - case - catch - char - class - const - continue - default - do - double - else -extends - final - finally - float - for - goto - if - implements - import - instanceof - int - interface - long - native -new - null - package - private - protected - public - return - short - static - super - switch - synchronized - this -throw - throws - transient - try - void - volatile - while

Página 12

Page 13: Aprendendo Java

ComentáriosExistem 3 tipos de comentários na linguagem Java

Comentário de bloco "/*...*/"

Comentário na linha"//"

Comentário de bloco com documentação "/**...*/"

/** * Titulo: comentado.java * Descrição: ilustra comentários na linguagem java * @author Hamilton Lima Jr [email protected] * @version 0.0 * */

class comentado{

// main é chamada automaticamente ... public static void main ( String args[] ) { /* esta é uma versão do olamundo.java elterada para exibir comentários

System.out.println( "Olá mundo" ); */

System.out.println( "Eu tenho comentários" ); // exibe a mensagem }}

comentado.java

Tipos de dados e declaração de variáveisAs variáveis em Java, ou são de algum tipo primitivo ou são um objeto, os tipos primitivos são :

Inteiros - byte, short, int, long

Ponto flutuante - float, double

Caracter - char ( "a" "\n" "\u001B" )

Boleano - boolean (true ou false)

Page 14: Aprendendo Java

A declaração das variáveis é realizada usando o formato : tipo variável

Os literais das variáveis ponto flutuante devem possuir um F ou um D após o valor para indicar se o mesmotrata-se de um double ou de um float. por default serão sempre double, logo para atribuir um literal para umvariável float deve-se informar que o mesmo é um float com o sufixo F após o número.

/** * Titulo: variaveis.java * Descrição: ilustra declaracoes de variaveis * @author Hamilton Lima Jr [email protected] * @version 0.0 * */

class variaveis{

// main é chamada automaticamente ... public static void main ( String args[] ) { int Quantidade = 123; System.out.println( "Quantidade = " + Quantidade );

char Letra = 'A'; char LetraQualquer = Letra;

// um valor com casas decimais por default é double double MaiorValor = 60000.45;

// logo para usa-lo em um float é necessário indicar com o F float Valor = 2546.34F; float OutroValor = 1500;

System.out.println( "Valor = " + Valor );

boolean Permitido = false; System.out.println( "Permitido = " + Permitido );

}}

variaveis.java

Página 14

Page 15: Aprendendo Java

Operadores igual "=="

diferente "!="

atribuição "="

Maior ">"

Menor "<"

Maior ou igual ">="

Menor ou igual "<="

E "&"

OU "|"

Negação "!"

E otimizado "&&"

OU otimizado"||"

Aritméticos padrão "+" "-" "*" "/"

Aritméticos Unários "+=" "-=" "*=" "/="

Incremento unário "++"

Decremento unário "--"

Resto da divisão "%"

Veja o exemplo abaixo que demonstra o uso dos operadores.

/** * Titulo: variaveis.java * Descrição: ilustra operadores * @author Hamilton Lima Jr [email protected] * @version 0.0 * */class operadores{

public static void main ( String args[] ) { int numero = 10; boolean falso = false & ( numero++ < 200 ); System.out.println( "AND & normal - numero = " + numero );

numero = 10; falso = false && ( numero++ < 200 ); System.out.println( "AND && otimizado - numero = " + numero );

float valor /= 10; /* a legibilidade desta operador não é das melhores seria melhor : valor = valor / 10

Page 16: Aprendendo Java

*/ valor /= 2; System.out.println( "/= valor " + valor );

int resto = 10 % 3; System.out.println( "% resto da divisão inteira " + resto );

}}

operadores.java

Nota: Os operadores lógicos otimizados, devem ser usados com especial cuidado pois funcionamda seguinte maneira: o "&&" AND ao encontrar algum item da expressão com valor falso, nãoexecuta o resto da expressão, e o OR "||" ao encontrar algum elemento da expressão que sejaverdadeiro não executa o resto da expressão.

Estruturas de controleNota: Todas as estruturas de controle executam blocos de código, que são delimitados pelaschaves "{..}", identificadores criados dentro de um bloco possuem escopo somente para o referidobloco.

Interrompendo os fluxos de controle• return - interrompe a execução do método em questão retornando o controle para o método chamador

• break - interrompe a execução do fluxo atual saindo para a linha de comando imediatamente posteriorao final do bloco de execução

• continue - desvia a execução do programa para o início do bloco de execução, evitando a execuçãodos trechos posteriores a chamada do continue

Página 16

Page 17: Aprendendo Java

seo exemplo a seguir ilustra as possíveis maneiras de utilizar o if em java, vale ressaltar que a expressão dacondição deve possuir um resultado boleano

/** * Titulo: variaveis.java * Descrição: ilustra uso do ife do else * @author Hamilton Lima Jr [email protected] * @version 0.0 * */class se{

public static void main ( String args[] ) { int numero = 10;

if ( numero >= 5 ) System.out.println( "maior ou igual " + numero );

// esta forma oferece maior legibilidade if ( numero >= 5 ) { System.out.println( "maior ou igual " + numero ); }

char A = 'A'; char B = 'B';

if ( A == B ) { System.out.println( A + " igual a B " + B ); } else { System.out.println( A + " diferente de " + B ); }

}}

se.java

Page 18: Aprendendo Java

VariandoO variando é dividido em 3 partes:

inicialização da variável de controle - também pode ser realizada a declaração da mesma

Condição de parada - exepressão que deve retornar um valor booleano

modificação1 da variável de controle - pode ser pós ou pré-fixado, ou ainda ser uma expressão

/** * Titulo: variaveis.java * Descrição: ilustra uso do for * @author Hamilton Lima Jr [email protected] * @version 0.0 * */

class variando{

public static void main ( String args[] ) { int limite = 10;

for ( int n = 1 ; n <= limite ; n ++ ) { System.out.println( n ); }

long fatorial = 1; int quantidade = 18;

for ( int n = 1 ; n <= quantidade ; n ++ ) { fatorial *= n; }

System.out.println( quantidade + "! = " + fatorial );

}}

variando.java

1 Observar que não é um incremento, pois em alguns casos esta expressão de modificação realizadecrementos, nos casos em que o for precisa que a varável de controle possua valores decrementais

Página 18

Page 19: Aprendendo Java

Enquanto

Utilizado normalmente quando precisamos executar um bloco e não podemos determinar com antecedência aquantidade de vezes, pois a quantidade irá depender de resultados da execução do bloco

/** * Titulo: variaveis.java * Descrição: ilustra uso do while * @author Hamilton Lima Jr [email protected] * @version 0.0 * */

class enquanto{

public static void main ( String args[] ) { boolean condicao = true; int n = 1; int limite = 20;

while ( condicao ) { System.out.print( n + " " ); n ++;

if ( n > limite ) { condicao = false; } }

System.out.println( "\n---" ); n = 1;

while ( ! ( n > limite ) ) { System.out.print( n + " " ); n ++; }

}}

enquanto.java

Casoo switch avalia uma expressão com resultado inteiro, logo pode ser usado para avalizar um char, podendocomparar tanto com o literal char quanto com o literal inteiro - no caso do literal inteiro será usado paracomparação com o valor da tabela ASCII do caracter

Caso o break não seja usado o switch continua avaliando as próximas condições .

Page 20: Aprendendo Java

/** * Titulo: variaveis.java * Descrição: ilustra uso do switch * @author Hamilton Lima Jr [email protected] * @version 0.0 * */

class caso{

public static void main ( String args[] ) { int mes = 8; String NomeMes;

switch ( mes ) { case 1: NomeMes = "Janeiro"; break; case 2: NomeMes = "Fevereiro"; break; case 3: NomeMes = "Março"; break; case 4: NomeMes = "Abril"; break; case 5: NomeMes = "Maio"; break; case 6: NomeMes = "Junho"; break; case 7: NomeMes = "Julho"; break; case 8: NomeMes = "Agosto"; break; case 9: NomeMes = "Setembro"; break; case 10: NomeMes = "Outubro"; break; case 11: NomeMes = "Novembro"; break; case 12: NomeMes = "Dezembro"; break; case 32: NomeMes = "Espaço"; break;

default: NomeMes = "Mes inválido"; break; }

System.out.println( "Mes " + mes + " = " + NomeMes );

char letra = 'B'; String msg ;

switch ( letra ) { case 'A': msg = "a letra A"; break; case 'B': msg = "b é a segunda"; break; case 'C': msg = "c é o começo de começo"; break;

default: msg = "não encontrado"; }

System.out.println( msg );

}}

caso.java

Página 20

Page 21: Aprendendo Java

Classes básicas

StringString em java, é uma classe, portanto possui métodos e atributos. Uma característica interessante das strings emjava, é que um literal string também é um objeto ! Logo podemos realizar construções como "João".length()

A comparação de strings deve ser realizada usando o método equals, pois quando comparamos duas stringsusando "==" estamos na verdade comparando endereços de memória onde objetos estão instanciados. Quandorealizamos a atribuição de um valor literal string para uma variável string, a virtual machine java (VM) cria umainstância de uma string para aquele literal. Na próxima vez que este literal for usado, a VM irá procurar por umainstância já existente. Existindo uma, irá utilizar a mesma atribuindo um endereço de memória já existente.Portanto na comparação de variáveis como nome1 e nome2 (no exemplo abaixo) usando == , o resultado é true.

/** * Titulo: variaveis.java * Descrição: ilustra uso da classe String * @author Hamilton Lima Jr [email protected] * @version 0.0 * */

class texto{ public static void main ( String args[] ) { String nome1 = "João"; String nome2 = "João"; String nome3 = new String( "João" ) ;

if ( nome1 == nome2 ) System.out.println( "nome1 igual nome2" );

else System.out.println( "nome1 diferente nome2" );

if ( nome1 == nome3 ) System.out.println( "nome1 igual nome3" ); else System.out.println( "nome1 diferente nome3" );

if ( nome1.equals( nome2 ) ) System.out.println( "nome1 equals nome2" );

if ( "João".equals( nome2 ) ) System.out.println( "João equals nome2" );

if ( "João" == nome2 ) System.out.println( "João == nome2" );

System.out.println( "comprimento " + "João".length() ); System.out.println( "substr(0,2) = " + "João".substring(0,2) ); System.out.println( "substr(0,2) = " + nome3.substring(0,2) );

Page 22: Aprendendo Java

System.out.println( String.valueOf( Math.PI ).substring(0,7) ); System.out.println(

new Float( 15.43384786F ).toString().substring(0,4) ); }}

texto.java

A Conversão de outros tipos de dados para String pode ser realizada usando o método toString() que éherdado por todas as classes da superclasse Object, ou usando o método valueOf da classe String.

System.out.println( String.valueOf( Math.PI ).substring(0,7) );System.out.println( new Float( 15.43384786F ).toString().substring(0,4) );

Classes para númerosPara cada tipo primitivo existe uma classe equivalente para permitir o manuseio dos dados primitivos. Merecemespecial destaque as classes para manipulação de valores int e float, que são respctivamente as classesInteger e Float (atenção nas letras maiúsculas). Diferentemente da classe string, estas precisam serinstanciadas para serem usadas, logo, para usar uma classe como esta é necessário o operador new, o exemploabaixo exibe diversos usos destas classes:

/** * Titulo: variaveis.java * Descrição: ilustra uso daa conversao de tipos numericos * @author Hamilton Lima Jr [email protected] * @version 0.0 * */

class numeros{ public static void main ( String args[] ) { int numeroi = Integer.parseInt("45"); float numerof = Float.parseFloat("45.23F"); double numerod = Double.parseDouble("50.23F");

Float oFloat = new Float( numerof ); Integer oInteger = new Integer( numeroi );

numeroi = (int) numerof; System.out.println( "float para int = " + numeroi );

numeroi = oFloat.intValue(); System.out.println( "Float para int = " + numeroi );

numeroi = (int) numerod; System.out.println( "double para int = " + numeroi );

numerof = (float) numeroi; System.out.println( "int para float = " + numerof );

Página 22

Page 23: Aprendendo Java

numerof = oInteger.floatValue(); System.out.println( "Integer para float = " + numerof );

}}

numeros.java

Para gerar números formatados use a classe NumberFormat, e o métodosetMinimumFractionDigits(), por exemplo que determina o número minimo decasas decimais a serem exibidas veja o exemplo abaixo do uso da classeNumberFormat

Page 24: Aprendendo Java

/** * Titulo: FormatoNumerico.java * Descrição: ilustra uso da formatação de números * @author Hamilton Lima Jr [email protected] * @version 0.0 * */

class FormatoNumerico {

public static void main ( String args[] ){

double numero = 10.456789;

java.text.NumberFormat nf = java.text.NumberFormat.getInstance(); nf.setMinimumFractionDigits(2); nf.setMinimumIntegerDigits(2);

System.out.println( "Pi " + nf.format( Math.PI ) ); System.out.println( "10.456789 " + nf.format( numero ) );

nf.setMinimumFractionDigits(5); System.out.println( "Pi (5) " + nf.format( Math.PI ) ); }}

FormatoNumerico.java

VetoresMerece destaque o fato de que o primeiro elemento de um array em Java é o zero.

A declaração de vetores é realizada com o uso de colchetes "[ ]". A declaração consiste em adicionar nadeclaração da variável os colchetes, podendo ser antes ou depois do nome da variável.

int [] vetorInteiros; int NovovetorInteiros [];

O vetor em java possui um tamanho definido, a definição deste tamanho é realizada na inicialização do vetor.Esta pode ocorrer no momento da declaração ou posteriormente.

Podemos usar o formato onde informamos o tipo de dados e o tamanho entre colchetes, ou informamos osvalores dos elementos do vetor entre chaves, e separados por vírgulas. A quantidade de elementos do vetor serádefinida pela quantidade de elementos informados entre chaves, veja nos exemplos abaixo:

Página 24

Page 25: Aprendendo Java

int vetorInteiros [] ; int NovovetorInteiros [] = { 1, 3, 4 }; // três elementos;

vetorInteiros = new int[10];

Nota: Observar que a inicialização de vetores usando os valores entre chaves somente pode serusado na declaração do vetor

Vetores de objetos, possuem particularidade, além de definir os elementos e informar o tamanho do vetor, énecessário instanciar cada objeto nas respectivas posições do vetor, pois ao definir o tamanho do mesmo,somente reservamos espaço na memória para comportar os objetos.

Vetores multidimensionais são declarados usando mais de um par de colchetes, podendo no momento deinstanciar o objeto vetor, informar o tamanho das diversas dimensões. Ou informar uma e as subdimensõesinformar posteriormente.

Para inicializar com valores os elementos de um vetor multidimensional, basta a cada elemento dentro daschaves colocar outros elementos dentro de chaves.

O exemplo abaixo mostra diversos usos de vetores, inclusive ressalta o fato que a main recebe as lista deparâmetros da execução em um vetor de Strings, e que o tamanho de um vetor pode ser obtido através doatributo length.

/** * Titulo: vetores.java * Descrição: ilustra uso daa conversao de tipos numericos * @author Hamilton Lima Jr [email protected] * @version 0.0 * */

import java.text.*;

class vetores{ public static void main ( String args [] ) { // recebe parametros da linha de comando // em args Float parametros [] = new Float [ args.length ]; for ( int n = 0 ; n < args.length; n ++ ) { parametros[ n ] = new Float( args[n] ); }

int vetorInteiros [] ; int NovovetorInteiros [] = { 1, 3, 4 }; // três elementos;

vetorInteiros = new int[10];

System.out.println( vetorInteiros [1] ); System.out.println( NovovetorInteiros [1] );

// este new somente declara um VETOR de Float não um objeto Float Float [] valores = new Float[4];

Page 26: Aprendendo Java

valores[0] = new Float( 10.24 ); valores[1] = new Float( 11.35 ); valores[2] = new Float( 12.56 ); valores[3] = new Float( 0.1 );

System.out.println( "tamanho = " + valores.length );

NumberFormat nf = NumberFormat.getInstance(); nf.setMaximumFractionDigits( 2 ); nf.setMinimumFractionDigits( 2 );

for ( int n = 0; n < valores.length ; n ++ ) { System.out.println( "valor + 70% = " + (valores[n].floatValue() * 1.7) );

float valorf = valores[n].floatValue() * 1.7F; System.out.println( "valor + 70% = " + nf.format(valorf) ); }

String nomes [][] = { {"Laranja", "Abóbora", "Alface"}, {"Maria", "João" }, {"10", "12", "12", "23"} };

for( int n = 0; n < nomes.length; n ++ ){ for( int m = 0; m < nomes[n].length; m ++ ){ System.out.println( "nomes[" + n + "][" + m +

"] = " + nomes[n][m] ); } }

}}

vetores.java

Chateado com a limitação de arrays possuirem tamanho fixo ? use a classe java.util.Vector, e seja feliz

Página 26

Page 27: Aprendendo Java

Lista de exercícios

1. Receba 3 números como parâmetro, exiba o maior o menor e o do meio

2. Receba uma frase como parâmetro (a frase deve ser digitada entre aspas) e informe o número de palavras quea frase contém.

3. Declare um vetor contendo 10 Strings, realize a inversão deste vetor - colocando o elemento 10 como 1, o 9como 2 e assim por diante, e após isto exiba o conteúdo do vetor invertido

4. Receba uma lista de números como parâmetro, após isto exiba a média dos números recebidos - independenteda quantidade de números

5. Exiba na tela a tabela ASCII, exibindo o número do caracter e o seu respectivo caracter - exibir de 1 a 255

6. Crie um vetor multidimensional de objetos, que possua duas dimensões, na primeira adicione um vetor destrings com os nomes dos funcionários, na segunda um vetor de Float com os salários dos funcionários

Receba como parâmetro o percentual de aumento salarial a ser aplicado para cada funcionário, após istoexiba na tela os nomes dos funcionários acompanhado do salário atualizado pelo índice recebido

7. Crie uma calculadora que funcione através da linha de comando, esta calculadora deve receber comandosaritméticos semelhantes a linguagem cobol, após receber cada comando deve realizar o cálculo e exibir oresultado

MULTIPLY A BY BDIVIDE A BY BADD A TO BSUBTRACT A FROM B

8. Receba um nome como parâmetro e indique quantas vogais e quantas consoantes contém o nome, e a vogalque mais ocorreu

9. Crie uma calculadora de minutos que receba a hora inicial a a hora final e exiba a quantidade de minutosentre os dois horários - receba os parâmetros no seguinte formato HH:MM HH:MM, onde HH significa hora eMM os minutos

10. Receba o número do mês e o ano, e após isto exiba o calendário para o mês e ano solicitado no seguinteformato:

Page 28: Aprendendo Java

c:\>java calendario 08 2001

Agosto 2001

Dom Seg Ter Qua Qui Sex Sab 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

c:\>

Use a classe GregorianCalendar, mas cuidado com a representação de meses,pois nesta classe começa com ZERO !

Página 28

Page 29: Aprendendo Java

C O N C E I T O S D EC O N C E I T O S D EO R I E N T A Ç Ã O AO R I E N T A Ç Ã O A

O B J E T O SO B J E T O S

Conceitos

Novas palavras, velhas idéiasQuando falamos sobre Orientação a Objetos ( OO ), pensamos logo em algo complexo Obscuro, e as vezesbeirando o mágico - os que conhecem esta tecnologia acabam se assemelhando a magos ... Mas na verdade aidéia não é nova, muito menos original, é somente um aperfeicoamento natural da idéia de "Reaproveitamentode código", da idéia de "Escreva uma vez, e só uma mesmo".

Reaproveitamento de código é um desafio antigo. Criávamos bibliotecas de código, modelos de trabalho,"receitas de bolo", entre outras coisas. Até que funcionava, porém às vezes não.

O conceito mais importante em OO, é entender que se trata de uma metodologia. Se desejamos colher seusfrutos, devemos planejar mais do que já fazemos, porque senão, a única mudança que teremos é uma nova etrabalhosa sintaxe - que não nos oferece muito.

As novas palavras

ClassesClasses - este termo em OO, significa a unidade básica de todo o planejamento, de toda organização em objetos.Uma classe é um modelo para um objeto, a partir da definição de uma classe, podemos gerar, trazer a existênciadiversos objetos - como a raça humana, todos da "classe ser humano". Apesar de serem da mesma classe sãoindivíduos separados, com algumas características próprias.

AtributosA estas características que mudam de indivíduo para indivíduo, chamamos "Atributos". São as informações queo plano de um objeto - uma classe – possui, determinando que informaçãoes o objeto necessitará paradeterminar seu comportamento e relacionamento com outros objetos.

MétodosO comportamento de um objeto, está na definição de seus "Métodos" que são na verdade onde residem aprogramação de fato - onde as estruturas de controle aparecem. São blocos de código, que utilizam os atributosdo objeto para realizarem seus objetivos, e às vezes recebem informações do mundo externo - parâmetros -

Page 30: Aprendendo Java

quando os atributos da classe não são suficientes para a realização de suas atividades.

Considerando a classe seuhumano e o método informarIidade(), consideramos os seguintes fatos: Não precisoinformar a você a data do seu nascimento para que você me diga sua idade ! Esta informação - a data denascimento - já é um atributo seu. Porém se pergunto se vc poderia me emprestar algum dinheiro, preciso passarcomo parâmetro para este método o valor desejado, para que a resposta possa acontecer corretamente.

EncapsulamentoUm conceito vital de OO, é o "Encapsulamento" . Ele determina que os atributos de uma classe devem serprivativos dela, garantindo assim a confiabilidade das informações registradas ali. Para tal são necessáriosmétodos de leitura e de gravação para os atributos que precisam ser acessados por outros objetos.

HerançaCoroando OO, vem o conceito de "Herança" que determina que classes podem herdar características de outras,permitindo que comportamentos que já estão definidos em uma classe não precisem ser redefinidos em outrasclasses, basta criar entre elas um relacionamento de herança, para as chamadas subclasses - isto não as tornamenos importantes, somente determina o sentido da herança - utilizarem as definições realizadas nas chamadassuperclasses .

Representando classes

IntroduçãoIremos utilizar como exemplo para nosso estudo de representação de classes, uma aplicação para automatizaruma loja de animais.

Todos os diagramas usados nos exemplos foram criados e exportados como gif usando a ferramenta Argo-UML,que é um projeto open-source desenvolvido em java, foi usada a versão 0.8.1

Diagrama de classesFigura 2-1. Uma Classe

Ilustração 2exemplo de uma classe

A representação de uma classe é feita através de um retângulo dividido em três partes horizontais

• Nome da classe

• Lista de atributos

Página 30

Page 31: Aprendendo Java

• Lista de métodos

Para cada um dos itens da classe podemos informar a sua "Visibilidade" que indica como o atributo ou métododa classe será acessado por outras classes

• (-) Privativo - representado por um hífen antes do nome do item, e somente a própria classe tem acesso

• (+) Publico - representado por um + antes do nome do item, e todas classes tem acesso

• (#) Protegido - representado por um # antes do nome do item, e todas subclasses tem acesso

AssociaçãoFigura 2-2. Associações

Ilustração 3associação de classes

As associações entre as classes são representadas por linhas que interligam os retângulos das classes, Além dalinha que estabelece o relacionamento ainda temos a informação da "cardinalidade" que informa as quatidadespossíveis para o relacionamento, e por fim o nome do relacionamento que fica escrito próximo da linha

Podemos ter dois níveis de leitura para um diagrama de classes, a leitura objetiva e a subjetiva

Leitura objetiva

• um Animal se alimenta de uma ou várias Dietas

• uma Dieta pode alimentar vários Animais ou nenhum

• Nem toda dieta serve a um Animal

• Podemos informar Dietas antes mesmo que um animal vá se alimentar dela

Leitura subjetiva, ou conclusões práticas

• Nem toda dieta serve a um Animal

• Podemos informar Dietas antes mesmo que um animal vá se alimentar dela

• Sempre que informar-mos um animal sua dieta deve ser informada antes

Page 32: Aprendendo Java

HerançaA herança em um diagrama de classes é representada através de uma linha que une as duas classes, a superclasseé indicada por um triângulo que é exibido próximo da referida classe conforme vemos no exemplo abaixo, Ondeas classes Passaro e Peixe são subclasses de Animal, e Animal é superclasse de de Passaro e Peixe

Figura 2-3. Herança

Ilustração 4herança

Página 32

Page 33: Aprendendo Java

U S A N D O J A V AU S A N D O J A V A

Classes e objetosAo criar uma instância de uma classe, criamos um objeto para usarmos os métodos definidos na classe, oexemplo a seguir demonstra isto

Exemplo 2-1. Instanciando classes

public class MeuObjeto {

private String nome;

public MeuObjeto( String nome ) { this.nome = nome; }

public String getNomeSeparado() { String retorno = "";

for (int i = 0; i < nome.length(); i++) { retorno += nome.charAt(i) + " "; }

return retorno; }

}

MeuObjeto.java

public class AppObjeto { public static void main(String[] args) {

MeuObjeto o = new MeuObjeto("José");

MeuObjeto lista[] = { new MeuObjeto("Ana"), new MeuObjeto("João"), new MeuObjeto("Maria") };

for (int i = 0; i < lista.length; i++) { System.out.println( lista[i].getNomeSeparado() ); }

}

AppObjeto.java

Page 34: Aprendendo Java

auto referência da classe, para fazer referência a instância atual da classe, usamos a palavra reservada "this" quepermite por exemplo em um método receber um parâmetro com o mesmo nome de uma atributo, e ser realizadaa referência ao atributo usando :

public class Exemplo {

private String nome;

public MeuObjeto( String nome ) { this.nome = nome; }

}

todos os atributos possuem escopo dentro do bloco onde foi declarado, se declarado na classe possuirá escopoda classe, se declarado dentro de um "for" somente estará visível dentro do bloco do "for"

Melhorando as classes

Construtorescontrutores, são métodos criados nas classes visando preparar o ambiente para o uso da classe, inicializandoatributos, executando métodos necessários para o início do trabalho

um método construtor possui o mesmo nome da classe e não possui tipo de retorno, pois na verdade quando oconstrutor é usado pelo operador "new" o retorno será a instância, portanto não sendo necessário identificar otipo de retorno

Sobrecargapor vezes desejamos usar um método com o mesmo nome porém com parâmetros diferentes na sua chamada, aisto chamamos sobrecarga de métodos, para realizar, basta declarar os métodos com o mesmo nome eparâmetros diferentes. No momento da chamada ao método basta passar os parâmetros no tipo e quantidadedefinidos em uma das declarações de métodos

Dica: A sobrecarga também pode ser utilizada para construtores realizando assim a sobrecargade construtores

Controle de acessoa visibilidade determina como será o relacionamento da classe com os outras classes, observar que estesqualificadores podem ser usados para qualquer elemento, seja uma classe, um método ou um atributo

• private - somente a própria classe tem acesso

• public - todas classes tem acesso

• protected - somente as subclasses tem acesso

ConstantesPara definir valores constantes, basta adicionar a palavra reservada "final" após a definição da visibilidade e

Página 34

Page 35: Aprendendo Java

antes do tipo de dado do atributo ou do método

Tabela 2-2. Descrição do uso do final

Elemento Descrição

Atributo impede que o valor atribuido na declaração seja alterado, usualmente são declaradoscom nome todo em maiúsculas

Método não permite que subclasses sobreescrevam o método, garantindo para toda a hierarquiade classes uma determinada forma de implementação

Classe não permite que hajam subclasses desta classe, impedindo desta forma que a herançaocorra

Elementos classepor vezes desejamos usar métodos ou ainda atributos de classes sem ter que realizar um instância, isto épromovido através do uso da palavra reservada "static" que define atributos e métodos classe, usando o exemploabaixo para acessar o valor do indice bastaria usar "Salario.INDICE"

public class Salario {

private float Salario = 0;

public static final float INDICE = 3.56F;

public static float Calculo( float Salario ) { return Salario * INDICE; }

Salario( float Salario ) { this.Salario = Salario; }

Salario( String Salario ) { this.Salario = Float.parseFloat( Salario ); }

}

Salario.java

Page 36: Aprendendo Java

Lista de exercícios1. Receba uma lista de nomes como parâmetro da linha de comando. para cada nomerecebido instanciar um objeto da classe pessoa em um vetor de objetos.

A classe pessoa deve possuir um atributo idade que é calculado de acordo com ocomprimento do nome vezes 10.

O nome da pessoa é informado através do construtor da classe pessoa, após instânciar todos os objetosPessoa, percorrer a lista de objetos de maneira a exibir o nome da pessoa mais velha da lista

Ilustração 5diagrama de verba

Crie as classes descritas no diagrama acima e uma aplicação para usar a classe salário de acordo com osrequisitos abaixo descritos

A classe Salario possuirá um "Vector" de objetos "Verba", sendo que os objetos serão na verdade instânciasdas subclasses de verba, que estarão descrevendo dados necessários para o cálculo do salário

Cada subclasse de verba deverá atribuir a superclasse, em seu construtor os atributos : Descricao, quantidadee valor. E deverá receber em seu construtor a quantidade

Observar que a classe Descontos, deve atribuir o valor negativo para a superclasse verba de maneira que osvalortotal dos objetos referentes a desconto sejam negativo

Verba.Valor = valor unitário da verba em questão

verba.valortotal() = retorna valor * quantidade

salario.valortotal() = retorna a soma do valortotal de cada verba do Vector de verbas

Em uma classe de aplicação crie um objeto do tipo Salario e execute o metodo AdicionarVerba que devereceber como parâmetro objetos do tipo verba ( horas normais, horas extras, descontos ). Exibir após isto ométodo valortotal() da classe Salario, para exibir o valor do salário a ser pago

Página 36

Page 37: Aprendendo Java

O R I E N T A Ç Ã O A O R I E N T A Ç Ã O A O B J E T O SO B J E T O S

Herançapara permitir que as subclasses recebam os métodos e atributos declarados na superclasse precisamos usar apalavra reservada "extends" que determina que a subclasse possui esta relação com a superclasse

Exemplo 3-1. criando subclasses

public class mae {

private String nome = "";

public void metodo( String n ) { setNome( "mae " + n + "\n" ); }

public void setNome( String nome) { this.nome = this.nome + nome; }

public String getNome() { return nome; }

}

mae.java

public class filha extends mae {

public void metodo( String n ) { super.metodo( n ); setNome( "filha " + n + "\n" ); }

}

filha.java

Page 38: Aprendendo Java

Anulaçãoquando declaramos um método na subclasse com a mesma assinatura da superclasse estamos realizando aanulação ou "override", isto determina que na subclasse ao executarmos o método em questão estaremos usandoo declarado na classe filha

Dica: não confundir "override" com "overload" que é a sobrecarga, pois a anulação oculta ométodo da classe mãe, enquanto que a sobrecarga oferece mais uma alternativa de uso do mesmométodo

por vezes precisamos no método que está anulando o método da classe mãe, usar a implementação da classemãe, para isto chamamos o método usando a palavra "super" seguido de um ponto e do nome do método quedesejamos chamar

Verificação de tipo

Molde de tipoMolde de tipo ou "type casting" permite a um objeto ser tratado como se fosse de outro tipo, bastando para talusar o nome da classe que desejamos entre parentesis antes do objeto em questão

observar que o molde de tipo somente é necessário quando precisamos que um objeto da superclasse quecontenha uma instância de uma subclasse, se faça passar por um objeto da subclasse. Pois para atribuir porexemplo uma instância de uma subclasse para uma superclasse não é necessário molde de tipo

Tabela 3-1. Uso do molde de tipo

Situação ComentárioSuperclasse v = newSubclasse()

permitido sem necessidade de molde de tipo

Subclasse s =(Subclasse) v;

permitido com necessidade de molde de tipo, e todas as chamadas a metodos dasubclasse também são permitidos, pois a variável v, possui na verdade uma instânciade Subclasse

Dica: para verificar o tipo de um objeto pode ser usado o operador "instanceof"

Página 38

Page 39: Aprendendo Java

Exemplo 3-2. criando subclasses

public class heranca {

public static void main( String [] arg ) {

filha f = new filha(); f.metodo( "Exemplo" );

mae m = new filha(); m.metodo( "segundo Exemplo" );

m = f; f = (filha)m;

System.out.println( f.getNome() ); System.out.println( m.getNome() );

}

}

heranca.java

Page 40: Aprendendo Java

Classes sem objetos

Classes e métodos abstratosObservamos que por vezes desejamos criar classes que não sejam instanciadas, que sejam somente um modelo,ou base para o comportamento de outras. nestes casos usamos o recurso de classe abstrata adicionando a palavrareservada "abstract"

da mesma forma é realizado nos métodos adicionamos "abstract" quando não desejamos que o mesmo possuaimplementação, mas seja implementado nas classes filhas.

Observar que nem toda classe abstrata precisa possuir métodos abstratos, porém todo método abstrato, herdadode um superclasse deve ser implementado a menos que a subclasse também seja uma classe abastrata

Vejamos os exemplos baseado no diagrama abaixo

Ilustração 6verbas

Página 40

Page 41: Aprendendo Java

Exemplo 3-3. Classe abstrata

public abstract class Verba {

private String Descricao = ""; private int Quantidade = 0; private float Valor = 0;

public String getDescricao() { return Descricao; } public int getQuantidade() { return Quantidade; } public float getValor() { return Valor; }

public float ValorTotal() { return Valor * Quantidade; }

public void setDescricao( String Descricao ){ this.Descricao = Descricao; }

public void setQuantidade( int Quantidade ){ this.Quantidade = Quantidade; }

public void setValor( float Valor ){ this.Valor = Valor; }

}

Verba.java

Page 42: Aprendendo Java

Interfacesinterfaces são muito semelhantes a classes abstratas, porém com algumas diferenças essenciais que determinama necessidade da linguagem possuir dois recursos

interfaces permitem definir assinaturas de métodos ( implicitamente são public e abstract ) que deverão serimplementados nas classes que implementam as interfaces, além disto permitem criar atributos queimplicitamente são: public, static, e final

Exemplo 3-4. Uso de interface

interface Isql {String sql();

}

neta.java

interface InterfaceHtml {String html();

}

Isql.java

public class neta extends filha implements Isql, InterfaceHtml {

public void metodo( String n ) { super.metodo( n ); setNome( "filha " + n + "\n" ); }

public String sql(){ return "´" + getNome() + "´"; }

public String html(){ return "<b>" + getNome() + "</b>"; }

}

InterfaceHtml.java

Tabela 3-2. Comparação classe abstrata e interface

Recurso Classe abstrata Interfacepermite definir métodos abstratos (sem implementação) sim simpermite mesclar métodos abstratos e comuns sim nãopermite herança múltipla não sim

Dica: Interfaces são ótimos lugares para guardar valores contantes

Página 42

Page 43: Aprendendo Java

O R G A N I Z A Ç Ã OO R G A N I Z A Ç Ã OD A C A S AD A C A S A

criação de pacotespacotes são criados para agrupar as classes de forma organizada e promover (se necessário) o compartilhamentode atributos e/ou métodos entre as classes do mesmo pacote, porém mantendo estes elementos fora do alcancedas classes de fora do pacote

para identificar a que pacote uma classe pertence, basta que na primeira linha do arquivo seja adicionada apalavra reservada "package" seguida do nome do pacote

o nome do pacote pode ser formado por várias partes, separadas por pontos, é comum as empresas colocaremcomo nome dos pacotes com o nome de domínio invertido, seguido do nome de fato do pacote, como :org.athanazio.sgml

observar que um pacote como o citado acima deverá possuir seus arquivos em um diretorio org\athanazio\sgml eno momento da compilação os arquivos devem estar dentro deste diretório

para usar classes e/ou interfaces que estão dentro de um pacote precisamos importar estes elementos. Para talusamos a palavra chave "import" seguida do caminho completo do pacote, mais o nome do elemento que desejaimportar, ou um asterisco representando que deseja importar todas as classes que estão naquele pacote

Dica: O COMANDO IMPORT NÃO É RECURSIVO

Exemplo 3-5. usando pacotes

package org.athanazio.sgml; interface entidadeSgml { public String sgml( String texto ); }

entidadeSgml.java

package org.athanazio.sgml;

public class para implements entidadeSgml {

public String sgml( String texto ) { return "<para>" + texto + "</para>"; }

}

para.java

Page 44: Aprendendo Java

import org.athanazio.sgml.*;

public class Testesgml {

public static void main( String arg [] ){

para p = new para(); System.out.println( p.sgml( "Java Rockz!" ) );

}

}

Testesgml.java

Página 44

Page 45: Aprendendo Java

T R A T A N D OT R A T A N D OE R R O SE R R O S

Tratamento de erros

A geração de erros no Java gera objetos de classe de erro, o tratamento dos mesmos passa pela manipulaçãodestes objetos de erro

O tratamento de erros em Java é baseado nas palavras reservadas "try ... catch ... finally", para executar umbloco de código protegido por um tratamento de erros, basta colocar o mesmo em um bloco após a palavra "try",e para cada erro que desejamos tratar devemos colocar uma cláusula "catch ( TipoErro variavel-erro ) {}" ouuma cláusula "finally" que é executada após a execução do bloco "try"

quando um método indica que pode gerar um determinado erro através da cláusula "throws" ao ser chamado estemétodo deverá estar dentro de um bloco de "try"

A figura abaixo mostra a hierarquia de classes envolvidas no tratamento de erros

Figura 4-1. Classes para Erros

para criar erros personalizados os mesmos devem ser subclasses de Exception, de maneira que ao declarar osmétodos que podem gerar os erros personalizados deve ser citado o erro que pode ser gerado com a cláusula"throws", observar que erros da classe "Error" ocorrem quando erros da Java Virtual Machine ocorrem demaneira que os mesmos não podem ser tratados

Os erros da classe "RunTimeException" possuem uma particularidade : quando são citados numa cláusula"throws" não é obrigatório que a execução ocorra num bloco de "try", isto porque se tratam de erros comoacesso a um objeto não instânciado, acesso a elementos de vetor que não existem

Page 46: Aprendendo Java

Exemplo 4-1. Exceção personalizada

public class ExceptionCampoVazio extends Exception {

public ExceptionCampoVazio( String NomeCampo ) { super("Campo " + NomeCampo + " precisa ser preenchido"); }

}

ExceptionCampoVazio.java

Exemplo 4-2. método que gera Exceção

public class Venda {

private String Nome;

public void setNome( String Nome ) throws ExceptionCampoVazio {

if ( Nome.equals("") ) { throw new ExceptionCampoVazio( "Nome" ); } else { this.Nome = Nome; }

}

}

Venda.java

Exemplo 4-3. teste de Exceção

public class TesteException { public static void main(String[] args) { Venda v = new Venda();

try { v.setNome(""); } catch ( ExceptionCampoVazio erro ){ System.out.println("Erro : " + erro.getMessage() ); } } }

TesteException.java

Página 46

Page 47: Aprendendo Java

B A N C O D EB A N C O D ED A D O SD A D O S

JDBC Conceitos

"Java Database Conectivity", ou uma maneira muito simpática de construir uma camada de acesso a banco dedados independente de plataforma

Como um dos objetivos da linguagem Java, é escrever uma vez e executar em qualquer lugar, nada mais justoque proporcionar este tipo de alternativa para acesso a banco de dados.

O desafio seria possuir drivers de acesso a banco de dados que não dependessem de recursos espcíficos deplataforma, ou da biblioteca XYZ do fabricante do banco de dados para realizar o acesso. Sendo assim surgiramos drivers JDBC escritos em Java, nem todos os drivers JDBC são totalmente independentes de bibliotecas dofabricante do banco de dados, mas o ideal é sempre adotar os drivers que são escritos totalmente em Java,reduzindo assim a dependencia externa.

Usando JDBC

etapa O que fazer 1. obter o driver JDBC paraacesso ao Mysql

Acesse http://www.mysql.com/products/connector-j/index.html e procure pelaultima versão estavel do driver

2. obter o banco de dadosMysql

Realize o download da ultima versão estavel em www.mysql.com

3. instalar o banco de dadosMysql

Caso o instalador esteja compactado, descompacte, procure por um arquivochamado setup.exe, execute o mesmo, aceite os padrão oferecidos ( observar queespecialmente o diretório de instalação não deve ser mudado, pois se realizar estamudança será necessário configurar o banco para funcionar em outro diretorio )

4. fazendo o banco de dadosfuncionar

Procure no diretório onde o banco de dados foi instalado (Ex. C:\mysql ) pelodiretório bin, execute o programa mysqld este programa irá iniciar o banco dedados e permitir acesso ao mesmo (atenção execute somente uma vez)

Page 48: Aprendendo Java

etapa O que fazer 5. como verificar se o bancode dados Mysql estápronto ?

O banco de dados estará ouvindo na porta 3306 por padrão portanto, paraverificar se esta porta estáaberta, execute no prompt do MS-Dos : netstat -an eprocure pela porta 3306, veja o exemplo abaixo

observe a linha TCP 0.0.0.0:3306 0.0.0.0:0 LISTENING

indica que o computador está esperando conexões TCP/IP na porta 3306, ou sejamuito provevel que o programa que está esperando tais conexões seja o banco dedados Mysql

para confirmar que de fato é o banco de dados Mysql que está esperando na porta3306, execute o seguinte comando:

c:\mysql\bin\mysql.exe

(substitua c:\mysql\bin pelo diretório onde foi instalado o mysql em suamaquina)

você verá uma tela semehante a esta Welcome to the MySQL monitor. Commands end with ; or \g.Your MySQL connection id is 2 to server version: 3.23.46-ntType 'help;' or '\h' for help. Type '\c' to clear thebuffer.mysql>

Página 48

Page 49: Aprendendo Java

etapa O que fazer 6. preparando o banco dedados para ser usado

Para executar nosso exemplo, precisamos criar uma tabela no banco de dados, epara isto iremos executar um script de banco dados – que nada mais é que umarquivo texto com diversos comandos para o banco de dados.

Noss script irá executar as seguintes tarefas :

a. criação do banco de dados javab. criacao do usuario teste com senha 123c. criação da tabela cliented. inserção de dados na tabela cliente

para criar o script basta colar o conteúdo abaixo em um arquivo texto e salvar nodiretório c:\mysql\bin

create database java;use mysql;delete from user where user = "teste";nsert into user ( User, Password , Host ) values ("teste",password("123"), "localhost" );insert into user ( User, Password , Host ) values ("teste",password("123"), "%" );flush privileges;grant all on java.* to teste;flush privileges;use java;create table cliente ( id int auto_increment not null primary key, nome varchar(30));nsert into cliente ( nome ) values ('joao');insert into cliente ( nome ) values ('jose');insert into cliente ( nome ) values ('pedro');

ap´s criar o arquivo com o nome de banco.sql por exemplo para executa-lo bastao seguinte comando:

c:\mysql\bin\mysql < c:\mysql\bin\banco.sql7. configurando o uso dodriver

a. crie um diretorio c:\mysql\jdbcb. copie o arquivo .JAR do driver JDBC para o diretorioc. altere a variavel de ambiente CLASSPATH para o seguinte :CLASSPATH=.;c:\mysql\jdbc\nome-do-arquivo-jar-do-jdbc

caso o conteudo de CLASSPATH ja possua algoaltere para o seguinte :

CLASSPATH=%CLASSPATH%;.;;c:\mysql\jdbc\nome-do-arquivo-jar-do-jdbc

substitua nome-do-arquivo-jar-do-jdbc pelo nome do arquivo jar do driver jdbc :o)

Page 50: Aprendendo Java

Vamos finalmente aos exemplos um de leitura de dados e outr de gravação

import java.sql.*;

public class LerBanco {

static Connection conexao = null; static ResultSet resultado = null; static Statement instrucao = null;

static String caminho ="jdbc:mysql://127.0.0.1:3306/java?user=teste&password=123"; public static void main ( String arg[] ) throws Exception {

try {

System.out.println( "1. nova instancia" );Class.forName("org.gjt.mm.mysql.Driver").newInstance();System.out.println( "2. conexao" );conexao = DriverManager.getConnection( caminho ); instrucao = conexao.createStatement();System.out.println( "3. executa query" );resultado = instrucao.executeQuery(

"SELECT * FROM cliente ORDER BY nome");String nome;

while ( resultado.next() ) {

nome = resultado.getString("nome");System.out.println( nome );

}} catch (SQLException E) {

System.out.println("---------------------------------" ); System.out.println("Erro ao acessar o banco de dados"); System.out.println("SQLException: " + E.getMessage()); System.out.println("SQLState: " + E.getSQLState()); System.out.println("VendorError: " + E.getErrorCode()); System.out.println("---------------------------------" );

E.printStackTrace();

} // try-catch

if ( resultado != null) { resultado.close(); } if ( instrucao != null) { instrucao.close(); } if ( conexao != null) { conexao.close(); }

} // main

} // classe

LerBanco.java

Página 50

Page 51: Aprendendo Java

import java.sql.*;

public class IncluirBanco {

static Connection conexao = null; static ResultSet resultado = null; static Statement instrucao = null;

static String caminho ="jdbc:mysql://127.0.0.1:3306/java?user=teste&password=123"; public static void main ( String arg[] ) throws Exception {

if (arg.length < 1) { System.out.println( "Uso incorreto \n" +

"devem ser informados ao menos um nome para inclusao no \n" + "banco de dados" );

return;}

try {

System.out.println( "1. nova instancia" );Class.forName("org.gjt.mm.mysql.Driver").newInstance();System.out.println( "2. conexao" );conexao = DriverManager.getConnection( caminho ); instrucao = conexao.createStatement();System.out.println( "3. executa query" );instrucao.executeUpdate(

"INSERT INTO cliente ( nome ) VALUES ('" + arg[0] + "')");} catch (SQLException E) {

System.out.println("---------------------------------" ); System.out.println("Erro ao acessar o banco de dados"); System.out.println("SQLException: " + E.getMessage()); System.out.println("SQLState: " + E.getSQLState()); System.out.println("VendorError: " + E.getErrorCode()); System.out.println("---------------------------------" ); E.printStackTrace();

} // try-catch

if ( instrucao != null) { instrucao.close(); } if ( conexao != null) { conexao.close(); }

} // main

} // classe

IncluirBanco.java

Page 52: Aprendendo Java

I N T E R F A C E SI N T E R F A C E SC O M U S U Á R I OC O M U S U Á R I OU S A N D O A W TU S A N D O A W T

Página 52

Page 53: Aprendendo Java

Descrição da AWT

Abstract Window Toolkit, permite a geração de interfaces gráficas convencionais usando alinguagem java, entenda convencional como interface que possue janelas, botões, caixas detexto, e outros elementos gráficos.

A AWT, faz uso das API2 de desenho de interface de cada sistema operacional, logo uminterface construída com AWT vai seguir a identidade visual do ambiente em que estiversendo executada.

O pacote de classe java.awt oferece diversas classes para a composição das interfaces,sendo que todas elas serão filhas das classes Component ou MenuComponent.

O diagrama abaixo mostra as principais classes do pacote AWT (os gerentes de conteúdonão estão incluídos)

2 Application Program Interface – conjunto de chamadas oferecidas ao programador, permitindo ao mesmoutilizar recursos sem precisar conhecer o seu funcionamento, ou seja partes de funcionamento interno de umsistema operacional ou programa que são disponibilizados para uso externo

Ilustração 7 pacote awt

Page 54: Aprendendo Java

novos nomes

Containerpermite organizar os componentes visuais dentro deles, os principais containers são :Window e Panel. Usando o método add() os objetos de componentes visuais sãoadicionados aos containers, permitindo que ao exibir um container os componetes visuaisque estão dentro dele sejam exibidos.

Window é um container que representa uma janela possuindo duas subclasses : Frame eDialog.

Veja uma resumo dos containers:

Frame – jabela com título e bordas que permitem redimensionamento, epermite adicionar componente MenuBar

Dialog – janela simples, não redimensionável, que não pode conter umMenuBar

Panel – área retangular onde podem ser adicionados componentes visuais,observar que deve ser usando dentro de uma Window, ou na janela de umbrowser

Componentsos componentes visuais são a essência das interfaces, pois através dos mesmos é que ainteração com o usuários acontece, cada componente visual serve a propósitos específicos,como por exemplo um caixa de texto, normalmente é usada para o usuário inserir um textoatravés do teclado, usar uma caixa de texto para que o usuário clique com o mouse paraselecionar algo parece no mínimo uma interface esfinge3.

Veja algumas das classes que pacote awt oferece como componentes visuais:

Button - botão CheckBox – caixa de seleção permitindo assinalar sim ou não Choice – caixa suspensa TextArea – área de texto com várias linhas Label – texto a ser exibido List – lista de seleção TextField – área de texto com somente uma linha

3 Diz a lenda que a terrível esfinge, criatura alada que misturava o corpo de mulher ao de leão, se postava naentrada da cidade de Tebas e propunha um enigma aos moradores. Decifra-me ou te devoro. Quem nãosoubesse a resposta era aniquilado. O monstro se apresentou com essa mesma ordem a Édipo, o mitológicoherói grego, que acertou a adivinhação e despachou o bicho para sempre.http://www.terra.com.br/istoe/1704/ciencia/1704_palavras_dos_deuses.htm

Página 54

Page 55: Aprendendo Java

Gerentes de layoutA posição e tamanho dos componentes adicionados aos containers depende dos gerentesde conteúdo. O container quando precisa exibir seus componentes, usa o gerente de layoutque possuir atualmente para organizar os componentes visuais.

Sendo assim problemas como resolução de vídeo e diferenças de vídeo entre plataformasnão precisarão entrar na lista de preocupações de sua interface visto que o posicionamentoserá realizado pelos gerentes de layout

mesmo sabendo das facilidades oferecidas pelos gerentes de layout, se desejar que ocontainer não use um gerente de layout deve alterar o mesmo para null

containerFulano.setLayout(null);

definindo o gerente de layout como null será necessário usar os métodos setLocation(),setSize() ou o setBounds() para definir posicionamento e tamanho dos componentes visuais.

Caso deseje gerenciar o layout sem usar os gerentes de leyout existentes a melhor prática é criaruma classe extenda as funcionalidades da classe LayoutManager, construindo assim seu própriogerente de layout.

Page 56: Aprendendo Java

Como funciona um aplicação

O código abaixo exibe uma pequena aplicação que somente exibe uma janela na tela,observe que o Frame precisa que seja definida as suas dimensões, através do métodosetSize( largura, altura ), e precisa também que seja definido como visível através do métodosetVisible(true).

Este é o resultado visual do código abaixo

import java.awt.*;public class FrameExemplo {

private Frame f;public FrameExemplo(){

f = new Frame("Titulo da janela");}public void exibir(){

f.setSize(200,100);f.setBackground( Color.blue );f.setVisible(true);

}

public static void main( String args[]){FrameExemplo janela = new FrameExemplo();janela.exibir();

}}

FrameExemplo.java

Página 56

Page 57: Aprendendo Java

o exemplo abaixo adiciona um painel ao frame e remove o gerenciador de leyout mantendoo painel na posição inicial do frame

import java.awt.*;

public class FrameComPainel {

private Frame f;private Panel p;

public FrameComPainel(String titulo){f = new Frame( titulo );p = new Panel();

}

public void exibir(){f.setSize(200,100);f.setBackground( Color.blue );f.setLayout(null);

p.setSize(100,50);p.setBackground(Color.yellow);

f.add(p);f.setVisible(true);

}

public static void main( String args[]){

FrameComPainel janela = new FrameComPainel("com painel");

janela.exibir();

}

FrameComPainel.java

Page 58: Aprendendo Java

Gerentes de layoutIremos abrodar os seguintes gerentes conteúdo:

FlowLayout – permite que cada componente seja colocado um ao lado dooutro enquanto houver espaço

BorderLayout – divide o container em 5 regiões GridLayout – separa o container em linhas e colunas

Cada Container possui um gerente de loyout padrão de acordo com a lista abaixo :

FlowLayout – gerente de layout padrão de : Panel BorderLayout – gerente de layout padrão de Window, Dialog e Frame

FlowLayoutO exemplo de código abaixo ilustra a alteração de gerente de layout em um Frame:

import java.awt.*;

public class ExemploLayout {

private Frame f;

private Button b1;private Button b2;

public ExemploLayout(String titulo){f = new Frame( titulo );b1 = new Button("me toque");b2 = new Button("NÃO ME TOQUE");

}

public void exibir(){f.setLayout( new FlowLayout() );f.add(b1);f.add(b2);f.pack();

f.setVisible(true);}

public static void main( String args[]){

ExemploLayout janela = new ExemploLayout("toques");janela.exibir();

}

}

ExemploLayout.java

Página 58

Page 59: Aprendendo Java

O código ExemploLayout gera janela conforme as imagens acima, observe que a janela da direita foiredimensionada e os botões foram reposiionados pois o gerente de Layout FlowLayout realiza esta tarefaautomaticamente.

Observar que o método pack() foi chamado, este método faz com os valores iniciais de tamanho do Frame, zerode altura e zero de largura, sejam alterados para permitir a visualização dos componentes que foram acicionadosa ele, sem deixar desperdício de tela.

Observar que o FlowLayout possui 3 construtores diferentes :

FlowLayout() FlowLayout( alinhamento ) FlowLayout( alinhamento, espaço horizontal, espaço vertical )

veja os exemplos abaixo de uso do FlowLayout:

// alinhamento a direita, espaço horizontal 15 e vertical 30setLayout( new FlowLayout( FlowLayout.RIGHT, 15, 30 ) );

// alinhamento a esquerdasetLayout( new FlowLayout( FlowLayout.LEFT) );

Consulte o javadoc em java.awt na classe FlowLayout para conhecer todos alinhamentosexistentes (CENTER, LEADING, LEFT, RIGHT, TRAILING)

observar que todos estes valores são atributos classe e inteiros.

Page 60: Aprendendo Java

BorderLayout

Este gerente de layout divide a tela em 5 regiões:

BorderLayout.NORTHB

orde

rLay

out.W

EST

BorderLayout.CENTER

Bor

derL

ayou

t.EA

ST

BorderLayout.SOUTH

Para usar um BorderLayout basta utilizar um dos seus construtores:

BorderLayout()BorderLayout( espaço horizontal, espaço vertical )

para adicionar elementos a um container que possua o gerente de layout como oBorderLayout devemos usar o método add() porém além do objeto devemos informar emque região do BorderLayout desejamos adicionar o elemento, conforme as opções :BorderLayout.NORTH, BorderLayout.SOUTH, BorderLayout.CENTER, orderLayout.WEST e BorderLayout.EAST.

o código abaixo adiciona um botão em um container Painel que pode ser adicionado a outrocontainer para ser visualizado

Panel p = new Panel(); p.setLayout(new BorderLayout()); p.add(new Button("Teste"), BorderLayout.SOUTH);

Ao adicionarmos mais de um componente em uma mesma região de um BorderLayout somenteo último adicionado ficará visível, contudo existem telas em que desejamos mais de umcomponente em uma determinada região, para isto uma solução seria criar um Panel comFlowLayout adicionar os componentes nele e adicionar o painel na região do BorderLayout

Página 60

Page 61: Aprendendo Java

O Exemplo a seguir produz aprimeira tela com oredimensionamento temos osegundo exemplo onde oselementos gráficos sãoredimensionados.

import java.awt.*;

public class ExemploBorder {

private Frame f;private Button bn;private Button bs;private Button bc;private Button bw;private Button be;

public ExemploBorder(String titulo){f = new Frame( titulo );bn = new Button("NORTE");bs = new Button("SUL");bc = new Button("CENTRO");bw = new Button("OESTE");be = new Button("LESTE");

}

public void exibir(){f.setLayout( new BorderLayout() );f.add(bn, BorderLayout.NORTH );f.add(bs, BorderLayout.SOUTH );f.add(bc, BorderLayout.CENTER );f.add(bw, BorderLayout.WEST );f.add(be, BorderLayout.EAST );f.pack();

f.setVisible(true);}

public static void main( String args[]){ExemploBorder janela = new ExemploBorder("regioes");janela.exibir();

}

}

ExemploBorder.java

Page 62: Aprendendo Java

GridLayout

este gerente de Layout permite a flexibilidade de dividir o container em linhas e colunas, e acada chamada do método add() um componente é adicionado na grade construída nosentido da esquerda para a direita e de cima para baixo.

São três os construtores de GridLayout:

GridLayout() - cria um layout de 1 linha por 1 colunaGridLayout( linhas, colunas )GridLayout( linhas, colunas, espaço horizontal, espaço vertical )

o exemplo abaixo demonstra a criação de uma interface usando o GridLayout:

import java.awt.*;

public class ExemploGrid {

private Frame f;

private Button b1, b2, b3, b4, b5;

public ExemploGrid(String titulo){f = new Frame( titulo );b1 = new Button("1");b2 = new Button("2");b3 = new Button("3");b4 = new Button("4");b5 = new Button("5");

}

public void exibir(){f.setLayout( new GridLayout( 2, 3 ) );f.add(b1);f.add(b2);f.add(b3);f.add(b4);f.add(b5);

f.pack();f.setVisible(true);

}

public static void main( String args[]){ExemploGrid janela = new ExemploGrid("botoes & cia");janela.exibir();

}

}

ExemploGrid.java

Página 62

Page 63: Aprendendo Java

Observe que ao redimensionar a janela a proporção entre os elementos visuais permanece

Combinando gerentes de layout

imagine a seguinte necessidade : criar uma interface para uma calculadora:Uma das soluções seria criar um painel com GridLayout com os botões de operaçõese adiciona-lo na região center de um BorderLayout e adicionar um caixa de texto na regiãonorte, vamos ao código que vai gerar as telas abaixo:

Page 64: Aprendendo Java

import java.awt.*;

public class Calculadora {

private Frame f;private Panel botoes;private Button b1, b2, b3, b4, b5, b6, b7, b8, b9, b0;private TextField valor;

public Calculadora(String titulo){f = new Frame( titulo );b1 = new Button("1"); b2 = new Button("2");b3 = new Button("3"); b4 = new Button("4");b5 = new Button("5"); b6 = new Button("6"); b7 = new Button("7"); b8 = new Button("8"); b9 = new Button("9"); b0 = new Button("0");

botoes = new Panel();valor = new TextField();

}

public void exibir(){f.setLayout( new BorderLayout() );botoes.setLayout( new GridLayout( 4, 3 ) );botoes.add(b1); botoes.add(b2); botoes.add(b3);botoes.add(b4); botoes.add(b5); botoes.add(b6);botoes.add(b7); botoes.add(b8); botoes.add(b9);botoes.add( new Label("")); botoes.add(b0);

f.add( valor , BorderLayout.NORTH );f.add( botoes, BorderLayout.CENTER );

f.pack();f.setVisible(true);

}

public static void main( String args[]){Calculadora janela = new Calculadora("botoes e botoes");janela.exibir();

}

}

Calculadora.java

1. crie uma layout de calculadora que adicione os botões de operações a serem realizadas

2. crie uma tela para inclusão de dados de um cliente, onde deve ser exibido um label a esquerdade cada caixa de texto (nome e email) e na região inferior da tela deve ser exibido um botão deok e outro de cancelar um ao lado do outro

Página 64

Page 65: Aprendendo Java

Desenhando na tela

O compoente Canvas deve ser usado quando desejamos construir um desenhopersonalizado na tela, para tal basta criar uma subclasse de canvas e sobreescrever ométodo paint.

Observar que o método paint recebe como parêmetro um objeto Graphics que possuidiversas funcionalidades de primitiva de desenho, o que permite construir qualquer elementovisual personalizado, o exemplo abaixo cria uma classe boneco que desenha um bonecopalito, este novo componente é usado no exemplo abaixo para desenhar uma família debonecos.

import java.awt.*;

public class Boneco extends Canvas{private Rectangle dimensoes;

public Boneco(){setSize( 60, 100 );

}

public void paint(Graphics g){

dimensoes = getBounds();setBackground( Color.WHITE );g.clearRect( dimensoes.x, dimensoes.y,

dimensoes.width, dimensoes.height );

int areav = (int) (dimensoes.height / 3);int areah = (int) (dimensoes.width / 4);

// desenha cabecag.drawOval( areah, 0, 2*areah, areav );

// desenha corpog.drawLine( 2*areah, areav, 2*areah, 2*areav );

// desenha braçosg.drawLine( 2*areah, (int)(1.5*areav), 3*areah,

(int)(1.5*areav) );g.drawLine( 2*areah, (int) (1.5*areav), areah,

(int)(1.5*areav) );

// desenha pernasg.drawLine( 2*areah, 2*areav, 3*areah, 3*areav );g.drawLine( 2*areah, 2*areav, areah, 3*areav );

}}

Boneco.java

Page 66: Aprendendo Java

import java.awt.*;

public class ExemploBoneco {

private Frame f;private Boneco b1;private Boneco b2;private Boneco b3;

public ExemploBoneco(String titulo){f = new Frame( titulo );b1 = new Boneco();b2 = new Boneco();b3 = new Boneco();

}

public void exibir(){f.setLayout( new GridLayout( 0, 3 ) );f.add(b1); f.add(b2); f.add(b3);

f.pack();f.setVisible(true);

}

public static void main( String args[]){ExemploBoneco janela = new ExemploBoneco("Familia boneco");janela.exibir();

}

}

ExemploBoneco.java

1. pesquise os métodos primitivos de desenho oferecidos pela classe Graphics

2. faça uma variação da classe boneco em que o corpo do mesmo seja uma retangulo e sejapassado como parâmetro no seu construtor a cor de preenchimento da cabeça e do corpo

Página 66

Page 67: Aprendendo Java

Componentes visuais

A tabela abaixo vai oferecer um referência simplificada sobre os componentes visuaisoferecidos pela AWT

Componente Uso comum ExemplosButton Permitir ao usuário através

do clique do mouse indicaruma ação a ser tomada

b0 = new Button("0"); f.add( b0 );

f.add( new Button(“botão”) );

CheckBox Permite ao usuário indicarse verdadeiro ou falso

deve ser usado o métodogetState() para verificar seesta marcado ou não

setLayout(new GridLayout(3, 1));

/* assinala como null o grupo de checkbox emarca como selecionado */ add(new Checkbox("one", null, true)); add(new Checkbox("two")); add(new Checkbox("three"));

para torna-los mutuamente exclusivos é necessário criarum grupo de checkbox e usar o métodogetSelectedCheckbox() para recuperar que componenteestá selecionado

setLayout(new GridLayout(3, 1)); CheckboxGroup cbg =

new CheckboxGroup(); add(new Checkbox("one", cbg, true)); add(new Checkbox("two", cbg, false)); add(new Checkbox("three", cbg, false));

Choice Caixa suspensa de seleção,permite escolher a partir deuma lista

Choice lista = new Choice(); lista.add("Green"); lista.add("Red");ColorChooser.add("Blue");

o código abaixo identifica o elementoatualmente selecionado

String atual = lista.getItem( lista.getSelectedIndex() );

Page 68: Aprendendo Java

Componente Uso comum ExemplosTextField Caixa de texto para receber

entrada de dados dousuário

TextField ed1, ed2, ed3, ed4; // campo de texto vazio ed1 = new TextField();

// vazio com 20 colunas ed2 = new TextField("", 20);

// texto a ser exibido predefinido ed3 = new TextField("Ola");

// texto predefinido com 30 colunas ed4 = new TextField("Ola", 30);

// define que a caixa de texto irá// exibir * ao invés dos caracteres // difitadosed1.setEchoChar('*');

// recupera o valor do editor 2String texto = ed2.getText();

// define o valor dos campos // ed3 e ed4ed3.setText( ed4.getText() );ed4.setText( texto );

Label Exibir um texto nocontainer setLayout(new FlowLayout(

FlowLayout.CENTER, 10, 10));

add(new Label("olá")); add(new Label("olá de novo"));

Página 68

Page 69: Aprendendo Java

Componente Uso comum ExemplosList Exibe uma lista permitindo

ao usuário escolher um dositens da lista

// exibirá quatro elementos na tela// e não permitirá multiplas seleçõesList lst = new List(4, false); lst.add("Mercury"); lst.add("Venus"); lst.add("Earth"); lst.add("JavaSoft"); lst.add("Mars"); lst.add("Jupiter"); lst.add("Saturn"); lst.add("Uranus"); lst.add("Neptune"); lst.add("Pluto"); cnt.add(lst);

diferente do choice o component list possui um métodoque retorna a string ou strings selecionadas através dosmétodos :

// retorna uma StringgetSelectedItem()

// retorna um array de StringgetSelectedItems()

TextArea Permitir a edição de textoem mais de uma linha // define uma área de texto com

// 5 linhas e 40 colunasnew TextArea("olás", 5, 40);

Page 70: Aprendendo Java

Tratando Eventos

Interfaces gráficas orientadas a eventos, é coisa antiga, pois mesmo quando ainterface era somente texto, já faziamos programas para tratar eventos do usuário. Oque mudou agora é a quantidade, e diversidade de eventos que precisamos tratar.

Antigamente os eventos ocorriam um por vez, e eram coisas do tipo: o usuáriopressionou a tecla A... Hoje temos : o usuário clicou, arrastou, clicou com o direiro, “dropou”pressionou Alt e clicou, passou com mouse por cima, fechou, abriu, moveu, apertou Pagedown, up, esquerda, direita, ... É muito evento, mas felizmente escrever rotinas para tratareventos em java é muito simples, eventos pra que te quero !

Como funciona ?As interações do usuário com a interface gera um evento, a JVM (Java Virtual Machine) criao objeto com os dados do evento, procura por algum objeto que esteja esperando poreventos deste determinado tipo e executa deste objeto o método referente ao eventoocorrido.

O objeto que espera o evento ocorrer é chamado de listener, o método que é executadopara tratar o evento chamasse event-handler.

Sendo assim é importante observar que caso não haja um listener adequado para um tipode evento, quando o mesmo ocorrer não será tratado.

O listener pode ser um objeto da própria classe ou ainda de outra classe, veja o exemploabaixo, onde o trtador de eventos é uma classe separada :

import java.awt.*;

public class TesteEvento1 { private Frame f; private Button b1; private Button b2; public TesteEvento1(String titulo){ f = new Frame( titulo ); b1 = new Button("Clique em mim (1)"); b1.setActionCommand("1"); b2 = new Button("Clique em mim (2)"); b2.setActionCommand("2"); } public void exibir(){ f.setLayout( new FlowLayout() ); b1.addActionListener( new TratadorBotao() ); b2.addActionListener( new TratadorBotao() ); f.add(b1);

Página 70

Page 71: Aprendendo Java

f.add(b2);

f.pack(); f.setVisible(true); } public static void main( String args[]){ TesteEvento1 janela = new TesteEvento1("Eventos"); janela.exibir(); } }

TesteEvento1.java

import java.awt.event.*;public class TratadorBotao implements ActionListener { public void actionPerformed( ActionEvent e ) { System.out.println("Ocorreu uma ação"); System.out.println("comando do botão = " + e.getActionCommand() ); } }

TratadorBotao.java

A chamada setActionCommand(“1”), determina que String será enviada para o tratador deeventos, visando possibilitar a correta interpretação do comando enviado para o tratador deeventos. Determinando assim para cada botão um comando diferente fazendo com quecada um seja interpretado de forma diferente.

O trecho addActionListener( new TratadorBotao() ) associa uma instância da classeTratadorBotao ao botão indicando este objeto como sendo o tratador de de eventos para omesmo.

O método ActionPerformed( ActionEvent e ) da classe TratadorBotao é executadorecebendo como parâmetro um objeto de ActionEvent que descreve o evento ocorrido, entreoutras intformações, possui o ActionCommand do componente que disparou o evento.

Neste outro exemplo de tratador de eventos, possuímos somente uma instância do tratadorde eventos, chamamos esta classe de singleton, pois a mesma somente possuirá umainstância (observe que o construtor é private), e usamos o método classe get() pararecuperar esta instância.

O tratador de eventos recupera o ActionCommand e usa o mesmo para identificar a posiçãono vetor de contadores a ser incrementada.

Page 72: Aprendendo Java

import java.awt.event.*;

public class TratadorBotaoContador implements ActionListener {

private int [] contador; private static TratadorBotaoContador instancia; public static TratadorBotaoContador get(){ if ( instancia == null ){ instancia = new TratadorBotaoContador(); } return instancia; } private TratadorBotaoContador(){ contador = new int[10];

for( int i=0; i <10; i ++ ){ contador[i] = 0; } }

public void actionPerformed( ActionEvent e ) { int posicao = Integer.parseInt( e.getActionCommand() ); contador[posicao] ++; for( int i=0; i <10; i ++ ){ if ( contador[i] > 0 ){ System.out.println("contador[" + i + "]=" +

contador[i] ); } } } }

TratadorBotaoContador.java

Página 72

Page 73: Aprendendo Java

Eventos de janelas

Os eventos de janelas são controlados a partir da interface WindowListener, que indica quea classe que a implementa deve fornecer implementação para os métodos :

windowClosing windowClosed windowOpened windowIconified windowDeiconified windowActivated windowDeactivated

dos quais o mais comum é o WindowClosing onde tornamos a janela invisível e depoisabandonamos o programa atual. Observar que neste tratador de evento seria uma bom lugarpara se colocar uma pergunta ao usuário se deseja realmente abandonar o programa, ou umbom lugar para gravar configurações do usuário.

Veja o exemplo a seguir que demonstra o uso destes eventos.

import java.awt.*;import java.awt.event.*;

/** * exemplo de manipulacao de eventos de janela * * @author Hamilton Lima [email protected] * @version 17/11/2002 */public class ExemploJanela extends Frame implements WindowListener {

public ExemploJanela(String titulo){ super(titulo); init(); }

private void init(){ addWindowListener(this); setSize(200,100); }

public void exibir(){ setVisible(true); }

public void windowClosing(WindowEvent e) { System.out.println("evento : closing");

setVisible(false); System.exit(0); }

public void windowClosed(WindowEvent e) { System.out.println("evento : closed"); }

Page 74: Aprendendo Java

public void windowOpened(WindowEvent e) { System.out.println("evento : opened"); }

public void windowIconified(WindowEvent e) { System.out.println("evento : iconified"); }

public void windowDeiconified(WindowEvent e) { System.out.println("evento : deiconified"); }

public void windowActivated(WindowEvent e) { System.out.println("evento : activated"); }

public void windowDeactivated(WindowEvent e) { System.out.println("evento : deactivated"); }

public static void main( String arg[]){ ExemploJanela e = new

ExemploJanela("tratando eventos de janela"); e.exibir(); }}

ExemploJanela.java

O tratamento de eventos pode ser simplificado através dos chamados Adapters classes analogas as interfaces detratamento de eventos contudo que são classes e implementam as interfaces necessárias para o tratamento de umdeterminado evento, não sendo necessários portanto implementar todos os métodos, tão somente aqueles que defato precisa.

A linguagem java inclusive permite um recurso muito elegante de programação que são as classes anônimas,para tratamento de eventos, observe no exemplo abaixo que a classe SEM NOME é declarada e passada comoparâmetro no método addWindowListener onde está sendo definido que classe cuidará dos eventos de janela,observe também que assim a janela não precisa implementar todos aqueles métodos vazios de WindowListener.

import java.awt.*;import java.awt.event.*;

public class JanelaSimples extends Frame {

public JanelaSimples(String titulo){ super(titulo); init(); }

private void init(){ setSize(200,100);

// tratador de eventos anonimo addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent e) {

Página 74

Page 75: Aprendendo Java

setVisible(false); System.exit(0); } }); }

public void exibir(){ setVisible(true); }

public static void main( String arg[]){ JanelaSimples e =

new JanelaSimples("tratador de eventos anonimo"); e.exibir(); }}

Page 76: Aprendendo Java

Criando menusA criação de menus envolve duas classes:

MenuBar – a barra dos menus

Menu – agrupamentos de itens de menu

MenuItem – cada item de menu

Para a criação de menus é necessário que haja um menu container como um Frame que possa receber ocomponente MenuBar com seus menu itens.

O tratamento de eventos é realizado através de um ActionListener que deve ser associado a cada item de menu.O exemplo abaixo demonstra a criação de um menu e o tratamento dos eventos ocorridos neles

import java.awt.*;import java.awt.event.*;

/** * exemplo de manipulacao de eventos de menu para * abrir varias janelas * * @author Hamilton Lima [email protected] * @version 17/11/2002 */public class Janela1 extends Frame implements ActionListener {

public static final String ITEMMENU_SAIR = "sair"; public static final String ITEMMENU_NOVO = "novo"; public static final String ITEMMENU_FECHAR = "fechar";

public Janela1(String titulo){ super(titulo); init(); }

private void init(){ setSize(200,100);

// tratador de eventos anonimo addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent e) { setVisible(false); System.exit(0); } });

// cria os componentes para o menu MenuBar menu = new MenuBar(); Menu arquivo = new Menu("arquivo"); Menu ajuda = new Menu("ajuda"); // cria os itens de menu MenuItem novo = new MenuItem( ITEMMENU_NOVO ); MenuItem fechar = new MenuItem( ITEMMENU_FECHAR ); MenuItem sair = new MenuItem( ITEMMENU_SAIR );

Página 76

Page 77: Aprendendo Java

// define o tratador de eventos dos itens de menu novo.addActionListener(this); fechar.addActionListener(this); sair.addActionListener(this); // adiciona os itens aos menus arquivo.add(novo); arquivo.add(fechar); arquivo.addSeparator(); arquivo.add(sair); // adiciona os menus a barra de menus menu.add(arquivo); menu.add(ajuda); // adiciona a barra de menus ao Frame setMenuBar(menu); }

public void exibir(){ setVisible(true); }

public void actionPerformed( ActionEvent e ) { String comando = e.getActionCommand(); if ( comando.equals( ITEMMENU_SAIR ) ){ setVisible(false); System.exit(0); }

System.out.println("comando = " + comando ); }}

Janela1.java

Page 78: Aprendendo Java

O trecho abaixo executa a janela acima:

public class AppJanela1 { public static void main( String arg[]){ Janela1 j = new Janela1("janela com menus"); j.exibir(); }}

AppJanela1.java

O resultado será uma janela como esta abaixo :

Página 78

Page 79: Aprendendo Java

E X E M P L O S D EE X E M P L O S D ES O L U Ç Õ E SS O L U Ç Õ E S

Capitulo 1, exercício 1Receba 3 números como parâmetro, exiba o maior o menor e o do meio

Exemplo A-1. maior menor e do meio

public class Pweb_L1_Ex1 {

public static void main (String args[]) {

String uso = "Use : java Pweb_L1_Ex1 n1 n2 n3 nn";

if (args.length < 1) { System.out.println(uso); System.exit(0); }

int MAX = args.length; int resultado[] = new int [ MAX ]; for (int i=0; i<MAX; i++) { resultado[i] = Integer.parseInt(args[i]); }

Util obj = new Util(); resultado = obj.ordenaInt(resultado);

for (int i=0; i<MAX; i++) { System.out.println(resultado[i]); } } }

Pweb_L1_Ex1.java

import java.util.*;

public class Util {

String[] split (String str, char ch) { Vector vec = new Vector(); int i, tmp = 0;

// Elimina espaços iniciais e finais str.trim();

Page 80: Aprendendo Java

for (i=0; i < str.length(); i++) { if (str.charAt(i) == ch) { vec.add(str.substring(tmp, i)); tmp = i+1; } } vec.add(str.substring(tmp, i));

if (vec.capacity() < 1) { return null; } else { String []tmpStr; tmpStr = new String[(vec.lastIndexOf(vec.lastElement()) + 1)]; for (i=0; i <= vec.lastIndexOf(vec.lastElement()); i++) { tmpStr[i] = (String)vec.get(i); } return tmpStr; } }

int[] ordenaInt (int x[]) { int min, aux; for (int i=0; i < ((x.length) - 1); i++) { min = i; for (int j=(i + 1); j < x.length; j++) { if (x[j] < x[min]) { min = j; } } aux = x[min]; x[min] = x[i]; x[i] = aux; } return x; }

}

Util.java

Página 80

Page 81: Aprendendo Java

Capitulo 1, exercício 2Receba uma frase como parâmetro (a frase deve ser digitada entre aspas) e informe o número de palavras que afrase contém

Exemplo A-2. numero de palavras de uma frase

public class Pweb_L1_Ex2 {

public static void main (String args[]) { String uso = "Use : java Pweb_L1_Ex2 \"FRASE\""; if (args.length < 1) { System.out.println(uso); System.exit(0); }

String resultado[];

// Split do argumento, com o separador ' ' Util obj = new Util(); resultado = obj.split(args[0], ' '); for (int i=0; i<resultado.length; i++) { if (resultado[i].length() > 0) { System.out.println(resultado[i]); } } } }

Pweb_L1_Ex2.java

Page 82: Aprendendo Java

Capitulo 1, exercício 3Declare um vetor contendo 10 Strings, realize a inversão deste vetor - colocando o elemento 10 como 1, o 9como 2 e assim por diante, e após isto exiba o conteúdo do vetor invertido

Exemplo A-3. Inversão de vetor

/** * * InverterVetorString * * @author athanazio * @version 24/07/2003 */public class InverterVetorString { public static void main(String[] args) { String vetor[] = { "um", "dois", "tres", "quatro",

"cinco", "seis", "sete", "oito", "nove", "dez" }; String temp = null; // divisao de inteiros resultado inteiro int meio = vetor.length / 2; for (int i = 0; i < meio; i++) { temp = vetor[i]; vetor[i] = vetor[ (vetor.length-1) - i]; vetor[ (vetor.length-1) - i] = temp; } for (int i = 0; i < vetor.length; i++) { System.out.println( vetor[i] ); }

}}

Página 82

Page 83: Aprendendo Java

Capitulo 1, exercício 4Receba uma lista números como parâmetro, após isto exiba a média dos números recebidos - independente daquantidade de números

Exemplo A-4. Média de números

// Exercicio 4 public class Pweb_L1_Ex4 {

public static void main (String args[]) { String uso = "Use : java Pweb_L1_Ex4 n1 n2 n3 nn"; if (args.length < 1) { System.out.println(uso); System.exit(0); }

int contador, soma = 0; for (contador=0; contador < args.length; contador++) { soma += Integer.parseInt(args[contador]); }

System.out.println((float)(soma / contador)); } }

Pweb_L1_Ex4.java

Page 84: Aprendendo Java

Capitulo 1, exercício 5Exiba na tela a tabela ASCII, exibindo o número do caracter e o seu respectivo caracter - exibir de 1 a 255

Exemplo A-5. Tabela ASCII

/** * * ListarTabelaASCII * * @author athanazio * @version 24/07/2003 */public class ListarTabelaASCII { public static void main(String[] args) { for (int i = 0; i <= 255; i++) { System.out.println( i + " " + (char)i); } }}

Página 84

Page 85: Aprendendo Java

Capitulo 1, exercício 6Crie um vetor multidimensional de objetos, que possua duas dimensões, na primeira adicione um vator destrings com os nomes dos funcionários, na segunda um vetor de Float com os salários dos funcionários

Receba como parâmetro o percentual de aumento salarial a ser aplicado para cada funcionário, após isto exibana tela os nomes dos funcionários acompanhado do salário atualizado pelo índice recebido

Exemplo A-6. Vetor de objetos

Pweb_L1_Ex6.java

Page 86: Aprendendo Java

Capitulo 1, exercício 7Crie uma calculadora que funcione através da linha de comando, esta calculadora deve receber comandosaritméticos semelhantes a linguagem cobol, após receber cada comando deve realizar o cálculo e exibir oresultado

• MULTIPLY A BY B

• DIVIDE A BY B

• ADD A TO B

• SUBTRACT A FROM B

Exemplo A-7. Calculadora

public class Pweb_L1_Ex7 { public static void main (String args[]) {

String uso = "Use : java Pweb_L1_Ex7 MULTIPLY n1 BY n2 \n" + "java Pweb_L1_Ex7 DIVIDE n1 BY n2\n"

+ "java Pweb_L1_Ex7 ADD n1 TO n2 \n" + "java Pweb_L1_Ex7 SUBTRACT n1 FROM n2";

if (args.length < 4) { System.out.println(uso); System.exit(0); }

String op1 = args[0]; int n1 = Integer.parseInt(args[1]); String op2 = args[2]; int n2 = Integer.parseInt(args[3]); double result = 0.0;

if (op1.equals("MULTIPLY") && op2.equals("BY")) { result = (double)(n1 * n2); } else if (op1.equals("DIVIDE") && op2.equals("BY")) { result = (double)n1 / (double)n2; } else if (op1.equals("ADD") && op2.equals("TO")) { result = (double)(n1 + n2); } else if (op1.equals("SUBTRACT") && op2.equals("FROM")) { result = (double)(n1 - n2); } else { System.out.println(uso); System.exit(0); }

System.out.println(result); } }

Pweb_L1_Ex7.java

Página 86

Page 87: Aprendendo Java

Capitulo 1, exercício 8Receba um nome como parâmetro e indique quantas vogais e quantas consoantes contém o nome, e a vogal quemais ocorreu

Exemplo A-8. Contagem de vogais e consoantes

public class Pweb_L1_Ex8 {

public static void main (String args[]) { String uso = "Use : java Pweb_L1_Ex8 nome";

if (args.length < 1) { System.out.println(uso); System.exit(0); }

char []consoante = {'b','c','d','f','g','h','j','k','l','m','n','p','q','r','s','t','v','w','x','y','z'};

char []vogal = {'a','e','i','o','u'}; int []contadorVogais = new int [vogal.length]; int contador, somaC = 0, somaV = 0;

for (contador=0; contador < args[0].length(); contador++) { for (int i=0; i < consoante.length; i++) { if (args[0].charAt(contador) == consoante[i]) { somaC++; break; } } for (int i=0; i < vogal.length; i++) { if (args[0].charAt(contador) == vogal[i]) { somaV++; contadorVogais[i]++; break; } } }

int []contadorVogaisTmp = new int [vogal.length]; for (int i=0; i < vogal.length; i++) { contadorVogaisTmp[i] = contadorVogais[i]; }

Util obj = new Util(); int resultado[] = obj.ordenaInt(contadorVogaisTmp);

String maisVezes = ""; for (int i=0; i < vogal.length; i++) { if (contadorVogais[i] == resultado[resultado.length - 1]) { maisVezes += String.valueOf(vogal[i]); } }

System.out.println("Total de Vogais : " + String.valueOf(somaV)); System.out.println("Total de Consoantes : " +

String.valueOf(somaC));System.out.println("Vogais que mais ocorreram : " + maisVezes);

Page 88: Aprendendo Java

} }

Pweb_L1_Ex8.java

Capitulo 1, exercício 9Crie um calculadora de minutos que receba a hora inicial a a hora final e exiba a quantidade de minutos entre osdois horários - receba os parâmetros no seguinte formato HH:MM HH:MM, onde HH significa hora e MM osminutos

Exemplo A-9. Calculadora de minutos

public class Pweb_L1_Ex9 {

public static void main (String args[]) {

String uso = "Use : java Pweb_L1_Ex9 HH:MM HH:MM";

if (args.length < 2) { System.out.println(uso); System.exit(0); }

String tmp1[]; String tmp2[];

// Split do argumento, com o separador ':' Util obj = new Util(); tmp1 = obj.split(args[0], ':'); tmp2 = obj.split(args[1], ':');

// Testes p/ validar formato de hora if ((tmp1.length != 2) || (tmp2.length != 2) || ((Integer.parseInt(tmp1[0]) < 0) ||

(Integer.parseInt(tmp1[0]) > 23)) || ((Integer.parseInt(tmp2[0]) < 0) ||

(Integer.parseInt(tmp2[0]) > 23)) || ((Integer.parseInt(tmp1[1]) < 0) ||

(Integer.parseInt(tmp1[1]) > 59)) || ((Integer.parseInt(tmp2[1]) < 0) ||

(Integer.parseInt(tmp2[1]) > 59))) {

System.out.println(uso); System.exit(0); }

int minutos1 = (Integer.parseInt(tmp1[0]) * 60) + Integer.parseInt(tmp1[1]);

int minutos2 = (Integer.parseInt(tmp2[0]) * 60) + Integer.parseInt(tmp2[1]);

int resultado;

// Não faz sentido tempo negativo if (minutos1 > minutos2) { resultado = minutos1 - minutos2; } else {

Página 88

Page 89: Aprendendo Java

resultado = minutos2 - minutos1; }

System.out.println("Diferenca de " + String.valueOf(resultado) + "

minutos !"); } }

Pweb_L1_Ex9.java

Page 90: Aprendendo Java

Capitulo 1, exercício 10Receba o número do mês e o ano, e após isto exiba o calendário para o mês e ano solicitado no seguinteformato:

c:\>java calendario 08 2001

Agosto 2001

Dom Seg Ter Qua Qui Sex Sab 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

c:\>

Exemplo A-10. Calendario

// Exercicio 10 import java.util.*;

public class Pweb_L1_Ex10 {

public static void main (String args[]) {

// Verificacao das informacoes passadas String uso = "Use : java Pweb_L1_Ex10 MONTH YEAR"; if (args.length < 2) { System.out.println(uso); System.exit(0); }

// Recupera parametros int mes = Integer.parseInt(args[0]) - 1; int ano = Integer.parseInt(args[1]);

// Variaveis locais int maxLinhas = 6; int colunas = 7; int linhaCorrente = 0; String[][] calendario = new String[6][colunas]; String[] dias =

{"Dom","Seg","Ter","Qua","Qui","Sex","Sab"};

String[] meses = {"Janeiro","Fevereiro","Marco","Abril", "Maio","Junho","Julho","Agosto", "Setembro","Outubro","Novembro","Dezembro" };

// Inicializa calendario com espacos vazios for (int i=0; i < maxLinhas; i++) { for (int ii=0; ii < colunas; ii++) { calendario[i][ii] = " "; } }

// Instancia de um objeto GregorianCalendar GregorianCalendar cal = new GregorianCalendar(ano, mes, 1);

Página 90

Page 91: Aprendendo Java

// Primeiro e Ultimo dia do mes utilizado int primeiroDia = cal.getActualMinimum(Calendar.DATE); int ultimoDia = cal.getActualMaximum(Calendar.DATE); int ultimoDiaSemana = cal.getFirstDayOfWeek() - 1;

// Carregamento do Array Calendario for (int i=primeiroDia; i <= ultimoDia; i++) {

// Guarda o dia na posicao em que deve aparecer no calendario calendario[linhaCorrente][(cal.get(Calendar.DAY_OF_WEEK) - 1)] = String.valueOf(i);

// Adiciona um dia no objeto cal ( // nossa instancia do GregorianCalendar) cal.add(Calendar.DATE, 1);

// Se ultimo dia da semana, pula linha if (cal.get(Calendar.DAY_OF_WEEK) == ultimoDiaSemana) { linhaCorrente++; } }

// Impressao na tela - Cabecalho System.out.println("\n " + meses[mes] + " " + String.valueOf(ano) + "\n");

for (int i=0; i < dias.length; i++) { System.out.print(dias[i] + " "); } System.out.println(""); // Impressao na tela - dados do Array calendario for (int i=0; i < maxLinhas; i++) { for (int ii=0; ii < colunas; ii++) { if (calendario[i][ii].length() == 1) { System.out.print(" "); } System.out.print(calendario[i][ii] + " "); } System.out.println(""); } }

Pweb_L1_Ex10.java

Page 92: Aprendendo Java

E X E M P L O D EE X E M P L O D EA P L I C A Ç Ã O M D IA P L I C A Ç Ã O M D I

Este exemplo de aplicação MDI combina recursos de AWT e Swing em uma só aplicação, as bibliotecas Swingsão usadas para gerenciar o comportamento visual de janelas filhas que permanecem internas na janelaprincipal, as seguintes classes compões este exemplo:

AppMDI.java – aplicação que chama janela principal

MDIPrincipal.java – janela principal que controla as janelas existentes

MDIFilha.java – Classe modelo para janelas filhas

MDISobre – tela modal de ajuda com créditos da aplicação

como diria uma amigo meu... show me the code !

public class AppMDI { public static void main( String arg[]){ MDIPrincipal mdi = new MDIPrincipal("Janela MDI"); mdi.exibir(); }}

AppMDI.java

import java.awt.*;import java.awt.event.*;import java.util.Vector;import java.util.Iterator;import javax.swing.*;import javax.swing.event.*;

/** * MDIPrincipal * exemplo de aplicacao MDI * janela principal * * @author Hamilton Lima [email protected] * @version 17/11/2002 */public class MDIPrincipal extends JFrame implements ActionListener {

public static final String ITEMMENU_SAIR = "sair";

Página 92

Page 93: Aprendendo Java

public static final String ITEMMENU_NOVO = "novo"; public static final String ITEMMENU_FECHAR = "fechar"; public static final String ITEMMENU_SOBRE = "sobre";

public static final String MENU_ARQUIVO = "arquivo"; public static final String MENU_AJUDA = "ajuda"; public static final String MENU_JANELA = "janela";

public static final String PREFIXO_JANELA = "Janela";

protected MenuBar barraMenu; protected Menu menuArquivo; protected Menu menuJanela; protected Menu menuAjuda;

// area interna protected JDesktopPane desktop;

public MDIPrincipal(String titulo){ super(titulo); init(); }

private void init(){ setSize(400,300); desktop = new JDesktopPane(); desktop.setPreferredSize(new Dimension(400,300)); setContentPane(desktop); // tratador de eventos anonimo addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent e) { setVisible(false); System.exit(0); } });

// cria os componentes para o menu barraMenu = new MenuBar(); menuArquivo = new Menu( MENU_ARQUIVO ); menuJanela = new Menu( MENU_JANELA ); menuAjuda = new Menu( MENU_AJUDA );

// cria os itens de menu MenuItem novo = new MenuItem( ITEMMENU_NOVO ); MenuItem fechar = new MenuItem( ITEMMENU_FECHAR ); MenuItem sair = new MenuItem( ITEMMENU_SAIR ); MenuItem sobre = new MenuItem( ITEMMENU_SOBRE );

// define o tratador de eventos dos itens de menu novo.addActionListener(this); fechar.addActionListener(this); sair.addActionListener(this); sobre.addActionListener(this);

// adiciona os itens aos menus menuArquivo.add(novo); menuArquivo.add(fechar); menuArquivo.addSeparator(); menuArquivo.add(sair);

menuAjuda.add( sobre );

Page 94: Aprendendo Java

// adiciona os menus a barra de menus barraMenu.add(menuArquivo); barraMenu.add(menuJanela); barraMenu.add(menuAjuda);

// adiciona a barra de menus ao Frame setMenuBar(barraMenu); }

public void exibir(){ setVisible(true); }

public void actionPerformed( ActionEvent e ) { String comando = e.getActionCommand();

if ( comando.equals( ITEMMENU_SAIR ) ){ setVisible(false); System.exit(0); }

if ( comando.equals( ITEMMENU_NOVO ) ) novo(); if ( comando.equals( ITEMMENU_FECHAR ) ) fechar(); if ( comando.equals( ITEMMENU_SOBRE ) ) sobre();

selecionarJanela( comando ); }

protected void selecionarJanela( String comando ){

Iterator iterator = listaJanelas.iterator(); MDIFilha filha = null;

while (iterator.hasNext()){ filha = (MDIFilha)iterator.next(); if ( filha.toString().equals( comando ) ){ filha.show(); filha.toFront(); try { filha.setSelected(true); } catch( Exception e ){ System.out.println(

"erro ao selecionar janela filha"); } break; } }

}

public void sobre(){ MDISobre j = new MDISobre( this ); j.show(); }

private int contadorJanelas = 1;

public void novo(){

atual = new MDIFilha( this, "Janela" + Integer.toString( contadorJanelas ++ ) );

Página 94

Page 95: Aprendendo Java

atual.reshape( 0, 0, 200, 100 );

// adiciona ao controle interno de janelas listaJanelas.add( atual );

// adiciona a area visivel da janela desktop.add( atual );

//exibe a janela atual.show();

//adiciona ao menu MenuItem filha = new MenuItem( atual.toString() ); filha.addActionListener(this); menuJanela.add(filha); }

public void fechar(){ if ( atual != null ){ atual.fechar(); } }

// metodos para o controle das janelas filhas

MDIFilha atual = null; Vector listaJanelas = new Vector();

public void abrindo( MDIFilha janela ){ atual = janela; }

public void fechando( MDIFilha janela ){ if ( janela == atual ) atual = null;

// remove da lista Iterator iterator = listaJanelas.iterator(); while (iterator.hasNext()){ if ( iterator.next() == janela ) iterator.remove(); } // remove do menu int maximo = menuJanela.getItemCount(); for( int n = 0; n < maximo; n ++ ){ if ( menuJanela.getItem(n).getLabel().equals(

janela.toString() )){ menuJanela.remove(n); break; } } }

public void minimizando( MDIFilha janela ){ if ( janela == atual ) atual = null; }

public void restaurando( MDIFilha janela ){ atual = janela; }

public void desativando( MDIFilha janela ){ if ( janela == atual ) atual = null;

Page 96: Aprendendo Java

}

public void ativando( MDIFilha janela ){ atual = janela; }}

MDIPrincipal.java

import java.awt.*;import java.awt.event.*;import javax.swing.*;import javax.swing.event.*;

/** * MDIFilha * exemplo de aplicacao MDI * janela base para criacao das janelas internas * * @author Hamilton Lima [email protected] * @version 17/11/2002 */public class MDIFilha extends JInternalFrame implements InternalFrameListener { MDIPrincipal dono;

public MDIFilha( Frame dono, String titulo ) { super( titulo, true, true, true, true ); setDefaultCloseOperation( WindowConstants.DISPOSE_ON_CLOSE ); addInternalFrameListener(this); this.dono = (MDIPrincipal)dono; }

public void fechar(){ setVisible(false); dono.fechando( this ); }

public String toString(){ return getTitle(); }

public void internalFrameClosing(InternalFrameEvent e) { dono.fechando( this ); }

public void internalFrameClosed(InternalFrameEvent e) { }

public void internalFrameOpened(InternalFrameEvent e) { dono.abrindo( this ); }

public void internalFrameIconified(InternalFrameEvent e) { dono.minimizando( this ); }

public void internalFrameDeiconified(InternalFrameEvent e) { dono.restaurando( this ); }

public void internalFrameActivated(InternalFrameEvent e) { dono.ativando( this );

Página 96

Page 97: Aprendendo Java

}

public void internalFrameDeactivated(InternalFrameEvent e) { dono.desativando( this ); }

}

MDIFilha.java

Page 98: Aprendendo Java

import java.awt.*;import java.awt.event.*;

/** * MDISobre * exemplo de aplicacao MDI * janela de ajuda com creditos da aplicacao * * @author Hamilton Lima [email protected] * @version 17/11/2002 */public class MDISobre extends Dialog {

public static final int LARGURA = 250; public static final int ALTURA = 150;

protected static String titulo = "sobre";

public MDISobre( Frame owner ){ super( owner, titulo, true ); setLayout( new GridLayout( 3, 1, 10, 10 ) );

// calcula para centralizar a janela Rectangle r = owner.getBounds(); int x = r.x + (int)((( r.width - r.x ) - LARGURA )/2); int y = r.y + (int)((( r.height - r.y ) - ALTURA )/2); reshape( x, y, LARGURA, ALTURA );

Label label = new Label("Exemplo de aplicacao MDI", Label.CENTER );

Label autor = new Label("www.athanazio.org 2002", Label.CENTER );

Button botao = new Button("Fechar"); botao.addActionListener( new ActionListener() { public void actionPerformed(ActionEvent e){ dispose(); } });

Panel panel = new Panel( new FlowLayout( FlowLayout.CENTER ) ); panel.add( botao );

add( label ); add( autor ); add( panel ); }}

MDISobre.java

Página 98