Programacao Orientada AObjetos 2010

ndice
Programao Orientada a Objetos (POO)..............................................................................................7 A programao Procedural................................................................................................................7 A Programao Estruturada...............................................................................................................8 A Programao Orientada a Objetos (POO)......................................................................................8 Descrio do Lpis .......................................................................................................................9 Descrio da Lapiseira..................................................................................................................9 Definindo a tecnologia Java.............................................................................................................13 Um pouco sobre a histria do JAVA...............................................................................................13 Caractersticas Importantes..............................................................................................................14 Portabilidade....................................................................................................................................15 O Class Loader.................................................................................................................................16 O Bytecode Verifier.........................................................................................................................16 A Java Virtual Machine...................................................................................................................17 A pilha, o heap e a JVM..................................................................................................................17 Como desenvolver em Java.............................................................................................................18 O JDK e alguns IDE's.................................................................................................................18 A sintaxe da linguagem Java...........................................................................................................19 Mtodos.......................................................................................................................................20 Declaraes.................................................................................................................................20 Expresses...................................................................................................................................20 Tipos de dados primitivos (Variveis).............................................................................................20 Textual........................................................................................................................................21 Lgico.........................................................................................................................................21 Integrais (inteiros).......................................................................................................................21 Ponto Flutuante...........................................................................................................................21 Literais.............................................................................................................................................22 Literais Boolean..........................................................................................................................22 Literais Char................................................................................................................................22 Literais Integrais (Inteiros)..........................................................................................................22 Literais de Ponto Flutuante.........................................................................................................23 Literais String..............................................................................................................................23 Palavras Reservadas.........................................................................................................................24 Variveis..........................................................................................................................................24 Declarando Variveis..................................................................................................................24 Variveis Membro e variveis Automticas...............................................................................25 Vetores.............................................................................................................................................26 Vetores de Objetos...........................................................................................................................27 Operadores Java...............................................................................................................................28 Precedncia.................................................................................................................................28 Ordem de Avaliao....................................................................................................................28 Os Operadores de Atribuio......................................................................................................29 Atribuindo Primitivos.................................................................................................................29 Atribuindo Inteiros......................................................................................................................29 Atribuindo Ponto Flutuante.........................................................................................................31 Atribuindo Variveis de Referncia............................................................................................31 Operadores lgicos de conexo...................................................................................................33 And: &&................................................................................................................................33 Or: ||........................................................................................................................................33 Conceito de Curto Circuito.........................................................................................................34 Os Operadores Unrios...............................................................................................................35 Operadores Unrios de Mais ou Menos: + - ..............................................................................35 H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 1
Operador de Inverso de Bits: ~ (Not bit a bit)...........................................................................36 O Operador de Negao Booleano: ! (Not).................................................................................36 O Operador Cast: (tipo) ..............................................................................................................36 Operadores Aritmticos..............................................................................................................37 O Operador +, Aritmtico ou Concatenador de Strings?...........................................................38 Os operadores de deslocamento (shift/rotate).............................................................................39 Os operadores de comparao.....................................................................................................40 O operador instanceof.................................................................................................................41 Os operadores de igualdade........................................................................................................42 Comparando objetos (referncias)..............................................................................................43 Comparando com equals........................................................................................................43 Comparando com hashCode...................................................................................................44 Os operadores de bits .................................................................................................................45 Operador ternrio........................................................................................................................46 Operadores de expresses reduzidas...........................................................................................46 Classes empacotadoras - emulam os tipos primitivos (wrappers)...................................................47 Usando as classes wrappers .......................................................................................................47 Antes do java 5.......................................................................................................................47 A partir do Java 5 (autoboxing e unboxing)...........................................................................47 Programando em Java...........................................................................................................................49 Princpios.........................................................................................................................................49 Qualificadores..................................................................................................................................49 Instrues de Programao Java...........................................................................................................50 Instruo switch...............................................................................................................................51 Instrues de controle de loops........................................................................................................52 Instruo for................................................................................................................................52 Variveis declaradas em Exp1....................................................................................................53 Instruo while............................................................................................................................54 Instruo do/while.......................................................................................................................55 Instruo break............................................................................................................................56 Instruo continue.......................................................................................................................57 Instruo for/each (enhanced for) ..............................................................................................58 Instrues rotuladas.........................................................................................................................59 Instruo break rotulado..............................................................................................................59 Instruo continue rotulado.........................................................................................................60 Instruo return................................................................................................................................60 Comentrios em Java.......................................................................................................................61 Escrevendo o primeiro programa (Console)....................................................................................61 Escrevendo o segundo programa (Console)....................................................................................62 Mtodos Especiais...........................................................................................................................63 O Mtodo Construtor..................................................................................................................63 Mtodo finalizadores...................................................................................................................64 Principais Caractersticas da POO........................................................................................................65 Encapsulamento...............................................................................................................................65 Sobrecarga ......................................................................................................................................68 Overriding (Sobrescrita)..................................................................................................................70 Herana (ou extenso).....................................................................................................................72 Consideraes sobre Herana.....................................................................................................75 Composio de classes comparada com Herana............................................................................76 Mtodos e Classes Abstratas...........................................................................................................78 Polimorfismo...................................................................................................................................78 Interface...........................................................................................................................................81 Tipos Genricos....................................................................................................................................84 Listas / Colees...................................................................................................................................85 H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 2
Usando listas....................................................................................................................................85 Usando listas navegveis (NavigableSet)........................................................................................87 Usando listas tipo Pilha (LinkedList)..............................................................................................89 Ordenando arrays.............................................................................................................................90 Ordenando arrays de objetos do cliente......................................................................................90 Navegando em listas com Interator e ListInterator..........................................................................93 Trabalhando com Map, HashMap e TreeMap......................................................................................94 O mesmo exemplo usando TreeMap..........................................................................................95 Classes e mtodos genricos................................................................................................................96 Um mtodo genrico........................................................................................................................97 Enumeraes.........................................................................................................................................98 Importao de constantes estticas.....................................................................................................101 Varargs: usando argumentos em quantidade varivel........................................................................103 Transformao de texto......................................................................................................................104 Executando programas externos.........................................................................................................105 Trabalhando com pacotes...................................................................................................................106 package..........................................................................................................................................106 Alguns pacotes Java disponveis...............................................................................................107 import.............................................................................................................................................107 Tratamento de Excees ....................................................................................................................108 O que tratamento de excees.....................................................................................................108 Conhecendo o funcionamento do bloco try/catch/finally..............................................................109 Um exemplo completo...................................................................................................................109 Disparando excees......................................................................................................................110 Tratando excees..........................................................................................................................111 Forando o tratamento de excees...............................................................................................113 Excees verificadas e no verificadas..........................................................................................113 Exemplos de excees Verificadas...........................................................................................114 Exemplos de excees No Verificadas...................................................................................114 Entendendo hierarquia das excees.............................................................................................114 Criando nossas prprias excees..................................................................................................116 Classe Internas....................................................................................................................................118 Classe internas annimas...............................................................................................................120 Algumas palavras reservadas 'avulsas'...............................................................................................120 synchronized..................................................................................................................................120 native..............................................................................................................................................120 strictfp............................................................................................................................................120 transient..........................................................................................................................................121 volatile...........................................................................................................................................121 O Uso do Ponto-e-Vrgula..................................................................................................................122 Threads...............................................................................................................................................123 Estados possveis de uma thread....................................................................................................124 Herdando da classe Thread ou de subclasses da classe Thread.....................................................124 Passando o objeto a ser executado como argumento de Thread....................................................125 Outro exemplo de thread...............................................................................................................126 O mtodo Sleep..............................................................................................................................127 O mtodo stop().............................................................................................................................128 Os mtodos getPriority() e setPriority().........................................................................................128 Usando Banco de Dados em Java.......................................................................................................130 Configurando o ODBC..................................................................................................................130 Estudando uma Conexo...............................................................................................................132 Testando a conexo........................................................................................................................133 Criando uma tabela........................................................................................................................133 Um exemplo completo...................................................................................................................134 H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 3
A superclasse Banco......................................................................................................................134 A interface BancoInterface............................................................................................................134 A Classe Conexao..........................................................................................................................134 A classe Pedido .............................................................................................................................136 Testando o nosso Banco................................................................................................................137 Modificando a tabela de Pedidos para trabalhar com Pedido/Item................................................138 A nova BancoInterface.................................................................................................................138 A Classe CriaTabelaPedido com nova estrutura............................................................................138 Criando a tabela PedidoItem..........................................................................................................139 A Classe PedidoItem......................................................................................................................139 Testando as classes de Pedido e PedidoItem.................................................................................141 GUI Interface Grfica com o Usurio..............................................................................................142 AWT Abstract Windows Toolkit................................................................................................142 Swing.............................................................................................................................................142 Usando objetos grficos.................................................................................................................142 Exemplo de uma GUI em Java......................................................................................................143 A GUI passo a passo (AWT).........................................................................................................144 Frame........................................................................................................................................144 Panel (Painis)...........................................................................................................................145 Usando Labels em Painis.............................................................................................................145 O TextField (Caixa de texto)....................................................................................................146 Botes........................................................................................................................................147 Interface Grfica + Banco de Dados...................................................................................................148 Modificando o Projeto para Inserir no Formulrio um Boto Sair ...............................................150 JavaServer Pages JSP......................................................................................................................153 JSP - Como Funciona? .................................................................................................................153 O Tomcat.......................................................................................................................................153 Instalando o Tomcat 5....................................................................................................................154 A estrutura de diretrios do Tomcat.........................................................................................155 O projeto Calculadora....................................................................................................................156 Aparncia final da interface grfica da calculadora..................................................................156 Cdigo do JSP correspondente.................................................................................................156 A Classe Calculadora.java........................................................................................................157 Classes JavaBean & Pginas JSP..................................................................................................158 Regras para construo e uso dos mtodos get/set....................................................................158 Construindo uma aplicao JSP usando o Eclipse e JSF...................................................................159 Criando o projeto: prjIMC.............................................................................................................159 A classe ControleIMC.java.......................................................................................................161 Configurando o servidor Tomcat no Eclipse............................................................................163 Bibliotecas Necessrias para utilizar o JSF...............................................................................165 Levantando o Tomcat...............................................................................................................166 A camada de apresentao Pgina JSP..................................................................................167 Configuraes...........................................................................................................................169 A extenso das pginas no web.xml.....................................................................................169 As classes Managed Bean no faces-config.xml...................................................................170 Escrevendo o cdigo JSF..........................................................................................................170 Resultado no navegador............................................................................................................172 Apndice.............................................................................................................................................173 Exemplos.......................................................................................................................................173 1 - Um exemplo de fluxo de caixa:...........................................................................................173 A classe Lanamento:...........................................................................................................174 A classe Caixa:.....................................................................................................................175 A classe de testes do Caixa..................................................................................................176 O resultado na console:........................................................................................................176 H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 4
2 - Um exemplo completo de um gerador Faturas...................................................................177 O diagrama de classes:.........................................................................................................178 A classe Codigo:...................................................................................................................179 A classe Pessoa:...................................................................................................................179 A classe PessoaFisica:..........................................................................................................179 A classe PessoaJuridica:.......................................................................................................180 A classe Cliente:...................................................................................................................180 A classe Vendedor:...............................................................................................................180 A classe Fornecedor:............................................................................................................180 A classe Item:.......................................................................................................................181 A classe Produto:..................................................................................................................181 A classe Fatura:....................................................................................................................182 A classe de teste:..................................................................................................................183 A sada do programa de teste:..............................................................................................184 Annotations....................................................................................................................................185 Criando annotations..................................................................................................................185 A interface:...........................................................................................................................185 A classe de tratamento da Annotation Requerido................................................................186 Testando a annotation Requerido:........................................................................................186 Padres de projeto..........................................................................................................................187 Singleton...................................................................................................................................187 Factory Method.........................................................................................................................189 Class Adapter............................................................................................................................191 Proxy.........................................................................................................................................193 Facade (faade).........................................................................................................................195 Observer....................................................................................................................................198 O padro Observer utilizando o pacote java.util.Observable...............................................201 MVC - Model View Controller ................................................................................................203 Java Reflection API.......................................................................................................................204 Classes e mtodos genricos ....................................................................................................204 Comparando tipos sem usar instanceof.....................................................................................205 Destrinchando a classe..............................................................................................................205 Explorando os Construtores......................................................................................................207 Explorando os atributos de uma classe.....................................................................................209 Invocando mtodos pelo nome..................................................................................................210 Instanciando novos objetos.......................................................................................................211 Alterando atributos de uma classe............................................................................................212 Testando uma aplicao usando o framework JUnit com Eclipse.................................................213 Configurando o Eclipse.............................................................................................................213 Nossa classe de teste de JUnit...................................................................................................216 Forando erros ..........................................................................................................................217 JNI Java Native Interface............................................................................................................218 Verificando o desempenho do JNI com IO...............................................................................221 Verificando o desempenho do JNI usando ponteiros................................................................223 Usando mtodos e propriedades de objetos do programa Java em um JNI..............................224 Usar ou no usar JNI?...............................................................................................................227 Java e Qualidade de Software.............................................................................................................228 Otimizaes...................................................................................................................................228 Conhea a Biblioteca Java.............................................................................................................228 Respeite as convenes de nomeao............................................................................................228 Utilize Excees criteriosamente...................................................................................................228 Cuidados com Concatenao de Strings........................................................................................229 Exerccios...........................................................................................................................................232 A classe Calculadora......................................................................................................................232 H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 5
Testando a Calculadora.............................................................................................................232 A classe Cliente.........................................................................................................................233 Testando o Cliente................................................................................................................234 A classe Banco..........................................................................................................................235 A Classe Agencia......................................................................................................................237 Trabalhando com interface........................................................................................................237 A interface ContaDefault..........................................................................................................238 Modificando a Classe Agencia..................................................................................................238 Mais modificaes na classe Agencia.......................................................................................239 Testando a aplicao Bancria..................................................................................................240 Usando uma interface grfica....................................................................................................241 Gabaritos........................................................................................................................................245 Gabarito da classe Cliente.........................................................................................................245 Gabarito da classe Banco..........................................................................................................246 A Interface ContaDefault..........................................................................................................248 Gabarito da classe Agencia.......................................................................................................248 Bibliografia.........................................................................................................................................254
H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 6
Programao Orientada a Objetos (POO)

Quando tudo comeou, os computadores eram programados por intermdio de uma borneira (Parecida com as mesas telefnicas de antigamente) onde o programador conectava um cabo de um borne a outro. Ningum merece... A melhorou... de borneira evoluiu para um teclado (Parecido com um de piano) onde o programador "digitava os bits palavra por palavra. Os "nmeros digitados podiam ser instrues de programa em linguagem de mquina ou dados. At aqui no existia uma linguagem de programao da forma que conhecemos hoje. A programao era feita diretamente na linguagem de mquina. Apareceu primeiro a linguagem ASSEMBLY. Esta linguagem, muito perto da linguagem de mquina, usava (e ainda usa) mnemnicos para substituir as instrues de mquina. Os dados eram escritos em texto codificados em ASCII. Isto permitiu um grande avano. Era possvel analisar e alterar os programas olhando para alguma coisa que fazia sentido para ns humanos. Os programas Assembly so conhecidos como 'linguio'. possvel, mas nada simples, entender e dar manuteno em um programa escrito em assembly... Abaixo um trecho exemplo de cdigo assembly: INICIO: LOOP: MVI MVI MOV ADD INC CPI JNZ LXI A,00H B,10H C,A B C 100H LOOP H,0100H ' Coloca zero no acumulador ' Coloca 10H no registrador B ' Zera o contador C ' Soma o valor do B no acumulador ' Incrementa em um o registrador C ' Compara o contedo do Acumulador com 100H ' Salta se no zero (diferente) para o label LOOP. ' Coloca no par HL o endereo 0100H
S como diverso: Qual seria o valor de C ao sair do loop? ................................................................................................................................................................ A programao Procedural Apareceram as linguagens redentoras de "alto nvel: COBOL para aplicaes comerciais e FORTRAN para as cientficas. Foi uma grande revoluo. Ambas linguagens ainda existem e ainda esto bastante vivas. Apesar da grande aproximao das novas linguagens (COBOL e FORTRAN) com a linguagem humana, ainda descabelam muita gente. A principal desvantagem era (e ainda ) a dificuldade de manuteno. Acompanhar e compreender o fluxo de programao em um cdigo procedural um verdadeiro desafio para a mente e para a pacincia. As linguagens procedurais permitem que o programador interrompa o fluxo do programa em qualquer lugar e mande continuar tambm em qualquer outro lugar (estamos falando do famigerado GO TO). Outros problemas srios so: Dificuldade de reutilizar cdigo, portabilidade complicada devido principalmente a forte dependncia da linguagem ao hardware e as numerosas 'mutaes' de cada uma. Cada fabricante de compilador 'contribui' com sua prpria 'verso' da linguagem. A principal caracterstica da programao procedural o fluxo do programa seguir linha a linha, e quando necessrio, mudar seu fluxo por meio de instrues de desvio (condicionais ou no). A palavra procedural vem de procedimentos. Portanto so linguagens voltadas a procedimentos: Exemplos de comandos de procedimento: Incremente, decremente, some, escreva, leia, procure, imprima, grave, digite, mostre, compare etc. H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 7
A Programao Estruturada Linguagens como C e Pascal foram as mais populares linguagens estruturadas que apareceram. Ambas permitem que o programa seja modularizado, de forma que possvel alguma reutilizao e boa organizao. O comando GO TO foi praticamente banido das linguagens estruturadas. A engenharia de software havia aprendido muito com as antecessoras da programao estruturada. Tanto Linguagem C quanto Pascal se preocuparam em se manter ntegras sem grandes variaes entre compiladores. Foram padronizadas pelo comit ANSI e at hoje so ferramentas poderosas e muito utilizadas. As principais caractersticas da programao estruturada a possibilidade de criar variveis de escopo local (a blocos e funes) e permitir programao modular (procedures, functions etc). O Visual Basic uma linguagem considerada hbrida. Ao mesmo tempo em que possui algumas caractersticas procedurais herdadas de sua antecessora (Basic), tambm oferece poderosos recursos de programao orientada a objetos. Mesmo assim, consideramos que Visual Basic est mais para uma linguagem estruturada voltada eventos. Hoje o Visual Basic est descontinuado e seu fabricante, a Microsoft est estimulando seus usurios a migrarem para o VB.net. A Programao Orientada a Objetos (POO) Finalmente chegamos aqui... As linguagens antecessoras da Programao Orientada a Objetos (POO) tentaram se aproximar da maneira de pensar e agir do ser humano. Ns vivemos proceduralmente. Nos planejamos para fazer uma coisa depois da outra em um fluxo lgico e natural. As vezes somos interrompidos mas logo que liberados tentamos retomar a atividade do ponto em que foi suspensa. Tudo que fazemos tem um incio e (quase sempre) um fim bem determinado. A programao estruturada, na realidade, uma programao procedural encapsulada em funes e subrotinas. Continuamos pensando proceduralmente mas agora dentro de subrotinas... A POO veio para chutar o pau da barraca. Agora o modelo de pensamento humano no mais o principal modelo. Agora estamos tentando "pensar usando a lgica da natureza. A natureza no tem nada de procedural. Tudo acontece ao mesmo tempo e a interao entre as coisas total. Na natureza praticamente no existem fatos isolados. As coisas se interagem... Na tentativa de trazer a natureza para a programao, no tem jeito, temos que tentar restringir as coisas para que no fique complicado demais para compreender (abstrao!). A primeira coisa dar um nome para coisa. Coisa, de agora em diante ser chamada de objeto. Todas as coisas so objetos. Todos os objetos que podemos reconhecer como tal possuem caractersticas comuns que nos permite identific-los, ou melhor, classific-los. Sabemos que um lpis um lpis talvez por geralmente serem de madeira, podem ser apontados... podem ser usados para escrever pois em seu interior sempre existe alguma coisa que risca... grafite, cera colorida, carvo... Mas podem ser de cores, comprimento, espessura diferentes... ter ou no borracha na outra ponta... Intuitivamente notamos que existem muitas caractersticas comuns nos lpis. Se ns recebssemos a tarefa de escrever uma especificao de um lpis poderamos preparar alguma coisa mais ou menos assim:
Descrio do Lpis Propriedades:

Cor da pintura externa; Tipo de seo (Cilndrico, hexagonal, pentagonal etc); Tipo do material do corpo do lpis (Madeira, plstico, cera, papel etc); Cor do material que escreve; Tipo de material que escreve; Cdigo de "maciez do material que escreve; Comprimento quando novo; Dimetro externo; Tem borracha ou no. Apontar; Escrever; Apagar (Caso tenha borracha).
Funcionalidades:

Esta descrio do lpis nos permite identificar um lpis quando o vemos. Temos a o projeto de uma classe. Isso mesmo, uma classe um projeto de objetos contendo a descrio de suas propriedades e funcionalidades (ou de agora em diante, mtodos). Um fiscal da receita pode usar esta descrio de lpis para saber que tipo de imposto cobrar para um produto com exatamente estas propriedades e mtodos. Mas, e uma lapiseira... Uma lapiseira um lpis? Olhando as propriedades... quase tudo bate. Mas podemos identificar facilmente alguns mtodos que a lapiseira tem a mais: Uma lapiseira pode regular o comprimento do "grafite. Precisamos possuir um mtodo para alimentar a lapiseira de novos "grafites. Podemos tambm encontrar algumas propriedades a mais: Dimetro do grafite, ter ou no um "clip. Mas percebemos intuitivamente que uma lapiseira no fundo um lpis incrementado ou para usar um termo mais tcnico, "estendido. Descrio da Lapiseira basicamente um lpis com as seguintes novas propriedades e mtodos: Propriedades:

Dimetro do grafite; Clip Tem ou no. Sistema de avano do grafite; Sistema de alimentao de novos grafites.
Mtodos:

Assim, acabamos de perceber que podemos estender classes. J sabemos como , e para que serve um lpis. Uma lapiseira um lpis incrementado. No necessrio pensar tudo do zero... Aproveitamos o projeto j consagrado do lpis para projetar um novo objeto. A Lapiseira. Esta uma das principais caractersticas da POO. Herana e reutilizao de projetos j existentes e consagrados para desenvolver novos projetos de outros objetos de caractersticas semelhantes aproveitando os anteriores como ponto de partida.
Um exemplo ilustrativo de orientao a objeto da natureza, so as classes, famlias e espcies dos seres vivos. Sem muita preocupao com o rigor cientfico, vejamos o exemplo da hierarquia da vida: Seres Vivos Animais Vertebrados Mamferos Primatas Homens Chimpanzs Orangotangos Gorilas Cetceos Candeos Bovinos Equinos Sunos Aves Peixes Rpteis Batrquios invertebrados Insetos Artrpodes Crustceos Moluscos Aracndeos Escorpies caros Vegetais O que vemos que o homem herdou mtodos e propriedades de seus antecessores na hierarquia da vida. O mtodo reprodutor humano, por exemplo, idntico em todos os mamferos. Nossa coluna vertebral praticamente idntica a todos os nossos colegas vertebrados. Nossos olhos no so muito diferentes dos olhos das aves ou dos rpteis. A natureza simplesmente copiou os projetos j aprovados e consagrados de classes anteriores. Isso o uso de herana na sua forma mais fantstica. Nesta altura voc deve estar pensando: Pera a.. o olho de uma baleia MUITO maior que o nosso. Os olhos das guias podem perceber detalhes que os nossos no podem... Os ces sentem cheiros e ouvem sons que ns no ouvimos... ... mas se observarmos bem, as propriedades so as mesmas... s mudam os valores a elas associados... Os olhos das guias e os narizes dos ces possuem mais clulas que os nossos. Mas o projeto das clulas so exatamente os mesmos. S muda a quantidade, ou seja, varia o valor da propriedade. Os mtodos, ou seja, as funcionalidades, so exatamente as mesmas. A existncia do olfato e da viso so os mtodos e esto presentes em todos os mamferos. As diferenas ficam por conta dos valores das propriedades. Uma girafa tem o mesmo nmero de vrtebras no pescoo que um camundongo... O que varia (e como!) o tamanho de cada uma (propriedade). H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 10
Resumindo a classe dos mamferos: Algumas propriedades:
Tamanho, cor, quantidade, forma, dimenses, massa; Viso, olfato, audio, locomoo, reproduo, tato, circulao, digesto;
Alguns mtodos:
O que temos de comum com os gorilas, assim como eles, herdamos 100% da classe dos primatas. A natureza derivou (ou estendeu) vrias outras classes, dentre elas a nossa. Naturalmente que a nossa classe (humana) possui mtodos que a dos gorilas, por exemplo, no possuem. Talvez raciocnio... ambio... habilidade motora... At aqui estamos falando de classes. As classes so as especificaes dos seres (objetos). Uma vez feito o projeto possvel dar incio ao processo de criao de objetos... Os objetos so entidades reais que podem fazer as coisas acontecerem. A grosso modo, as classes so apenas as especificaes sem nenhuma consistncia material. Considerando tudo isso, o homem, compreendendo a maneira como a natureza construiu a vida, concluiu que se desejasse um dia conseguir copiar a natureza, teria que construir suas ferramentas da forma como a natureza funciona: Orientada a objetos. Como dissemos no incio, no estamos acostumados a projetar nossas solues de forma orientada a objetos... Talvez seja esta uma das principais dificuldades para migrar de programao convencional (procedural ou estruturada) para POO. De qualquer forma vivemos em um mundo repleto de objetos que pertencem a alguma classe. Devemos procurar compreender como o mundo funciona e tentar modelar as solues da forma mais intuitiva possvel pensando que, seja l qual for o problema, temos objetos se interrelacionado das mais diversas formas. Os processos nos Sistemas OO so realizados atravs da troca de mensagens ou aes entre os objetos envolvidos. Um exemplo de parte de um sistema envolvendo dois objetos poderia ser o movimento de quantias em um determinado caixa. Podemos estabelecer facilmente a relao entre as "entidades envolvidas: Os diversos clientes e o caixa. Os objetos da classe Cliente, ze e pedro so identificados (atributos) pelo seu nome completo. O objeto da classe Caixa, cx criado com um valor inicial de R$1000.00 como seu nico atributo. Os mtodos credita() e saque() pertencem a classe Caixa enquanto o mtodo mostraNome() est definido na classe Cliente. As linhas abaixo ilustram, a criao dos objetos a partir das classes Cliente e Caixa. Cliente joze = new Cliente("Antnio Jos da Silva"); Cliente pedro = new Cliente("Pedro Paulo"); Caixa cx = new Caixa(1000.00); Alguns movimentos sobre o caixa poderiam ser realizados assim: cx.credita (pedro,250.50); cx.saque (joze,120.20); cx.saque (pedro,230,75); Alguns exemplos de utilizao dos mtodos definidos nas classes Cliente e Caixa. cx.mostraSaldo(); cx.mostraExtrato(joze); cx.mostraExtrato(pedro); joze.mostraNome(); pedro.mostraNome(); // // // // // Mostra Mostra Mostra Mostra Mostra o o o o o saldo em caixa movimento do Jos movimento do Pedro nome do cliente Antnio nome do cliente Pedro
Porque Java? Quando Java apareceu, o mundo da programao estava com alguns dilemas muito srios:
Apesar de existir uma tecnologia orientada a objeto j a muito tempo, os projetistas de software relutavam em adot-la por acharem muito complexa. Afinal se podemos fazer tudo com a velha e boa programao procedural/estruturada... porque mudar de paradigma? Os diversos tipos de computadores e sistemas operacionais foravam que os aplicativos tivessem que ser reescritos pois os programas precisavam tratar caso a caso as diferenas entre as diversas plataformas. A linguagem C++ era a nica 100% orientada a objeto que podia ser usada para desenvolver aplicativos de alta qualidade e performance. Contudo os bons programadores de C++ no so fceis de encontrar e erros de programao so difceis de localizar e de "curar. Alm disso, o desenvolvedor, mesmo usando C++, pode escrever um programa 100% procedural e/ou estruturado, sem declarar uma nica classe... As tecnologias desenvolvidas para WEB so uma verdadeira torre de babel. possvel misturar em um mesmo sistema para WEB tecnologias como: HTML, XML, ASP, PHP, CGI, VB Script, Java Script e o que mais aparecer... (Coloque neste caldeiro tambm toda a famlia .Net ) Tudo isso sem a menor preocupao com documentao, reutilizao de cdigo, ferramentas de depurao alm de um tratamento de excees muito precrio. Java mais simples e mais seguro que C++. O empresrio da rea de fabricao de software logo notou que Java tinha a estrutura de C++, com sua elegncia e formalismo mas sem os principais pontos crticos de segurana e complexidade. Java, entre outras simplificaes, no tem ponteiros e, impede em tempo de execuo, que ocorra invases de memria... o que, por sinal, o principal motivo de bugs em C++. Java, ao contrrio de C++, no permite uma linha sequer que no seja POO. A prpria estrutura da linguagem incentiva e facilita a reutilizao de cdigo. Java , de longe, a tecnologia de programao mais porttil que se pode conceber. A idia foi inspirada no Browser usado para navegar na WEB. Cada plataforma (hardware & SO) tem o seu "interpretador para rodar os programas Java. Desta forma basta instalar este "interpretador no novo ambiente para que tudo que tenha sido escrito em Java rode perfeitamente. possvel desenvolver sistemas para WEB praticamente 100% dentro da tecnologia Java (incluindo o Javascript), tanto para rodar no servidor quanto no cliente. Assim, podemos diminuir o leque de tecnologias utilizadas, facilitando muito a manuteno e documentao dos sistemas. Como foi visto, no existe exigncia de que o servidor tenha que rodar este ou aquele sistema operacional (Como o caso de Asp.NET por exemplo) Um possvel concorrente de Java, que seria o pacote da Microsoft.Net, logo de cara s roda em ambiente windows!!! Zero de portabilidade. O profissional com conhecimentos de Java hoje o mais procurado pelo mercado. O salrio/hora do analista/programador Java chega a ser o dobro do valor de um especialista em VB/ASP. Poderosos caciques da informtica como Sun (recm adquirida pela Oracle) e IBM investem muitos milhes na consolidao da tecnologia Java... E por ltimo, um detalhe realmente muito importante: Java uma tecnologia 100% gratuita. Muitas IDE's de grande qualidade so disponibilizadas sem nenhum nus para os usurios. Novas atualizaes so sempre colocadas a disposio de todos com uma farta documentao e muitas vezes incluindo os cdigos fonte (open source).
Java trouxe solues para todas estes dilemas:
Definindo a tecnologia Java Segundo a Sun, a Tecnologia Java :

Uma linguagem de Programao Um ambiente de Desenvolvimento Um ambiente de Aplicao Um ambiente de Deployment
similar em sintaxe ao C++ e similar em semntica ao SmallTalk utilizada para desenvolver aplicaes para a arquitetura Cliente Servidor, para ambientes Mveis e para a Internet. Um pouco sobre a histria do JAVA. Em 1991 um grupo de projeto da Sun, denominado Green, pesquisava formas de desenvolver uma nova gerao de computadores portteis com chips de aplicativos para os mais variados tipos de equipamentos, tais como, aparelhos domsticos, pdas (Palms, micros portteis) , etc.. A equipe liderada por James Gosling, inicialmente utilizou C++ aproveitando o conhecimento e a experincia do grupo, mas logo percebeu que seria necessrio criar uma nova linguagem de programao. Como resultado, em 1990, Gosling projetou a linguagem Oak (carvalho em ingls), batizada assim, pela viso que tinha de uma destas arvores em sua janela do escritrio. Nesta poca foi desenvolvido tambm o Green OS e uma interface grfica padro. Em 1993 surge a primeira oportunidade de aplicao da nova linguagem em uma concorrncia de TV a cabo interativa. O projeto de construo do prottipo durou dois anos e consumiu milhares de dlares. A concorrncia foi injustamente vencida pela SGI e o financiamento estava para ser cortado e a equipe transferida quando a Sun, motivada pelo crescimento explosivo da Internet, desenvolve o browser WebRunner, capaz de efetuar download e executar pequenas aplicaes Java. Em maio de 1995 o navegador, rebatizado como HotJava, e a linguagem Java foram formalmente apresentadas no SunWorld95. Este evento despertou o interesse da Netscape, que no incio de 1996, lana o Navigator 2.0 apto a baixar e executar pequenos applets*. Ainda em 1996, a Sun de forma indita, disponibiliza gratuitamente o JDK 1.02 (Kit de Desenvolvimento Java) para as plataformas Win95/NT e Solaris e posteriormente para as demais plataformas. Atualmente os JDK's so atualizados continuamente e novas API's surgem frequentemente facilitando o desenvolvimento de aplicaes especficas. Mais adiante mostraremos o exemplo de um relgio instalado em uma pgina HTML.
Um applet um pedao de cdigo escrito em Java que roda diretamente no browser. Ele normalmente carregado a partir da pgina HTML. (Veja o exemplo de carga de um applet abaixo)
<applet code="DataHora.class" width=480 height=32>
Caractersticas Importantes Como comentamos, a sintaxe do Java similar a da linguagem C++, no andar de nosso curso diversos pontos sero facilmente relacionados ao conhecimento. Evidente que veremos inmeras diferenas tambm. Para exemplificar, podemos citar que no Java as caractersticas do C e C++ abaixo foram retiradas:

Typedefs, Includes, Defines (no temos mais o preprocessador); Estruturas e Unies. (As estruturas viraram classes. As unies morreram mesmo); Funes independentes. (No temos mais funes. Apenas mtodos); Herana mltipla. (Para diminuir a complexidade); Comando de desvio goto. (Em C/C++ existia. Sabia?); Sobrecarga de operadores. ; (Pena. !!! Provavelmente a idia foi simplificar...); Ajuste automtico de tipos. (Melhora a segurana, mas complica um pouco sua vida); Ponteiros. (Para melhorar a segurana contra bugs tipo invaso Melhora a robustez).
Para alguns, no usar ponteiros uma beno. No vamos entrar no mrito do que melhor ou mais poderoso. Esta introduo foi apenas para ajudar a desmistificar a complexidade normalmente atribuda ao Java. Apesar de extensa e abrangente, a Tecnologia Java Sun tem uma proposta simples e robusta para nos auxiliar em muitos aspectos na rea de desenvolvimento de softwares, dentre os quais podemos salientar: Ela nos prov uma linguagem 100% Orientada a Objeto (POO);

O ciclo de desenvolvimento muito mais rpido, j que a tecnologia interpretada; Suas aplicaes so (o mximo possvel) portveis para mltiplas plataformas; As aplicaes so seguras e robustas porque o JRE (Java Runtime Enviroment) gerencia a memria impedindo invases; As aplicaes grficas conseguem uma boa performance suportada por multi threading; As aplicaes so adaptveis mudana de ambiente por serem capazes de realizar dinamicamente o download de mdulos de cdigo de qualquer lugar da rede; Suas aplicaes so seguras, pois o JRE (Java Runtime Enviroment) possui muitos mecanismos embutidos de proteo anti vrus.
De maneira macro, podemos dizer que a Tecnologia Java composta por:

Uma Linguagem de Programao; Ambientes de Desenvolvimento; Ambientes de Aplicao; Ambientes de Instalao/Configurao;
E est organizada nas seguintes reas:

J2SE (Java to Standard Edition - Core/Desktop); J2EE (Java to Enterprise Edition - Enterprise/Server); J2ME (Mobile/Wireless); Java Card; Java Web Services; XML (eXtensible Markup Language); Jini (Rede - Facilita a computao distribuda); JXTA (juxtapose padro para comunicao entre dispositivos ); JSLEE (Java Service Logic Execution Environment - Telecomunicaes); etc
Portabilidade Com o Java ns poderemos estender em muito os nossos conhecimentos e criar todos os tipos de aplicao que criaramos em outras linguagens convencionais de programao, nas plataformas mais distintas e com uma portabilidade sem igual. Tal portabilidade vem do fato que os cdigos fontes Java so compilados para cdigos intermedirios, chamados bytecodes. Os bytecodes so instrues especficas para a Java Virtual Machine (JVM) e totalmente independentes de Hardware / Sistemas Operacionais. A JVM tem como principais incumbncias os trabalhos de interpret-los e execut-los no ambiente desejado, para tanto, existem implementaes de JVM's para os principais sistemas operacionais, tais como: MS Windows, Linux, MacOS, Solaris, PalmOS etc...
meuPrograma.java
meuPrograma.class
Compilador
Interpretador
Desta forma um programa Java no tem contato com o Hardware, ele apenas conhece a JVM.
O Java segue, com algumas excees, o lema "write once, run everywhere, ou seja, desde que o computador tenha uma JVM "certificada Sun instalada, ele pode executar bytecodes que foram gerados em computadores com conjunto hardware & SO totalmente distintos. A ttulo de ilustrao, o primeiro pargrafo do bytecode gerado com a compilao do cdigo acima.
Esta proposta de arquitetura da JVM muito arrojada, mas acaba tornando um pouco mais lenta a execuo dos programas Java. Entretanto, o que perdemos em velocidade ganhamos em portabilidade e segurana. Veja a ilustrao abaixo: Compilando Em Tempo de Execuo
Class Loader
Programa.java
javac
NetWork
Byte Code Verifier
Programa.class
Interpreter Runtime Hardware
Os arquivos fontes .java so compilados pelo comando javac e convertidos em bytecodes em arquivos .class. Em tempo de execuo o programa Java carregado, checado e executado com o intermdio de um interpretador. O interpretador executa os bytecodes enviando os comandos interpretados para o hardware. A Sun denomina este ambiente como JRE Java Runtime Enviroment, responsvel em fornecer as API's Java, a JVM (Java Virtual Machine) e outros componentes necessrios para rodar applets e aplicaes escritas em Java. Vamos falar um pouco mais sobre cada um deles. O Class Loader Tem o propsito de carregar todas as classes necessrias para a execuo do programa, mantm as classes locais em "namespaces separados dos arquivos carregados remotamente, limitando assim a ao de trojans (malwares de e-mails). Previne os programas de spoofing (truques para obter login e senha do usurio de sistemas WEB), uma vez que o layout de memria do arquivo executvel determinado somente aps o carregamento de todas as classes, ou seja, esse trabalho feito em tempo de execuo, protegendo o acesso no autorizado s reas restritas de cdigo na memria. O Bytecode Verifier Realiza testes antes de rodar o aplicativo, verificando se:

O cdigo adere especificao da JVM (Java Virtual Machine); O cdigo no viola a integridade do sistema; O cdigo no causa stacks overflows ou underflows; Os tipos de parmetros para todos os cdigos operacionais esto corretos; No h converses ilegais de tipos e cdigo.
Todas as classes importadas por meio da network passam pela verificao do Bytecode Verifier.
A Java Virtual Machine Simplificando, a JVM determina o que os programas Java podem ou no fazer. Os programas escritos em linguagens compiladas, como C ou C++, so executados diretamente pelo sistema operacional, assim sendo, eles tm acesso direto a todos os recursos do sistema, incluindo a memria e sistema de arquivos. Por sua vez, os programas Java so executados de dentro da JVM que tem o poder de decidir o que um programa Java tem permisso ou no de realizar no computador. A mquina virtual age como um intermediador entre o hardware e o programa Java. Um programa Java no acessa diretamente os dispositivos de entrada e sada, o sistema de arquivos ou mesmo a memria do seu computador. Em vez disso, ele pede que a Mquina Virtual o faa. Esta a principal razo do Java no ter implementado ponteiros. Como j comentamos, todos estes passos tornam a execuo um tanto mais lenta, mas em alguns ambientes, uma poro do cdigo pode ser compilada para o formato nativo e executada diretamente pelo hardware da plataforma. Este papel realizado pelos compiladores just-in-time que so invocados na primeira chamada de um programa em bytecodes. O cdigo inicialmente interpretado e posteriormente traduzido para cdigo-nativo. Nas prximas chamadas aos mtodos do programa o cdigo-nativo ser executado diretamente, aproximando o desempenho ao encontrado nas aplicaes C++, exceto por um pequeno delay no tempo de carregamento do programa. O diagrama abaixo ilustra o mecanismo de compilao, carga e execuo de aplicaes Java
Fonte: Gerncia de Memria em Java Parte I Hlder da Rocha (argonavis)
A pilha, o heap e a JVM Do ponto de vista de um programador Java, as reas de memria virtual conhecidas como a pilha e o heap so lugares imaginrios na memria de um computador. No interessa nem adianta saber onde esto. Java no oferece opes de escolha: tipos primitivos ficam na pilha e objetos ficam no heap. Implementaes da especificao da JVM, (como a HotSpot JVM), oferecem parmetros que permitem algum controle sobre a gerncia de memria. Conhecer as escolhas de algoritmos e arquitetura da mquina virtual usada importante para saber como configur-la e quais parmetros ajustar para obter melhor performance. Ainda assim, o controle limitado e no existe, em Java, a disciplina gerncia de memria como existe em C /C++
Como desenvolver em Java Para o desenvolvimento de aplicaes simples em Java, ns precisamos apenas de um JDK (Java Software Developers Kit) da verso Standard Edition (SE) e um editor de texto ASCII. O JDK e a documentao de suas bibliotecas podem ser baixadas em: http://java.sun.com/products/jdk/ Em sua estao de trabalho em casa ou no trabalho, faa o download da verso mais atual ou de uma verso superior a 1.2.2. O JDK e alguns IDE's O JDK possui o compilador Java "javac, JVM "java, um visualizador de applets "appletviewer, as bibliotecas de desenvolvimento "os pacotes java, um programa para documentao "javadoc, um depurador "jdb e uma verso do ambiente de execuo "jre. Quanto ao editor de texto, no percam tempo utilizando editores como o Notepad. IDE's especialmente desenvolvidas para programao e livres de licena, so facilmente encontradas na Internet. Abaixo algumas das mais utilizadas: Eclipse JEdit JCreator LE GEL NetBeans - www.eclipse.org - www.jedit.org - www.jcreator.com - www.gexperts.com - www.netbeans.org
Mesmo com os editores mais simples, os passos para o desenvolvimento de pequenos aplicativos Java so bastante simples e podem ser descritos em: 1. Instale o JDK da Sun seguindo cuidadosamente as instrues do Setup 2. Edite (sem modificar nada!) o programa abaixo e salve-o com a extenso ".java"
3. public class SantosFC { public static void main(String args[]){ } System.out.println("Santos
Campeo Paulista 2010 !")
4. Compile no Prompt do MS-DOS com o comando:
javac SantosFC.java
5. Caso necessrio, corrija erros no arquivo ".java e recompile Uma compilao sem erro resulta no arquivo SantosFC.class 6. Execute o programa no prompt com o comando: java [opes] SantosFC.class ou Java SantosFC
A sintaxe da linguagem Java Um programa em Java constitudo apenas por classes. As classes, por sua vez, so formadas por propriedades e mtodos. Os mtodos so formados por variveis, comandos e expresses. Propriedades e variveis no so rigorosamente a mesma coisa. Mas compartilham a caracterstica de armazenar coisas e necessitarem de declarao de tipo, visibilidade etc. Apenas para organizar nosso pensamento, vamos estudar a sintaxe de Java seguindo a hierarquia abaixo:
Classes (Interfaces) Propriedades Mtodos Declaraes Expresses Variveis Operadores Literais Comandos Chamadas de mtodos Propriedades
As propriedades (ou variveis de instncia, ou variveis membro) podem ser variveis Java ou objetos de alguma outra classe. Em UML as propriedades so conhecidas como Atributos. Tambm podemos declarar arrays de variveis ou de objetos como propriedades. A declarao de uma propriedade deve ser feita dentro do corpo da classe. As declaraes de propriedades seguem as mesmas regras das declaraes de variveis (que veremos mais adiante). A diferena bsica entre uma declarao de varivel e uma declarao de propriedade que nas propriedades normalmente declaramos usando um qualificador (Veja: Qualificadores); Em Java, quando declaramos uma propriedade mas no inicializamos, elas sero inicializadas automaticamente com zero se forem numricas e com string vazio se forem tipo String. Podemos declarar uma propriedade constante. Para tal usamos o qualificador final. (Veja: Qualificadores ) Exemplos: static private int valor; public double a = 4; private long valor = 45; private String nome = "Maria;
Mtodos Os mtodos so os executores do servio. O conceito do mtodo ser uma derivao da idia das funes de C e C++. Formalmente funcionam como funes, recebendo argumentos, processando e retornando valores. As principais diferenas entre funes e mtodos que estes devem ser chamados sempre associados ao objeto a quem pertence e podem compartilhar propriedades com outros mtodos da mesma classe. A grande maioria dos mtodos so responsveis pela atribuio ou obteno de valores para as propriedades (mtodos get/set) ou clculo de valores obtidos a partir dos valores encontrados nas propriedades. Declaraes Podemos declarar variveis e objetos internamente aos mtodos. Como nas funes estas variveis no podem ser usadas fora do corpo do mtodo onde foram declaradas. No caso de variveis e/ou objetos internos ao mtodo no podemos usar alguns dos qualificadores como static, private e public. No caso de variveis locais aos mtodos, no existe a inicializao implcita como no caso das propriedades. Java exige que a varivel seja inicializada antes de seu uso (ocorre um erro de sintaxe). Esclarecendo: No existe erro de compilao se declaramos uma varivel sem inicializao. S no podemos us-la antes de colocar algum valor l. Exemplos: int a = 12; double x = 3.88; long valor; final double pi = 3.1415926535; boolean existe; Expresses As expresses em Java sempre retornam um valor. O valor retornado ter o tipo da varivel ou literal mais complexo encontrado na expresso. O operador cast, se usado, pode modificar o tipo do retorno na expresso. Tipos de dados primitivos (Variveis) O Java possui oito tipos de dados primitivos, subdivididos em: Textual Lgico Integral Ponto Flutuante char boolean byte, short, int, e long double e float Tipo boolean byte int float char short long double Bits 8 (Usa apenas 1) 8 32 32 16 16 64 64
Abaixo eles esto relacionados com os respectivos tamanhos definidos na especificao Sun.
Textual Para quem conhece C/C++, podemos notar algumas diferenas. Por exemplo, o tipo char foi substitudo pelo tipo primitivo byte. O tipo char continua sendo um inteiro, mas sem sinal e agora com 16 bits, ou seja, com uma faixa de 0 a -1.
Obj00DFD2B6
Esta alterao deve-se ao fato do Java basear seus dados de caracteres padro Unicode que admite caracteres internacionais. Desta forma, possvel representar 32.768 caracteres diferentes. Caso os oito bits mais significativos (bits do lado esquerdo) de um char forem 0, ento este char representa um caractere ASCII (American National Standard Code for Information Interchange), padro americano para apresentao de smbolos com 8 bits. Lgico O tipo lgico boolean s capaz de assumir os valores literais true e false. No existe nenhuma outra relao de valores aceitveis, ou seja, falso e verdadeiro no podem ser representados por zero e valores diferentes de zero, como em C/C++. Integrais (inteiros) Os quatro tipos de dados inteiros ou integrais so nmeros internamente representados em complemento de dois, armazenando valores dentro dos seguintes intervalos: 08 16 32 64 bits bits bits bits byte short int long
Obj00DFD2B7
Obj00DFD2B9
Obj00DFD2BB
Obj00DFD2BD
at at at at
-1
Obj00DFD2B8
-1
Obj00DFD2BA
-1
Obj00DFD2BC
-1
Obj00DFD2BE
Observe que, para cada tipo, o expoente de 2 no mnimo e no mximo um a menos do que o tamanho do tipo Ponto Flutuante Os dois tipos de pontos flutuantes em Java so: 32 bits float 64 bits double
1.40239846e-45 4.94065645841246544e-324
at 3.40282347e+38 at 1.79769313486231570e+308
Esses tipos esto em conformidade com a especificao IEEE 754 (Institute of Electrical and Electronic Engineers, 1985). Para as expresses que no tem representao em nmeros (infinito, por exemplo), double 's e float 's podem tomar valores padres de bits que representam tais resultados. Abaixo seguem os padres definidos nas classes Float e Double: Float.NaN Float.NEGATIVE_INFINITY Float.POSITIVE_INFINITY Double.NaN Double.NEGATIVE_INFINITY Double.POSITIVE_INFINITY Obs: NaN significa Not a Number. Exemplos: System.out.println(Math.sqrt(-2.)); Imprime: NaN
1.double teste = 50.0/0.0; 2. 3. if (teste == Double.POSITIVE_INFINITY) { 4. System.out.println("Esta linha executada.); 5. } Outro fato importante que em Java no existe o modificador unsigned, como no C++, sendo assim, os tipos primitivos com exceo do boolean e do char possuem sinais. Literais Literais so partes constantes das expresses. Eles podem ser atribudos a variveis de tipo primitivo e strings ou podem aparecer em chamadas de mtodos. varivel = literal; Literais Boolean Os nicos literais que podem ser atribudos ao tipo boolean so true e false. boolean verdadeiro = true; boolean falso = false; Como em VB e C++. Java no aceita 0 (zero) para falso e diferente de zero para verdadeiro... Literais Char Podemos representar um literal char entre aspas simples ( char c = a; ) ou pelo seu valor Unicode, quando no o encontramos no teclado. Exemplo: char c = \u03A6; ( que expressa a letra grega .) char letra = b; A ( \ ) combinada com um caractere convencionado utilizada para representar um caractere sem representao visual, tais como os caracteres especiais listados abaixo: \n \r \t \b \f \ \ \\ Literais Integrais (Inteiros) Podemos expressar os literais integrais em decimal, octal ou hexadecimal. Veja alguns exemplos que representam o decimal 46:

Pula linha Retorno do carro Tabulao Retrocesso Avano de pgina Aspas simples Aspas duplas Barra invertida
46 - Decimal Padro Inteiro 056 - Octal Literal com prefixo 0 (Muito cuidado !!!) 0x2E - Hexadecimal Literal com prefixo 0x 0X2e - Hexadecimal Literal com prefixo 0X ( indiferente usar X ou x)
Para os Literais em hexadecimal, tanto o prefixo quanto o dgito hexadecimal podem ser maisculos ou minsculos. Por default, literais integrais representam valores de 32 bits, caso queiramos indicar um literal integral 64 bits, temos de anexar o sufixo L maisculo ou minsculo expresso. Evitamos o L minsculo por ser facilmente confundido com o 1. Literais de Ponto Flutuante Para expressar um nmero de ponto flutuante um literal deve ter um ponto decimal ou a letra e, indicando conotao cientfica ou o sufixo f ou d, indicando respectivamente um literal float ou double. As letras e, f e d podem ser maisculas ou minsculas. O default de um literal de ponto flutuante sem sufixo double. Exemplos: 1.55E6 Literais String Um Literal String pode ser definido como uma sequncia de caracteres entre aspas duplas. Exemplo: String peixe = "Santos F. C."; 2.5454e-2 -32.999e7 -0.59e-17
Ns abordaremos as Strings com mais detalhes nos textos sobre os pacotes java.lang e java.util. Os literais String so cadeias de caracteres armazenadas em memria e terminadas com o caractere '\ 0' (Zero de oito bits)
Palavras Reservadas Como as demais linguagens, o Java possui algumas palavras reservadas a sua sintaxe. Vamos a elas.
Abstract assert boolean break byte case catch char class const continue default do double else extends false final finally float for future generic goto if implements import inner instanceof int interface long native new null operator outer package private public rest return short static strictfp super switch this throw throws transient true try var void volatile while enum
protected synchronized
As palavras sublinhadas, apesar de reservadas, no so atualmente utilizadas por Java. Nenhuma delas pode ser usada para identificar classes, variveis, mtodos ou rtulos. Identificadores vlidos devem seguir uma das trs regras abaixo:

Conter ou iniciar com letra (a ~ z | A ~ Z); Conter ou iniciar com cifro $; Conter ou iniciar com o underscore _; Conter (mas no iniciar com) dgitos numricos (0 ~ 9).
E dessa forma, no use espaos, caracteres acentuados ou qualquer outro caractere que no '_' ou '$'. Como em C++, a linguagem Java tambm case sensitive, ou seja, meuArrayInt um identificador diferente de MeuArrayInt. Variveis Variveis so nomes/identificadores que endeream posies de memria onde se armazenam valores dos tipos descritos nas declaraes. Declarando Variveis Para declararmos uma varivel temos de associar obrigatoriamente o tipo, o nome e opcionalmente, um valor de inicializao. Vejamos alguns exemplos vlidos: int int int meuInt; meuInt1, meuInt2, meuInt3; meuInt1 = 10, meuInt2; meuObj obj = new meuObj("teste); meuObj obj2 = obj;
Temos de tomar cuidado com situaes como as seguintes: int a = 10; int b = a; diferente de
No primeiro caso, as duas variveis valem 10 e esto armazenadas em reas de memria separadas. No segundo caso obj2 aponta para a mesma rea de memria de obj, ou seja, qualquer alterao em obj2 refletir em obj e vise-versa. Nota muito importante: um consenso internacional na comunidade Java, o uso de letras minsculas para iniciar o nome de variveis e propriedades. As letras maisculas podem (e devem) ser usadas livremente em seu interior. Exemplos: valorTotal, numeroDePagina, somaParcial etc.
Variveis Membro e variveis Automticas As variveis em Java diferem em relao ao tempo da seguinte forma: Uma varivel membro instanciada (criada na memria) e destruda nos mesmos tempos do objeto onde ela foi declarada. J uma varivel automtica ou local a um mtodo, s existe durante a execuo do mtodo onde ela foi declarada e, caso tente ser acessada fora deste mtodo, ocorrer um erro informando que ela indefinida. Examine o exemplo:
1. public class Escopo { 2. private int x = 1; // Varivel Membro da classe 3. public void primeiroMetodo() { 4. int x=7, y=5; // Variveis Locais ao mtodo 5. this.x = x + y; 6. System.out.println("Varivel local x: + x); 7. System.out.println("Varivel membro x: + this.x); 8. segundoMetodo(10); 9. } 10.} 11.public void segundoMetodo(int x) { 12. int y = 8; // Varivel Local ao mtodo 13. this.x = x + y; 14. System.out.println("Argumento do Mtodo x: " + x); 15. System.out.println("Varivel membro x: " + this.x); 16. } 17.}
1. public class TestaEscopo { 2. public static void main(String[] args) { 3. Escopo teste = new Escopo(); 4. teste.primeiroMetodo(); 5. } 6. }
As variveis membros (propriedades) que no so inicializadas explicitamente na declarao, recebem implicitamente um valor inicial. byte int float char object reference short long double boolean 0 0 0.0f \u0000 null 0 0L 0d false
Como j visto anteriormente, as variveis locais aos mtodos NO so inicializadas automaticamente. Caso voc tente utilizar uma varivel local antes de sua inicializao, Java ir gerar uma mensagem de erro de compilao. A inicializao de variveis locais ou automticas uma responsabilidade do programador.
Exemplo: int i; i = i + 5; O cdigo acima causar um erro de compilao. A varivel local 'i' deveria ter sido inicializada e no foi. O correto seria: int i = 0; i = i + 5; Vetores Um vetor ou array Java uma estrutura ordenada, com posies de armazenamento associadas a um nmero (ndice) que podem conter dados de tipos primitivos, referncias a objetos, ou ainda, referncias a outros arrays. Todos os elementos de um array so do mesmo tipo. Isto garantido na declarao do array, quando especificamos seu nome e quais sero seus tipos de elementos, veja o cdigo abaixo: int inteiro []; Dimension dim []; double bidim [][]; int [] inteiro; Dimension [] dim; double [][] bidim; // Array de tipo primitivo // Array de referncia de objeto // Array bidimensional (Matriz) // Array de tipo primitivo // Array de referncia de objeto // Array bidimensional
As seguintes declaraes tambm so vlidas:
Em C/C++ conhecemos a primeira forma e, se percebermos bem, mais um detalhe vai nos ocorrer. O tamanho do array no foi especificado... Em Java, s possvel especificar o tamanho do array em tempo de execuo por meio da palavra chave new. Veja alguns exemplos vlidos abaixo: int meuArrayInt[]; // Declarando ao compilador. // Alocando 10 inteiros em tempo de execuo. meuArrayInt = new int[10]; int len = 10; int meuArrayInt[]; meuArrayInt = new int[len]; // Definindo o tamanho com uma varivel int[] meuArrayInt new int[10]; //Os passos anteriores em uma nica linha
Declarando, alocando e inicializando em uma nica linha. A quantidade de elementos atribudos determina o tamanho do array, meuArrayInt possui 10 posies, mas agora, com os valores determinados. int meuArrayInt[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; Declarando um array de strings com quatro elementos inicializados. String[] nomes = {"Maria","Jos","Pedro","Paulo"}; O que sai na tela? for(int i=0;i<nomes.length;i++) System.out.println(nomes[i]);
Quando no inicializamos os arrays, valores default so automaticamente atribudos aos seus elementos, conforme a tabela abaixo. byte int float char object reference short long double boolean 0 0 0.0f \u0000 null 0 0L 0d false
Arrays que armazenam objetos aps a alocao com new devem ter cada objeto armazenado devidamente instanciado ou podemos receber a exceo NullPointerException ao tentar acess-lo na posio determinada pelo ndice do array. Comentando mais sobre acesso, um erro comum tentar acessar o contedo de um array alm do seu limite de posies, como exemplo, tentar acessar a dcima primeira posio no meuArrayInt[]. Caso faamos isso a exceo ArrayOutOfBoundsException ser lanada.
1. 2. 3. 4. 5. 6. 7. 8. 9. } public class MeuArrayTeste { public static void main(String args[]){ int meuArrayInt[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // com o atributo length podemos evitar facilmente tal erro for (int i = 0; i < meuArrayInt.length; i++) { System.out.println(meuArrayInt[i]); } }
Detalhe: Como no C/C++, os arrays Java so zero-based. (O primeiro ndice zero) Vetores de Objetos Apesar de ainda no termos visto as classes de Java, podemos tambm criar e manipular arrays de objetos. Os objetos do array podem ser instanciados na declarao ou em qualquer outro momento. Exemplos:
Criando e instanciando 3 objetos da classe Crculo com raios 10, 5 e 13 respectivamente: Circulo circulo[] = { new Circulo(10), new Circulo( 5), new Circulo(13) } ;
Declarando um array de 40 referncias para objetos quadrados. Depois instanciando os 40 Quadrados e mostrando a rea de cada um na console. Quadrado quadrados[] = new Quadrado[40]; for (int i=0;i<40; i++) { quadrados[i] = new Quadrado(i); System.out.println("rea do quadrado: " + quadrados[i].getArea()); }
Operadores Java Os operadores Java so muito semelhantes aos existentes em C, C++ e C#, podemos dizer que os operadores de atribuio, aritmticos, compactos, lgicos e relacionais so idnticos e tm o mesmo funcionamento. Precedncia Abaixo seguem os operadores em ordem descendente de precedncia.
++ -+ ~ ! ( tipos de dado ) * / % + << >> >>> < > <= >= instanceof == != & ^ | && || ?: = *= /= %= += -= <<= >>= >>>= &= ^= |=
Ordem de Avaliao Antes da execuo de uma expresso realizada de forma fixa, da esquerda para a direita, a ordem de avaliao dos operandos. Vejamos com detalhes: int[]x = {0,0,0,0,0};// Array de 5 posies inicializadas com zero int y = 2; // Varivel inteira (ndice do array) x[y] = y = y * 2 ; Neste exemplo, qual seria o valor de y? Em qual posio do array ser armazenado? int y = 2; x[y] = y = y * 2 ;
Na execuo da ltima linha do fragmento de cdigo teremos os seguintes passos: x[2] = 2 = 2 * 2; x[2] = 2 = 4; // O valor 4 sobrepe y (valendo 2)
x[2] = 4; // Percebam que a atribuio de 4 a y no alterou seu valor no ndice do array // Esse valor foi atribudo em tempo de avaliao da // Ento, y valer 4 e ser armazenado na terceira posio do array.
ndice (y) Valor 0 0 1 0 2 4 3 0 4 0
Os Operadores de Atribuio De maneira simples, variveis so locais na memria onde armazenamos bits, e estes locais podem armazenar grupos de bits que conhecemos como char, int, float, double etc...Os tipos primitivos possuem sua representao na memria de maneira conhecida, ou seja, o valor 9 de um tipo byte seria representado pelos 8 bits: 0000 1001. E um objeto? Vamos pegar a linha abaixo da nossa classe TestaEscopo: TestaEscopo teste = new TestaEscopo(); O que temos dentro da rea de memria teste? O objeto teste? O que temos uma referncia ao objeto teste na memria, ou seja, a maneira como podemos acesslo, releia Declarando variveis. Os detalhes de armazenamento so de responsabilidade da implementao da mquina virtual. Atribuindo Primitivos Como em diversas linguagens, o Java, utiliza o sinal de igualdade para a atribuio. O sinal " = combinado a outros 11 operadores aritmticos formam 12 diferentes maneiras de atribuirmos valores em Java, nada muito estranho.... A atribuio simples feita com o sinal de = e operadores como o += e o -= realizam operaes compostas por clculo e atribuio do resultado obtido. Atribuindo Inteiros 1. int a = 9; 2. int b = a + 3; 3. int c = a + b; 4. a += c; Parece fcil, mas temos de tomar certos cuidados, vejam: 1. byte x = 9; // Existe converso implcita 2. byte y = 2; // Existe converso implcita 3. byte z = x+y; Essa ltima linha no ser compilada. Estranho no? Vamos analisar: Na linha: byte x = 9; O compilador executa uma converso da seguinte forma: byte x = (byte) 9; O 9 um literal do tipo int de 32 bits, lembra? Mas como o seu valor pode ser comportado em uma varivel do tipo byte, o compilador 'caridosamente' realiza a tarefa de converso para voc. Isso tambm se aplica s variveis short e char (menor preciso do que o tipo int).
Mas o que ocorreu na expresso byte z = x+y; simples, temos de lembrar sempre da seguinte regra:
Qualquer operao que envolva um tipo int, short, char ou byte, sempre resultar em um int. Na expresso acima, a soma do byte x com byte y resulta em um int e, como sabemos, no podemos atribuir um int de 32 bits a um byte de 8 bits. Para tanto, temos de fazer o seguinte cast: byte z = (byte) (x+y); Mais alguns exemplos: byte x = 9; x += 2; // Sem problemas, o compilador realiza a converso // implicitamente para ns J em: byte x = 9; x = x + 2; Novamente, teremos de usar o cast: byte x = 9; x = (byte) (x + 2); // Correto mas trabalhoso.... // Teremos problemas, j que x + 2 resulta em um int.
J estava me esquecendo, em Java, como no C++, as seguintes declaraes so vlidas: int x, y, z; x = y = z = 10; // Mltipla atribuio
Essa atribuio executada da direita para a esquerda, do z chegando ao x.
Atribuindo Ponto Flutuante Como comentamos, um literal de ponto flutuante sem sufixo implicitamente um double de 64 bits. Se voc tentar: float a = 99.9; // Essa linha no compilar! O compilador considera que voc est atribuindo um valor de 64 bits a um espao que comporta apenas 32 e no permitir essa atribuio sem a utilizao do sufixo f ou F. float a = 99.9f; // No teremos mais problemas de compilao!
Atribuindo Variveis de Referncia Vamos a um exemplo que aprendi com a Sun, imagine que temos um objeto que representa uma data formado por dia, ms e ano e que, seu construtor, inicializa suas variveis membro. Vejamos o que acontece com a alocao de memria. MinhaData d = new MinhaData (1, 2, 2008); A parte em negrito armazena na memria, apenas a referncia ao objeto: d
????
MinhaData d = new MinhaData (1, 2, 2008); O operador new aloca o espao em memria para MinhaData d dia mes ano
???? 1 2 2008
MinhaData d = new MinhaData (1, 2, 2008); O operador = associa, com o endereo de memria, o objeto MinhaData a varivel de referncia d. d dia mes ano
0x01234567
1 2 2008
Agora que j conhecemos os passos de alocao, vamos comparar a atribuio de inteiros com a de variveis de referncia. Observe o seguinte cdigo: int x = 9; int x2 = x; MinhaData d = new MinhaData (1, 2, 2008); MinhaData d2 = d; x x2
9 9
As variveis x e x2 possuem o mesmo valor com endereos de memria diferentes. d d2

0x01234567 0x01234567 1 2 2008
Os objetos d e d2 tambm, mas com uma diferena, eles fazem referncia a um mesmo objeto na memria. Isso acarreta em: Fazendo: d.dia = 2; A linha: d2 = new MinhaData(1,1,2008); Resultaria em dois novos objetos MinhaData com duas referncias diferentes. d d2
0x01234567 0x01234568 1 1 2 1 2008 2008
// Estaremos alterando d2.dia para 2 tambm.
Temos uma exceo a essa regra com objetos String. Veja o seguinte fragmento de cdigo: String teste = "Ja"; String teste2 = teste; // Conforme explicamos acima, as duas // variveis referenciam o mesmo objeto teste teste2 Se fizermos: teste2 = teste2 + "va"; // Teremos em teste2 a palavra Java Seguindo o raciocnio explicado anteriormente, teste tambm deveria armazenar "Java, mas como comentamos, existe uma exceo quando tratamos com Strings. A regra : A Virtual Machine sempre criar um novo objeto em qualquer alterao que faamos com uma String, ou seja, na linha: teste2 = teste2 + "va";
0x01234567 0x01234567
Ja
Um novo objeto String ser criado na memria e a referncia ser associada a varivel teste2, deixando teste inalterada. teste teste2
0x0123456 7 0x0123456 8
Ja
Java
Operadores lgicos de conexo
And: && And lgico palavra a palavra. Usado para conectar duas expresses lgicas: Verdadeiro apenas se ambas as expresses forem verdadeiras. Exemplos: int a = 10, b = 5, c = 5; System.out.println (a > b && c >= b); // V && V => V Imprime: true System.out.println (a > b && a == b && a * 3 > 6); // V && F && V Imprime: false Or: || Or lgico palavra a palavra. Usado para conectar duas expresses lgicas: Verdadeiro se apenas uma das expresses for verdadeira. Exemplos: int a = 10, b = 5, c = 5; System.out.println (a > b || c < b); // V | | F => V Imprime: true System.out.println (a > b || a == b || a * 3 > 6); // V | | F | | V => V Imprime: true
Conceito de Curto Circuito Em uma expresso lgica mltipla, muitas vezes podemos adiantar o resultado da expresso antes mesmo que esta chegue ao fim. Quando este fato ocorre, dizemos que ocorreu curto circuito e o Java no prossegue com as comparaes j que conhece o resultado final da expresso. Exemplos:
(3 < 5) && (5 < 4) && (a == 5)
Observe que a primeira comparao ( 3 < 5 ) resulta em ( true ), mas a segunda ( 5 < 4 ) resulta em ( false ). Desta forma, no momento da segunda comparao, j se conhece o resultado final da expresso ( false ), uma vez que basta um elemento da expresso ser ( false ) para toda a expresso ser falsa em uma sequncia de AND's. A ltima expresso ( A = = 5 ) no chega a ser comparada pelo Java. Note que o valor da varivel a irrelevante uma vez que a comparao no chega a ser realizada.
(4 < 3) || (5 > 2) || (7 < a) || (b != a)
Neste exemplo a primeira comparao, ( 4 < 3 ) resulta em ( false ). Como o operador lgico a seguir um || a segunda comparao deve ser realizada, pois a expresso ainda no est resolvida. Esta segunda comparao resulta em ( true ) j que a afirmao ( 5 > 2 ) verdadeira. Automaticamente o resultado da expresso passou a ser conhecido. Ser ( true ). Desta forma a ltima, ( b != a ) e a penltima (7 < a) comparao no sero realizadas e, portanto, os valores de a e b no preciso ser conhecidos pois o resultado final das expresses no depende deles. Este conceito pode ser usado para evitar eventuais erros em tempo de execuo. Veja o exemplo:
1. public class TesteCurtoCircuito { 2. 3. 4. 5. 6. 7. 8. 9. public static void main (String [] args) { Horista fun1 = new Horista ( 15.85,"Jos","Silva"); Mensalista fun2 = new Mensalista (4578.55,"Adam","Smith"); Funcionario fun = null; if (args[0].equals("H")) else if (args[0].equals("M")) else fun = fun1; fun = fun2; fun = null;
10. if (fun != null && "Jos".equals(fun.getNome())) 11. System.out.println ("Valor a receber: R$ " + fun.salario()); 12. else 13. System.out.println ("Salrio no pode ser mostrado..."); 14. } 15.}
Observe que no if da linha 11 o primeiro teste se o objeto virtual fun est null ou no. Se fun for igual a null a expresso mltipla resultar em false, graas ao conceito do curto circuito (Basta uma comparao resultar em false para que a expresso resulte em false). Desta forma a segunda expresso, que invoca um mtodo de fun no ser executada e, portanto, no ocorrer um erro de tentativa de uso objeto com null. Nota: Veja mais a frente em Polimorfismo o exemplo completo com as definies das classes Horista, Mensalista e da superclasse Funcionario.
Os Operadores Unrios Os operadores unrios so chamados assim por operarem apenas uma varivel. Operadores de Incremento e Decremento: ++ e -Aumentam ou diminuem uma varivel em uma unidade, o importante que podemos fazer isso antes ou depois de utiliz-la. Analise o seguinte cdigo:
1. public class IncDec { 2. public static void main( String args[] ) 3. { 4. int x; 5. x = 9; 6. System.out.println( x ); // Imprime 9 7. System.out.println( x++ ); // Imprime 9 e depois incrementa 8. System.out.println( x ); // Imprime 10 9. System.out.println( --x ); // Decrementa e imprime 9 10. System.out.println( ++x ); // Incrementa e imprime 10 11. System.out.println( x-- ); // Imprime 10 e decrementa 12. System.out.println( x ); // Imprime 9 13. } 14.}
Operadores Unrios de Mais ou Menos: + No vamos confundir estes operadores com os de soma e subtrao (+ e -), com um exemplo vai ficar mais fcil entender o contexto: (Note as linhas 5 e 10)
1. public class NegPos { 2. public static void main( String args[] ) 3. { 4. int x; 5. x = -9; 6. System.out.println( x ); // Imprime -9 7. System.out.println( x++ ); // Imprime -9 e depois incrementa 8. System.out.println( x ); // Imprime -8 9. System.out.println( --x ); // Decrementa e imprime -9 10. x = +9; 11. System.out.println( ++x ); // Incrementa e imprime 10 12. System.out.println( x-- ); // Imprime 10 e decrementa 13. System.out.println( x ); // Imprime 9 14. } 15.}
Usamos os operadores apenas para indicar que estamos trabalhando com valores negativos e positivos.
Operador de Inverso de Bits: O operador
~ (Not bit a bit)
inverte os bits de tipos integrais, ou seja, converte 0 para 1 e 1 para 0.
Por exemplo: ~ 0000 0000 0000 0000 0000 0000 0000 1010 Resulta: 1111 1111 1111 1111 1111 1111 1111 0101
1. public class InvBit { 2. 3. 4. 5. 6. 7. 8. 9. } public static void main(String [] args) { int x; x = 10; System.out.println( x ); System.out.println( ~x ); }
//Imprime 10 //Imprime -11
O Operador de Negao Booleano: ! (Not) O operador ! inverte o valor de uma expresso booleana. Verifique o cdigo abaixo.
1. public class NegBoo { 2. 3. 4. 5. 6. 7. 8. } public static void main( String args[] ) { boolean teste = true; System.out.println( !teste ); System.out.println( teste ); }
//Imprime false //Imprime true
OBS: Vamos usar bastante este operador com o controle fluxo if ( ). O Operador Cast: (tipo) Podemos dizer que em Java temos duas formas de converso, as implcitas e as explicitas. Vamos analisar o cdigo abaixo:
1. public class Conversao{ 2. public static void main( String args[] ) 3. { 4. double x = 0.0; 5. int y = 1; 6. x = y; // Converso implcita, atribumos um int para um double 7. System.out.println( x ); 8. y = (int) x; // Converso explcita, informamos ao compilador que 9. System.out.println( y ); // o valor double x ser comportado 10. // sem problemas no int y 11. } 12.}
Imprime: 1.0 1 Finished executing
Relembrando, o double x tem 64 bits e o int y 32, ento, no precisamos realizar explicitamente o cast. O compilador faz isso por ns, j que os tipos so compatveis e estamos atribuindo o menor para o maior. J no segundo caso, atribumos um double para um int e o compilador, sem o cast, retorna seguinte erro: possible loss of precision. E ele tem toda razo, quando estamos realizando esta compactao, realmente poderemos estar perdendo a preciso do dado, ou seja, a responsabilidade toda nossa! Operadores Aritmticos
+ * / % -
Adio Subtrao Multiplicao Diviso Resto (Diviso Inteira) Sinal Negativo (Inverte o sinal da varivel)
Esses so os operadores mais familiares que encontramos, portanto, detalharemos um pouco mais apenas os operadores de resto % e cast. Vamos analisar mais um trecho de cdigo.
1. public class Aritimeticos { 2. public static void main( String args[] ) {
3. int a = 9, b = 4; 4. System.out.println( a + b ); // Imprime 13 5. System.out.println( a - b ); // Imprime 5 6. System.out.println( a / b ); // Imprime 2 7. System.out.println( a % b ); // Imprime 1 8. // a = b / 0; // Gera: java.lang.ArithmeticException: / by zero 9. // a = b % 0; // Gera: java.lang.ArithmeticException: / by zero 10. // Essas so as nicas excees aritmticas. 11. double c = 9, d = 4; 12. System.out.println( c / d ); // Imprime 2.25 13. System.out.println( c % d ); // Imprime 1.0 14. c = d / 0; // No d erro 15. c = d % 0; // No d erro 16. /* As duas operaes anteriores resultam em valores infinitos 17. positivos ou negativos,nesse caso positivos, pois o zero 18. no negativo */ 19. System.out.println( -a ); // Imprime -9 20. byte f = 64, g = 4; 21. 22. f = (byte) (f * g); // 64 * 4 = 256 ou 1 0000 0000 em binrio 23. System.out.println(f); /* Imprime 0, pois um byte tem 8 bits e no 24. cast perdemos o bit mais significativo, "overflow". Lembra o que 25. comentamos sobre operador cast? A responsabilidade toda nossa! */ 26. } 27. }
Imprime: 13 5 2 1 2.25 1.0 -9 0 Finished executing Obs: As linhas 8 e 9 esto comentadas para que no ocorra erro de diviso inteira. O Operador +, Aritmtico ou Concatenador de Strings? Diferente do C++, em Java no podemos sobrecarregar operadores. No caso do operador + (mais) ele j sobrecarregado pela linguagem. Por isso podemos fazer:
1. public class OperadorMais{ 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. public static void main( String [] args ) { int a = 20; int b = 10; // Abaixo os operandos so inteiros, fazendo que o + realize // uma operao aritmtica. System.out.println( a + b ); /* Neste caso os operandos so Strings, fazendo com que o + realize a concatenao do texto*/ System.out.println("Santos " + "F. C.");//Imprime: Santos F. C. // E no caso abaixo? System.out.println("Santos Campeo em " + a + b ); /* Caso um dos operando seja String, todos os outros sero tratados da mesma maneira. Essas converses so realizadas implicitamente pelos mtodos toString() e integer.toString() definidos em java.lang.Object */
Imprime: 30 Santos F. C. Santos Campeo em 2010 Finished executing
Os operadores de deslocamento (shift/rotate) So operadores que permitem deslocar os bits para esquerda ou direita o nmero de vezes que for solicitado Em Java temos trs operadores. Dois deles so idnticos aos de C/C++. (<< e o >> ), j o terceiro >>>, vem do fato da linguagem Java trabalhar, com exceo do char, com seus valores numricos sempre com sinal. Diferente do C e do C++ onde tnhamos a opo unsigned. Os operadores de deslocamento inserem um bit esquerda ou direita de um nmero em sua representao binria, "empurrando todos os outros bits existentes e eliminando os excedentes do outro lado.. Estas operaes s podem ser aplicadas aos tipos char, short, int e long que so os Integrais. Vamos acompanhar o seguinte exemplo:
1. public class Deslocamento { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. } 17.} public static void main (String args []) { char res; res = (char) (0xAE << 3); System.out.println("1010 1110 << 3 => " + Integer.toBinaryString(res)); res = (char) (0xAE >> 3); System.out.println("1010 1110 >> 3 => " + Integer.toBinaryString(res)); res = (char) (0x2E >> 3); System.out.println("0010 1110 >> 3 => " + Integer.toBinaryString(res)); res = (char) (0xAE >>> 3); System.out.println("1010 1110 >>> 3 => " + Integer.toBinaryString(res));
Imprime: 1010 101 1010 0010 1010 Nota: Para efeito de melhor visualizao do mecanismo de rotao a sada impressa acima foi editada com as seguintes convenes:

1110 1110 110 1110 110 1110 110
<< >> >> >>>
3 3 3 3
=> => => =>
01110000 11110101 00000101 00010101
// // // //
Preenche com zeros a direita Preenche com o atual (1 no caso) Preenche com atual (0 no caso) Preenche sempre com zero
Em negrito: Novos bits inseridos Traado negrito: Bits que sero eliminados.
As aplicaes mais comuns para os operadores de deslocamento so na manipulao de bits em sistemas de controle de processo, automao de equipamentos etc. Podemos usar tambm os operadores de deslocamento para realizar divises e multiplicaes por dois

x >> 4 x << 4
Equivale a: Equivale a:
x / 24 x * 24
Os operadores de comparao Operadores de comparao <, <=, >, >=, == e != sempre resultam em um valor boolean (true ou false). Geralmente utilizamos esses operadores para testes em declaraes if( ) ou controles de laos. Comparando inteiros, nmeros de ponto flutuante e caracteres:

< <= > >=
menor que menor ou igual a maior que maior ou igual a
Vamos a alguns exemplos:

1. public class Compara { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22.} public static void main (String args[]){ int a = 9; int b = 66; int c = -13; float d = 9.0F; char e = 'B'; boolean f; if (a < b) System.out.println("Primeira comparao: " + a); if (c < b) System.out.println("Segunda comparao: " + c); if (b > d) System.out.println("Terceira comparao: " + b); if (d <= a) System.out.println("Quarta comparao: " + d); if (b >= e) System.out.println("Quinta comparao: " + b); f = 13 > 9; System.out.println("Sexta comparao: " + f); }
imprime: Primeira comparao: 9 Segunda comparao: -13 Terceira comparao: 66 Quarta comparao: 9.0 Quinta comparao: 66 Sexta comparao: true Finished executing Nota: Podemos comparar as variveis b com e, apesar de no ser uma boa prtica, por que o Java utilizar o valor ASCII ou Unicode do caracter comparado, ou seja, a varivel b vale 66 (cdigo ASCII do caracter 'B') e a varivel e vale 'B' (como vimos, cdigo ASCII do caracter 'B' vale 66). Por este motivo a comparao resultou em true. H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 40
O operador instanceof O operador instanceof compara, em tempo de execuo, variveis ou um elemento de um array com um tipo classe, interface ou array. Vejamos:
1. public class ComparaString { 2. public static void main (String args[]){ 3. String time = new String("Peixe"); 4. if (time instanceof String){ 5. System.out.println("Estamos bem no Brasileiro!"); 6. } 7. } 8. }
Com o instanceof ainda conseguimos saber se o objeto que comparamos uma instncia de uma de suas superclasses ou um tipo genrico Object.
1. class Calculadora{} 2. 3. public class CalculadoraCientifica extends Calculadora { 4. public static void main (String args[]){ 5. CalculadoraCientifica calc = new CalculadoraCientifica(); 6. if (calc instanceof Object){ 7. System.out.print("calc um Objeto"); 8. } 9. if (calc instanceof Calculadora){ 10. System.out.println(" e subclasse de Calculadora."); 11. } 12. } 13. }
Imprime: calc um Objeto e subclasse Finished executing Ainda podemos testar se um objeto nulo:
1. public class TestandoObjNulo { 2. 3. 4. 5. 6. 7. } public static void main (String args[]){ String teste = null; boolean resultado = teste instanceof String; System.out.println(resultado); }
de Calculadora.
Apesar de ser um String, o objeto teste nulo ento: Imprime: false Quando comparamos com uma interface (veremos interface mais a frente), testamos se o objeto esquerda implementa a interface direita da expresso. Abordaremos o tema interface mais frente. Quando comparamos arrays com instanceof implicitamente temos dois passos, primeiro verificado se o objeto um array e depois, se o tipo de elemento do array correspondente ao tipo de elemento comparado direita.
Os operadores de igualdade Comparando nmeros, booleanos ou variveis de referncia objetos.

== !=
igual a diferente de
1. public class TestaIgualdade { 2. public static void main (String args[]){ String a = new String("teste"); String b = a; int c = 67; // 67 o cdigo ASCII do 'C' char d = 'C'; if (c == d) System.out.println("A regra vale para char tambm."); if (b == a) { System.out.println("a e b so iguais, pois apontam); System.out.println("para o mesmo endereo de memria."); } b = new String("teste"); if (b != a){ System.out.println ("\nAgora, apesar do contedo igual"); System.out.println ("a e b so diferentes pois apontam"); System.out.println ("endereos de memria diferentes."); }
3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. } 20.}
Imprime: A regra vale para char tambm. a e b so iguais, pois apontam para o mesmo endereo de memria. Agora, apesar do contedo igual a e b so diferentes pois apontam endereos de memria diferentes. Finished executing
Comparando objetos (referncias) Comparando com equals A comparao de objetos pode parecer a primeira vista um caso particular da comparao de primitivos mas, como vimos no item anterior, no bem assim. Quando comparamos objetos estamos realmente querendo comparar o contedo de cada uma de suas propriedades. Se o contedo de todas propriedades do objeto a for igual ao contedo de todas as propriedades do objeto b ento podemos afirmar que a e b so idnticos, mas no necessariamente o mesmo. A simples comparao a == b no est verificando se os objetos so de contedo idntico, mas se compartilham o mesmo endereo de memria, ou seja um nico objeto mas com duas referncias. Por este motivo, toda classe em Java possui um mtodo herdado da classe Object * equals(). Todas as classes utilitrias disponveis para uso nas diversas API's java j possuem um mtodo equals() implementado e pronto para uso o que no acontece com as classes desenvolvidas para o projeto. Neste caso desenvolvedor da classe deve providenciar sua codificao. Vamos considerar a classe Retangulo abaixo:
1. public class Retangulo { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. private double ladoA; private double ladoB; public Retangulo (double ladoA, double ladoB) { setLadoA(ladoA); setLadoB(ladoB); } public double getArea() {return this.ladoA * this.ladoB;} public double getPerimetro() {return 2* (this.ladoA + this.ladoB);} @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Retangulo ret = (Retangulo) obj; // Necessrio porque obj Object if (this.ladoA != ret.ladoA) return false; if (this.ladoB != ret.ladoB) return false; return true; } .......... // Outros mtodos }
Nossa classe Retangulo possui apenas duas propriedades. Vamos analisar nosso cdigo:

Linha 10: Fizemos nossa anotao de que o mtodo est sobrescrito; Linha 12: Se a referncia recebida (obj) a mesmas que this, o objeto o mesmo; Linha 13: Se a referncia recebida null, no igual; Linha 14: Se as classes de this e obj forem diferentes, no so iguais. Linhas 17 e 18,: Finalmente verificam se as propriedades possuem o mesmo contedo**. Linha 19: Se chegou aqui, t tudo bem... so iguais mesmo.
* Toda classe que no estende nenhuma outra, estende Object por default. ** Devemos ter cuidado ao comparar float's e double's primitivos, as vezes pequenas diferenas de preciso podem indicar erroneamente que os valores so diferentes. H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 43
Comparando com hashCode A comparao de igualdade , na maioria dos casos, penosa porque utiliza um bom volume de processamento e ainda no ajuda muito quando precisamos classificar (ordenar) os objetos de uma coleo. O hachCode um nmero inteiro obtido ao ser utilizado algum algoritmo que, a partir dos contedos das propriedades, permite saber se um objeto igual, menor ou maior que outro. Assim como o equals(), o mtodo hashCode() tambm esta definido na superclasse Object e usado para verificar igualdades e normalmente so mais eficientes que o equals(). Veja o mtodo hashCode() para nossa classe Retangulo descrita no item anterior.
1. @Override 2. public int hashCode() { 3. final int primo = 31; 4. int result = 1; 5. long temp = Double.doubleToLongBits(this.ladoA); 6. result = primo * result + (int) (temp ^ (temp >>> 32)); 7. temp = Double.doubleToLongBits(this.ladoB); 8. result = prime * result + (int) (temp ^ (temp >>> 32)); 9. return result; 10. }
Exemplo de uso de equals() e hashCode():

1. public static void main(final String args[]) { 2. 3. Retangulo r1 = new Retangulo(2,4); 4. Retangulo r2 = new Retangulo(2,4); 5. Retangulo r3 = r2; 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. System.out.println ("a) " + (r1 == r2 ? "r1 igual a r2" : "r1 diferente de r2")); System.out.println ("b) " + (r1.equals(r2) ? "r1 igual a r2" : "r1 diferente de r2")); System.out.println ("c) " + (r1.hashCode() == r2.hashCode()? "r1 igual a r2" : "r1 diferente de r2")); r3.setLadoA(3); System.out.println ("d) "+(r1 == r2 ? "r1 igual a r2" : "r1 diferente de r2")); System.out.println ("e) "+(r1.equals(r2) ? "r1 igual a r2" : "r1 diferente de r2")); System.out.println ("f) "+(r1.hashCode() == r2.hashCode()? "r1 igual a r2" : "r1 diferente de r2")); }
Imprime: a) b) c) d) e) f) r1 r1 r1 r1 r1 r1 diferente de igual a r2 igual a r2 diferente de diferente de diferente de r2 r2 r2 r2
Procure entender e explique cada uma das 6 sadas do programa.
Os operadores de bits

& ^ |
(AND lgico)
ou exclusivo (XOR - or exclusive) ou lgico (OR lgico)
Estes operadores so aplicveis a tipos integrais (inteiros) , e atuam comparando os bits correspondentes de dois operandos, conforme as regras demonstradas na seguinte tabela:
x
0 0 1 1 Vamos aos exemplos:
y
0 1 0 1
& (and)
0 0 0 1
| (or)
0 1 1 1
^ (xor)
0 1 1 0
1. public class OperaBits { 2. public static void main (String args[]){ 3. 4. 5. 6. 7. 8. 9. byte x = 10; // 1010 byte y = 5; // 0101 boolean v = true, f = false; System.out.println("1010 AND 0101 => 0000 ->" + (x & y)); System.out.println("1010 OR 0101 => 1111 ->" + (x | y)); System.out.println("1010 XOR 0101 => 1111 ->" + (x ^ y)); y <<= 1;
10. System.out.println("1010 XOR 1010 => 0000 ->" + (x ^ y)); 11. System.out.println("Aps o deslocamento y vale: "+y+" -> 1010\n"); 12. System.out.println("v AND f: " + (v & f)); 13. System.out.println("v OR f: " + (v | f)); 14. System.out.println("v XOR f: " + (v ^ f)); 15. } 16.}
Imprime: 1010 1010 1010 1010 Aps AND 0101 => 0000 OR 0101 => 1111 XOR 0101 => 1111 XOR 1010 => 0000 o deslocamento y false true true -> 0 -> 15 -> 15 -> 0 vale: 10 -> 1010
v AND f: v OR f: v XOR f:
Como vimos acima, tambm permitido aplic-los em expresses com operadores booleanos.
Operador ternrio Chamado de operador ternrio porque opera em 3 expresses simultaneamente. Expresso geral: Exp1 ? Exp2 : Exp3 O operador ternrio funciona da seguinte forma: Se a Exp1 for verdadeira, vale a Exp2. Caso contrrio valer a Exp3. Repare que este operador na verdade em alguns casos pode substituir o uso do comando condicional if / else. Exemplos:

max = a > b ? a : b; a > b ? max = a : max = b; System.out.println(media >= 7.0 ? "Aprovado":"Reprovado"); Operadores de expresses reduzidas
So operadores que servem para tornar mais compacto o cdigo, evitando repetio desnecessria do nome das variveis. Esta reduo tambm permite que o compilador ajuste tipos implicitamente, sem necessidade do uso de cast para converso. Exemplo: byte x = 9; x += 2; x = x + 2; // Compila OK // Erro de compilao
Sem problemas, o compilador realiza a converso de byte para int implicitamente. Temos aqui um erro de compilao, j que somar um byte com o literal 2 que um literal inteiro, resulta em um inteiro. No momento de atribuir de volta para o x o resultado da soma o compilador no poder faz-lo porque um inteiro (4 bytes) no pode ser armazenado em um byte... Ser necessrio usar cast. Se no existisse o operador reduzido a soluo seria fazer: x = x + (byte) 2; Exemplos de operadores reduzidos: Considere sempre o mesmo valor inicial da varivel var em cada linha da tabela; int var = -64; De var = var * 10; var = var / 2; var = var % 2; var = var + 4; var = var 6; var = var << 2; var = var >> 2; var = var >>> 2; var = var & 1; var = var ^ 1; var = var | 0xFF; Reduz para... Valor final de var var *= 10; var /= 2; var %= 2; var += 4 var -= 6; var <<= 2; var >>= 2; var >>>= 2; var &= 1; var ^= 1; var |= 0xFF; -640 -32 0 -60 -70 -256 -16 1073741808 0 -63 -1 (ou 0xFF)
Classes empacotadoras - emulam os tipos primitivos (wrappers) Como vimos, as variveis primitivas so caracterizadas pela sua forma de armazenamento. Elas, diferentemente dos objetos, no so referncias mas so contedos diretamente armazenados na memria. As variveis primitivas podem gerar cdigo muito mais eficiente porque as CPU's conseguem fazer as operaes lgicas e matemtica diretamente por intermdio de seus registradores internos. O uso de variveis primitivas encontra alguns opositores porque diminui o grau de orientao a objeto da linguagem (se que isso existe!). Outras linguagens OO como o C# por exemplo, aboliram completamente os tipos primitivos embora o compilador esteja preparado para realizar otimizaes para neutralizar uma boa parte das limitaes das classes empacotadoras. Java, sem nenhum escrpulo, possui variveis primitivas e ainda incentiva seu uso em uma boa quantidade de situaes. Elas geram cdigo mais eficiente e, at o aparecimento da verso 5 do Java, eram muito mais fceis de serem utilizadas. Entretanto, em muitas outras oportunidades o uso direto das variveis primitivas reduz muito a flexibilidade da linguagem e impossibilitam algumas aplicaes onde o manuseio de objetos (ou suas referncias) ajuda muito no desenvolvimento de API's, framework's etc. Por este motivo, java possui uma classe equivalente para todos os tipos primitivos. So elas:
Primitivo
void int float double short byte char long boolean
Wrappers
Void Integer Float Double Short Byte Character Long Boolean
Usando as classes wrappers

Antes do java 5
Integer x1 = new Integer(10); No uso: System.out.println("Soma: " + x1.intValue() + x2.intValue()); if (x1.compareTo(new Integer(5)) > 0) System.out.println(x1.toString() + " maior que 5"); ou Integer x2 = new Integer("10");
A partir do Java 5 (autoboxing e unboxing)

Integer x1 = 10; No uso: System.out.println("Soma: " + x1 + x2); if (x1 > 5) System.out.println(x1 + " maior que 5"); ou Integer x2 = Integer.parseInt("10");
Como visto, Java 1.5 ao implantar a converso e desconverso de objeto para primitivos e viceversa, facilitou a vida do programador que pode tratar as classes wrappers quase como se estivesse manipulando primitivos diretamente. Todavia, essa facilidade pode passar a sensao de que o uso de wrappers a mesma coisa que usar primitivos. Mas isso no bem assim. O autoboxing e unboxing representa um acrscimo de processamento realmente muito significativo. Alguns testes citados no livro de Joshua Bloch, mostram que o tempo de execuo dos algortimos que utilizam classes de primitivos equivalentes pode ser mais que dez vezes maior em relao ao mesmo algortimo que faz uso diretamente dos primitivos. Abaixo medimos o tempo de execuo de um mesmo lao e mostramos a diferena entre o tempo de execuo usando variveis primitivas e seu equivalente de classe. Utilizando a classe equivalente ao long (Long)
1. public class TesteAutoboxing1 { 2. 3. 4. 5. 6. 7. 8. 9. 10. } public static void main(String[] args) { Long soma = 0L; long antes = new Date().getTime(); for (Long i = 0L ; i < 0xfffffffL ; i++) { soma += i; } long depois = new Date().getTime(); System.out.printf("Tempo: %5.2f segundos\n",(depois-antes)/1000.);
Imprime: Tempo: 11,55 segundos O mesmo algoritmo usando apenas primitivos:

1. public class TesteAutoboxing2 { 2. 3. 4. 5. 6. 7. 8. 9. 10. public static void main(String[] args) { long soma = 0L; long antes = new Date().getTime(); for (long i = 0L ; i < 0xfffffffL ; i++) { soma += i; } long depois = new Date().getTime(); System.out.printf("Tempo: %5.2f segundos\n",(depois-antes)/1000.);
Imprime: Tempo: 0,92 segundos
Neste exemplo, a primeira verso foi mais que 12 vezes mais rpida confirmando os resultados obtidos por Joshua no seu trabalho. Naturalmente este tempo pode variar com as caractersticas de cada equipamento e tambm com o compilador que est sendo utilizado. Este exemplo foi compilado pelo Eclipse Version: 6.6.0 em um AMD Athlon Dual Core 2.1GHz, 2GB de RAM e Sistema Operacional Windows XP com SP 3.
Programando em Java
Princpios Um programa executvel em Java composto por uma ou mais classes. Uma das classes, dever possuir um mtodo pblico, esttico, sem retorno e necessariamente chamado main. S poder existir um mtodo com estas caractersticas. Como acontece em C/C++, este mtodo ser usado como ponto de partida para rodar o programa. Os arquivos fonte de Java devem ter exatamente o mesmo nome da classe (ou interface). Java 100% case sensitive, portanto, o nome do arquivo fonte dever possuir exatamente a mesma grafia do nome da classe. Os fontes Java devem possuir necessariamente a extenso .Java Os fontes Java podem possuir mais de uma classe, desde que todas as outras sejam privadas. (Veja: Qualificadores ) Qualificadores As classes, mtodos e propriedades podem receber qualificadores, com os seguintes significados:
public: Indica que acessvel externamente a classe. Por enquanto, vamos pensar em classes e mtodos pblicos e propriedades privadas. Naturalmente estas condies podem no ser as melhores para todos os casos mas, sempre que no existir outro motivo melhor, podem ser utilizadas. private: Indica que a classe, mtodo ou propriedade no deve ser acessada externamente a classe. final: No caso de ser usado em propriedades, significa que a propriedade no poder ter seu valor modificado (O que equivale a dizer que se trata de uma constante) . Se for usada em uma classe, significar que a classe no poder sofrer extenso, ou seja, nenhuma outra classe poder ser derivada dela. static: Indica que a classe, mtodo ou propriedade no ser instanciada. Isso significa que so criadas quando o Java encontra a definio da classe e no so instanciadas novamente. Na realidade os elementos declarados como static so comuns a todos os objetos da classe. possvel invocar um mtodo esttico usando o nome da prpria classe no lugar do nome do objeto. Exemplo: import java.Math.*; public class classTeste { double a = Math.sqrt(2); }
Nota importante: Caso o qualificador seja omitido, Java considera o qualificador default, ou seja, que a classe, mtodo ou propriedade privado a todo o pacote (package)
Instrues de Programao Java

Quem conhece C/C++ , PHP, C# ou Javascript, j conhece os comandos de Java. Existem apenas algumas diferenas que sero comentadas a medida que forem aparecendo. Instruo condicional if else Desvia o fluxo de execuo de um programa de acordo com o retorno de uma expresso booleana. Os ifs podem ser encadeados indefinidamente. Exemplos:
if (a > b) max = a; else max = b; if (altura >= 1.75) resultado = "alto"; else if (altura < 1.65) resultado = "baixo"; else resultado = "mdio"; if (idade >= 18) { mensagem = "Voc j pode tirar carta de motorista."; if (idade < 21) mensagem += " mas ainda no maior de idade."; else mensagem += " e um adulto.";
} else if (idade < 13) { // Esta chave obrigatria if (idade >= 10) mensagem = "Voc um pr adolescente."; else mensagem = "Voc ainda uma criana.";
} else mensagem = "Voc um adolescente.";
Notas:
Em Java no possvel como em C++ e VB, usar o valor de retorno de uma expresso como falso se zero e verdadeiro se diferente de zero. Java exige que a expresso lgica retorne um valor booleano. Exemplo: int a = 1; if (a) System.out.println ("Para Java isso um erro (no compila)"); if (a!=0) System.out.println ("Uma expresso booleana. Est correto!");
Usando if's encadeados, procure sempre "caprichar na edentao. Apesar de no fazer sentido nenhum para o compilador, podemos com mais facilidade visualizar a lgica do cdigo. Os blocos devem ser delimitados por chaves abrindo e fechando. Se existir apenas uma instruo associada ao if ou else, as chaves so desnecessrias embora recomendada por algumas escolas como forma de melhorara a legibilidade do cdigo. As vezes so necessrios delimitadores para que seja possvel colocar um else em um bloco mais externo. (Veja o exemplo acima)
Instruo switch Outra maneira de se desviar o fluxo de um programa a instruo switch. Usamos o switch para substituir uma sequncia de if's desde que obedeam algumas condies. Exemplo:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. char op = 'S'; switch (op) { case 'S' : case 's' : System.out.println("Opo selecionada = 's' ou 'S'"); break; case 'N' : case 'n' : System.out.println("Opo selecionada = 'n' ou 'N'"); break; default : System.out.println("Digite apenas 'S' ou 'N'"); }
Imprime: Opo selecionada = 's' ou 'S' Notas:

Apesar de no estar errado, no necessrio delimitar os blocos de cada case com chaves. Se no existir nada na linha do case, o case imediatamente a seguir ser selecionado no caso de sua condio ser verdadeira. Veja linhas 4 e 5. A instruo switch no permite expresses que retornem referncias nem variveis primitivas como long, float e double. So vlidos apenas os tipos byte, short, char e int. Note que a varivel op do exemplo um char. Se necessrio voc poder usar um cast para ajustar o retorno da expresso a um tipo vlido. Tambm no podemos usar operadores do tipo >=, <=, testar intervalos etc. A instruo case s pode verificar igualdade. Cada case s pode ser associado a um literal. No se pode usar variveis nas linhas case. O comando break no final da seleo case o responsvel pela interrupo do fluxo do programa. Se a seleo encontrada no contiver um brake, o programa executa todos os cases abaixo at encontrar algum outro break ou o final do comando switch. A instruo default ser selecionada sempre que nenhum case conseguir uma igualdade com o retorno da expresso do switch. Se a varivel op fosse igual a 'X', por exemplo, a mensagem que seria impressa seria: Digite apenas 'S' ou 'N'
Obs: Realmente, para quem est acostumado ao case do VB ou do Delphi por exemplo, vai ficar um pouco decepcionado. O Java implementou o case exatamente da mesma forma que em C++; Mesmo assim, usamos bastante o switch/case em aplicaes com interface grfica para decidir qual dos componentes do mesmo tipo gerou um determinado evento.
Instrues de controle de loops Instruo for Possibilita o controle de laos de repetio (loops). Testa a condio antes de executar o bloco. Sintaxe: for (Exp1 ; Exp2 ; Exp3) { <Comandos> }
Exp1 uma expresso que executada antes de iniciar o loop propriamente dito. Normalmente usamos a Exp1 para criar e/ou inicializar a varivel de controle. Exp2 a expresso responsvel pelo controle do nmero de repeties. Em Java, Exp2 sempre uma expresso booleana. Enquanto o retorno de Exp2 for verdadeiro o lao no termina. Exp3 s executada no final do loop. Normalmente usamos esta expresso para modificar o contedo da varivel de controle. A nica expresso obrigatria a Exp2 (Controle de interaes), Exp1 e Exp3 podem ser suprimidas de acordo com a lgica da aplicao. Uma diferena entre C/C++ e Java que todas as expresses do for podem ser suprimidas. As expresses so separadas entre si por ; (ponto e vrgula) possvel escrever mais de uma expresso separadas por vrgulas.
Notas:
Exemplos:
1. int soma = 0; 2. for (int i = 1 ; i < 100 ; i++) soma += i; 3. System.out.println("Soma de inteiros entre 1 e 99: + soma);
Imprime: Soma de inteiros entre 1 e 99: 4950 Finished executing

1. int j = 6; 2. for (;j<10;) { 3. System.out.println("Valor do contador: 4. }
" + j++);
Imprime: Valor do Valor do Valor do Valor do Finished Nota: Veja que a nica expresso usada neste for (linha 2) a expresso lgica de controle de repeties: Exp2. Exp1 no foi necessria pois o j foi declarado e inicializada imediatamente antes do for. A varivel de controle j est sendo incrementada de dentro do mtodo println. contador: contador: contador: contador: executing 6 7 8 9
1. int soma = 0; 2. for (int i=0, j=10 ; i < 10 ; i++, j--) soma += ( i + j ); 3. System.out.println("Valor do contador: " + soma);
Imprime: Valor do contador: 100 Finished executing Notas:
Neste exemplo usamos o local reservado para primeira expresso para declarar duas variveis. Esta variveis so locais ao for. No lugar da terceira expresso e incrementamos o i e depois decrementamos o j. A varivel soma teve que ser declarada fora do for para que possa ser usada fora dele. Se fosse declarada junto com o i e com o j, no poderia ser usada fora de seu contexto. Variveis declaradas em Exp1
Caso seja usado o recurso de declarar uma ou mais variveis na Exp1 do for, estas variveis sero locais ao lao for. Assim, caso exista alguma varivel membro de mesmo nome, no haver risco de modificao da varivel membro de mesmo nome: Exemplo:
1. public class TesteEscopoFor { 2. public static int i = 10;
3. public static void main (String args[]) { 4. 5. for (int i = 1, j = 5; i < 3; i++, j--) { 6. System.out.println ("Valor interno de i: 7. System.out.println ("Valor interno de j: 8. } 9. System.out.println ("Valor externo de i: " 10.// System.out.println ("Valor externo de j: " 11. } 12.}
" + i ); " + j ); + i ); + j ); // No compila
Imprime: Valor Valor Valor Valor Valor Notas:

interno interno interno interno externo
de de de de de
i: j: i: j: i:
1 5 2 4 10
A linha 12 no compilar, porque a varivel j s existe no contexto do for Caso seja necessrio acessar a varivel membro dentro do for, basta referenci-la usando a palavra reservada this. ( this.i )
Instruo while Sintaxe: while ( <Exp> ) { <comandos> }
Exp uma expresso booleana. O lao while executado enquanto o resultado da expresso Exp retornar true; Usamos o lao while quando necessrio testar uma condio antes de executar alguma instruo. As chaves so necessrias apenas se existirem mais de um comando associado ao while.
Notas:

Exemplos:
1. int soma = 0, i = 1; 2. while (i < 100) soma += (i++); 3. System.out.println("Soma de inteiros entre 1 e 99: " + soma);
1. boolean teste = true; 2. int i = 1, soma = 0; 3. while (teste) { 4. soma += (i++); 5. if (i > 99) teste = false; 6. } 7. System.out.println("Soma de inteiros entre 1 e 99: " + soma);
Instruo do/while Sintaxe: do { <comandos> } while ( <Exp> );
Exp uma expresso booleana. O lao do/while executado enquanto o resultado da expresso Exp retornar true; Usamos o lao while quando necessrio testar uma condio depois de executar alguma instruo. As chaves so necessrias apenas se existirem mais de um comando associado ao do/while. O compilador quando encontra um do, considera-o como incio da lao. Tudo a seguir estar dentro do lao at encontrar o while finalizador. Note que no final do while sempre deve existir um ; (ponto e vrgula). Se no existir este ponto e vrgula, o compilador ir considerar que um novo while interno ao lao do/while. Fatalmente ocorrer um erro de sintaxe pois o while terminador do do jamais ser encontrado...
Notas:

Exemplos:
1. int i = 0; 2. do i++; while (i < 100); 3. System.out.println("Valor de i no final: " + i);
Imprime: Valor de i no final: 100 Finished executing

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. int interacoes = 0, i = 0, j = 0; do { i++; while (j < 100) { interacoes++; j++; } j=0; } while (i<100); System.out.println("Nmero de interaes: " + interacoes);
Imprime: Nmero de interaes: 10000 Finished executing Note que existe um while (linha 4) aninhado ao do/while (entre as linhas 2 e 10).
Instruo break O comando break pode aparecer em dois lugares distintos e em ambos como um comando auxiliar. No comando switch, como vimos, marca o fim do bloco de execuo do case verdadeiro. A segunda aplicao fica por conta da interrupo de um lao qualquer (for, while e do/while) Exemplo:
1. double soma = 0F; 2. int interacoes = 0; 3. while (interacoes < 10000) { 4. soma += Math.random(); 5. interacoes++; 6. if (soma > 1000) break; //Aborta o lao caso soma ultrapasse 1000 7. } 8. System.out.println("Interaes: " + interacoes);
Imprime: Interaes: 2032 Finished executing Obs: O mtodo random da classe Math, gera um nmero randmico entre 0.0 e 1.0. (exclusive) O teste do while verifica se as interaes no passam de 10000. Porm, na linha 6, um if monitora o valor de soma: Caso ultrapasse a 1000 o break abortar o while mesmo antes da varivel interacoes chegar em 10000. O comando break no considerado l muito estruturado... quanto mais OO... O abuso de break em laos pode tornar o cdigo mais difcil de ser depurado. Afinal o lao pode ser interrompido por outros motivos que no a condio do controle de repetio virar para false. Ainda mais que substituir o break por algum outro recurso quase sempre muito simples. Veja o exemplo acima modificado para eliminar o break:
1. double soma = 0F; 2. int interacoes = 0; 3. while (interacoes < 10000 && soma <= 1000) { 4. soma += Math.random(); 5. interacoes++; 6. } 7. System.out.println("Interaes: " + interacoes);
Imprime: Interaes: 2101 Finished executing
Instruo continue O comando continue est no mesmo time do comando break. Existe, est ai para ser usado mas no l muito bem visto. Ele funciona pulando tudo que est abaixo dele at o final do loop. O continue no interrompe o lao, apenas no permitir a execuo do que est abaixo dele at o final da interao corrente. Exemplo:
1. 2. int soma = 0; int interacoes = 0;
3. while (soma < 1000) { 4. int denominador = (int)(Math.random()*100.0)-50; 5. if (denominador == 0) continue; 6. soma += (50 / denominador); 7. interacoes++; 8. } 9. System.out.println("Interaes: " + interacoes);
Imprime: Interaes: 3463 Finished executing Na linha 4, a varivel denominador pode assumir qualquer valor inteiro entre -49 e +49, inclusive zero. O continue da linha 5 tem a finalidade de no permitir que a diviso da linha 6 acontea, caso o denominador seja zero, evitando assim um erro fatal (diviso de um inteiro por zero): java.lang.ArithmeticException: / by zero Como no caso do break, o continue poderia ser facilmente evitado conforme mostramos abaixo:
10. 11. 12. 13. 14. 15. 16. 17. 18. 19. int soma = 0; int interacoes = 0; while (soma < 1000) { int denominador = (int)(Math.random()*100.0)-50; if (denominador != 0) { soma += (50 / denominador); interacoes++; } } System.out.println("Interaes: " + interacoes);
Imprime: Interaes: 7457 Finished executing Obs: O nmero de interaes diferente nos dois exemplos, porque estamos lidando com um mtodo randmico. Cada vez que roda, obtemos um resultado diferente.
Instruo for/each (enhanced for) A partir da verso Java 1.5 lanado pela SUN em 2004, a linguagem passou a contar com o controle de loop estilo for/each. A principal motivao na implementao do novo estilo de lao facilitar os loops onde se percorre por inteiro listas homogenias como arrays, collections etc. A performance dos laos for/each melhor que dos laos indexados porque o uso de ndices consome mais instrues de mquina do que o incremento de referncias necessrio para percorrer uma lista. Exemplos:
1. String []semana = {"Seg","Ter","Qua", 2. "Qui","Sex","Sb","Dom"}; 3. 4. for(String dia:semana) { 5. if ("Qua".equals(dia) || "Sb".equals(dia)) continue; 6. System.out.println("-"+dia); 7. }
Imprime:
-Seg -Ter -Qui -Sex -Dom
Note que os dias Qua e Qui no foram impressos!

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. List<String> meses = new ArrayList<String>(); meses.add("Janeiro"); meses.add("Fevereiro"); meses.add("Maro"); meses.add("Abril"); for (String mes: meses) { System.out.println("Ms: " + mes + "."); }
Imprime: Ms: Ms: Ms: Ms: Janeiro. Fevereiro. Maro. Abril.
1. public Integer sum(Integer [] intArray) { 2. int total = 0; 3. for (int num : intArray) { 4. total += num; 5. } 6. return total; 7. }
Instrues rotuladas Instruo break rotulado Mesmo com as restries aos comando break e continue, Java "resolveu incrementar ambos ainda com mais poder. No existem estas instrues rotuladas em C/C++. A principal razo de existncias das instrues rotuladas permitir que um lao mais interno de loops aninhados possa abortar no o lao onde est o break, mas qualquer outro mais externo. Exemplo:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. int i=0, j=0, k=0; i_laco: // label para o lao mais externo for (i=0;i<10;i++) { System.out.println ("Lao i: " + i); j_laco: // label para o lao mais interno for (j=0;j<10;j++) { System.out.println ("Lao j: " + j); if (Math.random() > 0.5) break i_laco; for (k=0;k<10;k++) { System.out.println ("Lao k: " + k); if (Math.random() > 0.5) break j_laco; } }
Imprime: Lao i: 0 Lao j: 0 Lao k: 0 Lao k: 1 Lao k: 2 Lao k: 3 Lao k: 4 Lao k: 5 Lao i: 1 Lao j: 0 Finished executing
Instruo continue rotulado Exemplo:

1. i_laco: // label 2. for (int i=0;i<10;i++) { 3. for (int j=0;j<10;j++) { 4. if (Math.random() > 0.5) continue i_laco; 5. System.out.println ("Valor de i: " + i + " Valor de j: " + j); 6. } 7. }
Imprime:
Valor de Valor de Valor de Valor de Valor de Valor de Valor de Valor de Valor de Valor de Finished
i: 1 Valor i: 1 Valor i: 3 Valor i: 5 Valor i: 5 Valor i: 6 Valor i: 6 Valor i: 6 Valor i: 6 Valor i: 7 Valor executing
de de de de de de de de de de
j: j: j: j: j: j: j: j: j: j:
0 1 0 0 1 0 1 2 3 0
Instruo return Usado para retornar variveis ou objetos em mtodos. Exemplos:

1. 2. 3. 1. 2. 3. public double getSalario() { return salario; } public String getNomeCompleto() { return nome + " " + sobrenome; }
O comando return obrigatrio caso o mtodo tenha sido declarado com qualquer tipo de retorno, exceto void. Exemplo:
1. 2. 3. public void setNome(String nome) { this.nome = nome; // No tem return; }
possvel existir mais de um return em um mtodo: Exemplo:

1. public double getSalario() { 2. if (salario > 10 * salarioMinimo) return salario*0.95; 3. else return salario; 4. // return salario * 0.80; // Esta linha jamais seria executada 5. }
Nota: Qualquer instruo aps um return gera um erro de compilao. (Veja linha 4 do ltimo exemplo)
Comentrios em Java
Entre delimitadores ( /* .... */ ) :
Exemplo: /* Isto no ser compilado e pode ter mais de uma linha */
Usando duas barras normais. (// ...) Exemplo: // Este um comentrio de apenas uma linha Comentrio de documentao (Javadoc): ( /** ... ) Exemplo: /** Comentrio de documentao */ Escrevendo o primeiro programa (Console)
Passo a passo: Abra o Eclipse... Inicialmente vamos criar um projeto: File -> New -> Project ... -> Java Project Digite o nome do projeto: Sugesto: prjTeste Selecione a opo: Create project at external location. Selecione a pasta onde deseja colocar o seu projeto. ( possvel criar a pasta caso ainda no exista) Clique em Finish Agora nossa primeira (e nica) classe. Siga o caminho: File -> New -> Other -> Class Digite um nome para a classe: Sugesto: PrimeiroTeste -> Clique em Finish Nota: No momento da criao da classe, voc tem opo de criar tambm o pacote (package) com o nome que voc quiser. O editor do Eclipse ir abrir com um texto mais ou menos assim: /* * Criado em: 14/01/2010 * * TODO */ /** * @author Helio Rangel * * TODO */ public class PrimeiroTeste { }
Notas:
O primeiro comentrio, com data de criao um comentrio comum configurvel para cada estao/usurio. (O Eclipse gerou automaticamente para voc.) O segundo um tipo especial de comentrio (veja: Comentrios em Java ) e usado pelo utilitrio Javadoc para gerar a documentao automtica.
Digite no espao entre as chaves da classe PrimeiroTeste o cdigo:

1. public class PrimeiroTeste { 2. 3. public static void main (String args[]) { 4. System.out.println("Meu primeiro programa!!!"); 5. } 6. }
Imprime: Meu primeiro programa!!! Escrevendo o segundo programa (Console) Nosso segundo exemplo vai usar os argumentos da linha da comando: args[]. Como em C/C++ e outras linguagens possvel passar argumentos diretamente via prompt de comando.
1. public class SegundoTeste { 2. 3. public static void main(final String args[]) { 4. 5. for (int i=0; i< args.length;i++) 6. System.out.println(i + 1 + ")" + args[i]); 7. } 8. }
Para facilitar a vida do desenvolvedor, o Eclipse permite a digitao de argumentos sem necessidade de sair do ambiente de desenvolvimento. Siga o caminho: Run Open Run Dialog (paleta Arguments) Digite os argumentos na janela Program Arguments separados por espaos:
Imprime: 1)Jose 2)Pedro 3)Maria 4)Antnio
Mtodos Especiais O Mtodo Construtor Os construtores so mtodos especiais usados para ajudar "construir o objeto no momento de sua criao. Os mtodos construtores so usados principalmente para inicializar as propriedades. Um mtodo construtor no retorna nada (nem void) e necessariamente tem o mesmo nome da classe. Os mtodos construtores so chamados automaticamente quando da criao do objeto (new), assim ele no invocado diretamente associado a um objeto. (lembra que ele ainda est em construo?), e portanto, no tem para quem retornar um valor. Mesmo que o programador no escreva explicitamente um construtor, Java cria um construtor implcito (ou default) sem argumentos e sem corpo. Os construtores so muito importantes no processo de projetar as classes e sua hierarquia. Se necessrio, os construtores podem ser sobrecarregados. (Veremos sobrecarga mais a frente) Exemplo:
1. public class QuadradoBase { 2. protected double area, perimetro, diagonal; 3. public QuadradoBase(double lado) { // Construtor 4. area = lado * lado; 5. perimetro = 4 * lado; 6. diagonal = lado * Math.sqrt(2); 7. } 8. public double getArea() { 9. return area; 10. } 11. public double getPerimetro() { 12. return perimetro; 13. } 14. public double getDiagonal() { 15. return diagonal; 16. } 17. protected void finalize () { 18. System.out.println("Fim do quadrado...); 19. } 20.}
Note que o construtor (linha 3) um mtodo pblico sem declarao de tipo de retorno e com o mesmo nome da classe: QuadradoBase. Ele responsvel pelo clculo da rea, permetro e diagonal do quadrado. Os construtores no so herdados pelas subclasses, mas devem ser "chamados por elas. Assim, se uma classe subclasse de uma superclasse onde existe um construtor, o construtor da subclasse obrigado chamar o construtor da superclasse passando os argumentos necessrios. Para isso usamos a palavra reservada super. Ainda no vimos herana em detalhes mas, mesmo assim vamos dar uma olhada no exemplo abaixo:
1. public class Quadrado extends QuadradoBase { 2. private double lado; 3. public Quadrado (double lado) { 4. super(lado); // Passando para o construtor da 5. // super classe o lado do quadrado 6. this.lado = lado; 7. } 8. public void setLado(double lado) { 9. area = lado * lado; 10. perimetro = 4 * lado; 11. diagonal = lado * Math.sqrt(2); 12. } 13.}
Mtodo finalizadores Java no implementou exatamente o destrutor de C/C++ porque o destrutor, por definio, executado imediatamente no momento da "morte do objeto. Java usou outro nome um pouco mais light. O mtodo finalizador entra em uma fila de threads, sendo efetivamente executado quando a thread ganhar o processador. O motivo para usar uma thread para destruir o objeto se justifica: Normalmente a alocao e desalocao de recursos leva certo tempo uma vez que so operaes de entrada e sada. O mtodos finalizadores no podem receber argumentos e, como os construtores, tambm no podem retornar nada. Usamos os mtodos finalizadores para liberar recursos alocados pelo mtodo. Fechar arquivos, liberar canais, desbloquear tabelas e, porque no, liberar as referncias de objetos para "facilitar a vida do coletor de lixo. O mtodo finalize, por ser um mtodo assncrono em relao a aplicao, no bem visto pela comunidade Java e deve ser evitado sempre que possvel. O nome do mtodo finalizador uma palavra reservada: finalize Veja o exemplo na linha 17 da classe QuadradoBase. Para verificar o funcionamento do construtor e do finalize, vamos examinar o exemplo:
1. public class TesteQuadrado { 2. public static void main (String args[]) { 3. Quadrado q = new Quadrado(10); 4. System.out.println("rea do quadrado: " + q.getArea()); 5. System.out.println("Diagonal: " + q.getArea()); 6. q = null; 7. System.gc(); 8. } 9. }
Imprime: rea do quadrado: 100.0 Diagonal: 14.142135623730951 Fim do quadrado... Finished executing Como j comentamos, o momento em que o finalize realmente executado desconhecido. Sabemos que o finalize necessariamente roda antes do coletor de lixo liberar a memria do objeto. No exemplo acima, na linha 7 foramos o coletor de lixo a executar chamando o mtodo da classe System: gc(). (Garbage Collector). Assim, o finalize roda ainda a tempo de ser mostrado na sada do programa. A chamada para o construtor da superclasse (Quadrado) super (linha 4) deve ser a primeira coisa que aparece no construtor. ilegal fazer chamadas ou criar variveis antes da chamada do super. H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 64
Principais Caractersticas da POO

Encapsulamento a tcnica de controlar o acesso de terceiros as propriedades e mtodos das classes. Quando criamos uma varivel membro em nossa classe, muitas vezes (quase sempre) precisamos ter controle de 100% de seu contedo. Se o usurio de nossa classe pudesse acessar livremente as propriedades isso poderia comprometer a segurana de nosso cdigo. Veja o exemplo:
1. public class Circulo { 2. 3. public double raio, area, perimetro; 4. private final double pi = 3.1415926535; 5. 6. public Circulo (double raio) { 7. this.raio = raio; 8. calculaArea(); 9. calculaPerimetro(); 10. } 11. public void calculaArea() { 12. area = pi * this.raio * this.raio; 13. } 14. public void calculaPerimetro () { 15. this.perimetro = 2 * pi * this.raio; 16. } 17.}
Note que as variveis membro raio, area e perimetro so todas pblicas. Vamos criar um programa que usa a classe Circulo:
1. public class TesteEncapsulamento { 2. 3. 4. 5. 6. 7. 8. static public void main (String args[]) { Circulo C1 = new Circulo (10); System.out.println("Crculo de raio: " + C1.raio); System.out.println("rea:............" + C1.area); System.out.println("Permetro........" + C1.perimetro); C1.area = 100; C1.raio = 5;
9. System.out.println("Crculo de raio: " + C1.raio); 10. System.out.println("rea:............" + C1.area); 11. System.out.println("Permetro........" + C1.perimetro); 12. } 13.}
Imprime: Crculo de raio: 10.0 rea:............314.15926535 Permetro........62.83185307 Crculo de raio: 5.0 rea:............100 Permetro........62.83185307 Finished executing
Como podemos notar, o programa no funcionou como espervamos. O segundo crculo, o de raio 5 (Linha 8), mostrou como rea um valor fixo e incorreto (100) ... e como permetro o mesmo valor do primeiro crculo.. . O usurio poderia cometer este erro, sem conhecer o cdigo da classe Crculo, "imaginando que a classe calcularia automaticamente a nova rea e permetro assim que fosse alterado o raio. Quando permitimos que o usurio modifique diretamente o raio ou qualquer outra varivel membro, estamos acabando com a confiabilidade da classe... Agora vamos reescrever a classe Circulo usando corretamente o princpio do encapsulamento:
1. public class Circulo { 2. 3. private double raio, area, perimetro; private final double pi = 3.1415926535;
4. public Circulo (double _raio) { // Construtor 5. this.raio = _raio; 6. calculaArea(); 7. calculaPerimetro(); 8. } 9. public void calculaArea() { 10. this.area = pi * this.raio * this.raio; 11. } 12. public void calculaPerimetro () { 13. this.perimetro = 2 * pi * this.raio; 14. } 15. public void setRaio (double _raio) { 16. if (_raio > 0) { // Raio deve ser maior que zero. 17. this.raio = _raio; 18. calculaArea(); 19. calculaPerimetro(); 20. } else System.out.println ("Raio deve ser maior que zero"); 21. } 22. public double getRaio() { 23. return this.raio; 24. } 25. public double getArea() { 26. return this.area; 27. } 28. public double getPerimetro() { 29. return this.perimetro; 30. } 31.}
Notem que as variveis membro agora so todas privadas (linha 2). Escrevemos mais quatro mtodos: setRaio(), getRaio(), getArea() e getPerimetro(). Estes tipos de mtodos so caractersticos de projetos de classes para atender o encapsulamento. Com eles possvel permitir que o usurio acesse as variveis membro sem risco para o funcionamento correto da classe. Os prefixos get para mtodos que fazem leitura de variveis membro e os mtodos set para os mtodos que podem modificar os seus valores so consagrados e recomendados. Nos mtodos get costumamos tambm acrescentar cdigo de consistncia para evitar entrada de argumentos ilegais. (linha 16) Nota: Utilizamos a constante pi com seu valor declarado dentro do cdigo mas poderamos tambm utilizar a constante PI declarada da classe de funes matemticas utilitrias Math. Os mtodos calculaArea() e calculaPerimetro() ficariam assim: 9. public void calculaArea() {
10. this.area = Math.PI * this.raio * this.raio; 11. } 12. public void calculaPerimetro () { 13. this.perimetro = 2 * Math.PI * this.raio; 14. }
Agora vamos ver como fica o programa:

1. public class TesteEncapsulamento { 2. 3. static public void main (String args[]) { 4. 5. Circulo C1 = new Circulo (10); 6. 7. System.out.println("Crculo de raio: "+C1.getRaio()); 8. System.out.println("rea:............"+C1.getArea()); 9. System.out.println("Permetro........"+C1.getPerimetro()); 10. 11. C1.setRaio(5); 12.//C1.area = 100; 13. 14. System.out.println("Crculo de raio: "+C1.getRaio()); 15. System.out.println("rea:............"+C1.getArea()); 16. System.out.println("Permetro........"+C1.getPerimetro()); 17. } 18.}
Imprime: Crculo de raio: 10.0 rea:............314.15926535 Permetro........62.83185307 Crculo de raio: 5.0 rea:............78.5398163375 Permetro........31.415926535 Finished executing Melhorou no acha? Agora ao usar o mtodo setRaio(), o usurio est tambm recalculando a rea e o permetro de uma forma transparente para ele. A linha 12 teve que ser comentada porque no mais possvel alterar diretamente o valor do raio via varivel membro j que agora ela no mais pblica. A primeira vista, pode parecer ao programador experiente, que isso um excesso de segurana ou cuidado. No final das contas a classe Circulo ficou maior e mais complexa. No mtodo main fomos obrigados a usar mtodos para obter as informaes que antes fazamos diretamente. Para que? Ser que todo este trabalho se justifica? A explicao simples: Um dos pontos fortes da POO o fato de que ela permite reutilizao de cdigo fcil e segura. No nosso exemplo, ao construir a classe Circulo, ns no estamos construindo para o nosso uso particular. Na verdade no sabemos quem ir usar... seu bom senso, sua experincia e formao... Incluir segurana nas classes pode viabilizar sistemas seguros com menor possibilidade de erros de programao e lgica. O Encapsulamento apenas um dos muitos recursos da POO para melhorar a segurana e reusabilidade de cdigo.
Sobrecarga um recurso da POO que permite a criao de classes de uso mais intuitivo. Com menor necessidade de treinamento por parte dos usurios. Dois ou mais mtodos so sobrecarregados quando possuem o mesmo nome mas se diferenciam pelo tipo e/ou quantidade de argumentos (assinaturas). Podemos ter sobrecarga de mtodos construtores ou no. A Sobrecarga pode ocorrer tambm entre mtodos da classe corrente e de alguma superclasse que faa parte de sua hierarquia. Vamos a um exemplo: A classe abaixo uma classe composta por mtodos estticos. Como j vimos, podemos usar estes mtodos usando o nome da classe no lugar do nome do objeto.
1. public class MostraTipo { 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.} static private int numeroChamadas = 0; static public String tipo (char a) { numeroChamadas++; return "char"; } static public String tipo (int a) { numeroChamadas++; return "int"; } static public String tipo (long a) { numeroChamadas++; return "long"; } static public String tipo (double a) { numeroChamadas++; return "double"; } static public String tipo (float a) { numeroChamadas++; return "float"; } static public String tipo (String a) { numeroChamadas++; return "string"; } static public int getNumeroChamadas() { return numeroChamadas; }
Note que todos os mtodos da classe tem o mesmo nome (tipo) e retornam um String, mas cada um recebe um argumento de tipo diferente...
Vamos ao programa executvel:

1. public class TesteSobrecarga { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. } 25. } static public void main (String args[]) { MostraTipo t1 = new MostraTipo(); // Criando objeto String tipo = t1.tipo(88F); //Usando mtodo Tipo com um float System.out.println(tipo); String a = long b = int c = float d = double e = byte f = char g = Circulo C1 "Man"; 12344L; 45; 3F; 5D; -8; 65; = new Circulo(1);//Criando um objeto Crculo para teste
System.out.println(a +" um " + MostraTipo.tipo(a)); System.out.println(b +" um " + MostraTipo.tipo(b)); System.out.println(c +" um " + MostraTipo.tipo(c)); System.out.println(d +" um " + MostraTipo.tipo(d)); System.out.println(e +" um " + MostraTipo.tipo(e)); System.out.println(f +" um " + MostraTipo.tipo(f)); System.out.println(g +" um " + MostraTipo.tipo(g)); System.out.println("Total:" + MostraTipo.getNumeroChamadas() + " chamadas."); // System.out.println(MostraTipo.tipo(C1));
Imprime: float Mane um string 12344 um long 45 um int 3.0 um float 5.0 um double -8 um int A um char Total: 8 chamadas Finished executing O Compilador verifica qual o tipo do argumento que est sendo passado para o mtodo e decide qual deles (sobrecarregados) usar. Caso exista um mtodo sobrecarregado com exatamente o mesmo tipo ele ser usado imediatamente. Caso seja passado um tipo que no existe mtodo sobrecarregado para ele, o compilador "se vira e procura o mtodo disponvel que possa servir sem prejuzo de preciso. Na linha 19 passamos uma varivel do tipo byte. Note que no existe nenhum mtodo tipo( ) para tratar variveis do tipo byte. O compilador "resolveu o problema utilizando o mtodo que trata inteiros pois, neste caso, no haver perda de preciso. Se o compilador no conseguir uma soluo vivel, ocorrer um erro de compilao com a mensagem: Smbolo no pode ser resolvido. Na linha 23, que foi comentada, se tentou passar um argumento para o mtodo tipo( ) que um objeto da classe Circulo. O compilador no consegue resolver este problema e interrompe a compilao. A mensagem significa que no existe um mtodo tipo( ). Pelos menos para objetos da classe Crculo.
Overriding (Sobrescrita) De maneira anloga a sobrecarga, overriding permite criao de classes e pacotes de uso mais fcil e intuitivo, sem perda segurana e facilitando a reusabilidade. Overriding muitas vezes confundido com sobrecarga. As diferenas podem parecer sutis mas so importantes. Temos overriding quando existe um mtodo em uma superclasse de mesmo nome mas com argumentos idnticos. Para que haja overriding necessrio que estejamos trabalhando em um projeto com herana. Vejamos e exemplo: Primeiro a superclasse Quadrilatero:
1. public abstract class Quadrilatero { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22.} protected String ID; protected double lado1; protected double lado2; public Quadrilatero(final double _l1, final double _l2){ this.lado1 = _l1; this.lado2 = _l2; } public double getArea() { return this.lado1 * this.lado2 ; } public double getPerimetro() { return 2 * (this.lado1 + this.lado2); } public double getDiagonal() { return Math.sqrt(this.lado1 * this.lado1 + this.lado2 * this.lado2); } public String getTipoQuadrilatero() { return ID; }
Agora a classe Quadrado:

1. public class Quadrado extends Quadrilatero { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14.} public Quadrado (final double _lado) { super(_lado, _lado);// Repassando argumentos para a superclasse super.ID = "Quadrado"; } @Override // Anotao indicando que o mtodo sobrescrito. public double getPerimetro() { return 4.0 * super.lado1; } @Override public double getDiagonal() { return super.lado1 * Math.sqrt(2.0); }
A subclasse Retangulo
1. public class Retangulo extends Quadrilatero { 2. 3. public Retangulo(double final _lado1, double final _lado2){ 4. super(_lado1, _lado2); // Repassando argumentos para a superclasse 5. super.ID = "Retngulo"; 6. } 7. }
Finalmente a classe de teste:

1. public class TesteOverriding { 2. static public void main (String args[]) {
3. Quadrado fig01 = new Quadrado (1); 4. Retangulo fig02 = new Retangulo (3,4); 5. 6. System.out.println("Diagonal do " + 7. fig01.getTipoQuadrilatero()+": "+ fig01.getDiagonal()); 8. 9. System.out.println("Diagonal do " + 10. fig02.getTipoQuadrilatero()+": "+ fig02.getDiagonal()); 11. } 12.}
Imprime: Diagonal do Quadrado: 1.4142135623730951 Diagonal do Retngulo: 5.0 Finished executing Vamos l: Temos aqui uma super classe chamada Quadrilatero com duas subclasses estendidas dela. So elas as classes Quadrado e Retangulo. Rigorosamente um quadrado um caso especial de retngulo e o calculo da rea, permetro e diagonal de ambos obedecem exatamente as mesmas regras. Apenas com objetivo didtico, reescrevemos o mtodo getDiagonal() dentro da subclasse Quadrado usando uma forma de clculo alternativa. Observe que tambm existe este mtodo definido na superclasse Quadrilatero. Note que em TesteOverriding chamamos para o objeto fig01 e fig02 o mtodo getDiagonal(). Aqui entra o conceito de sobrescrita. O compilador procura um mtodo getDiagonal() subindo da classe onde aparece a chamada nvel a nvel at a superclasse de maior nvel, procurando um mtodo de mesmo nome. O primeiro encontrado ser usado. No caso do objeto fig01 que um quadrado, o compilador encontrou o mtodo j na subclasse Quadrado e usou. No caso do objeto fig02, que um retngulo, no existe nenhum mtodo getDiagonal() na classe Retangulo. O compilador ento, procura nas classes hierarquicamente superiores at que encontre getDiagonal() na superclasse Quadrilatero. Portanto, os mtodos chamados nas linhas 7 e 10, apesar de terem o mesmo nome, so mtodos diferentes sobrescritos.
Herana (ou extenso) Herana ou extenso a caracterstica da POO mais importante para reutilizao de cdigo. A idia que muito raro que se encontre um problema 100% novo. Quase sempre precisamos acertar alguma condio particular de problema que, em sua maior parte, j foi equacionado e resolvido. Em POO, definimos como superclasse uma classe que foi estendida. A classe que estendemos tratamos por subclasse. Em uma hierarquia de classes, uma mesma classe pode ser subclasse de uma e superclasse de outra (veja os exemplos). Modificar o que j existe e funciona temeroso porque nos arriscamos a criar novos bugs e acabar estragando alguma coisa que funcionava corretamente. Com a herana, podemos usar esta classe j existente como superclasse sem fazer nenhuma modificao e herdar dela nossa subclasse. Uma subclasse pode ter todos os mtodos e propriedades da superclasse e mais as novas que escreveremos.. Vamos ao exemplo: Transporte Aqutico Motor Lancha Navio Balsa Vela Iate a vela Laser Pinguim Terrestre Carga Passageiro Moto Ferrovirio Carga Passageiro Areo Vela Motor Seguindo a rvore hierrquica acima, poderamos construir uma coleo de dezenas de classes. Para exemplificar vamos seguir apenas o ramo assinalado em negrito. A primeira classe considerada a classe base. uma classe que por ser abstrata no permite que se crie um objeto diretamente dela. Neste caso s usamos o abstract para exemplificar seu uso. Vamos examinar a classe abstrata Transporte:
1. abstract public class Transporte { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14.} private String nomeSubclasse; // Nome da subclasse associada static private int numeroObjetos; // Contador de objetos public Transporte (String _nomeSubclasse){ // Construtor this.nomeSubclasse = _nomeSubclasse; numeroObjetos++; } public int getNumeroObjetos() { return numeroObjetos; } public String getNomeSubclasse() { return nomeSubclasse; }
Seguindo a rvore, a prxima classe, Aquatico, ser estendida de Transporte:
1. public class Aquatico extends Transporte { 2. 3. private int comprimentoPes; 4. private String nomeSubclasse; 5. 6. public Aquatico (final int _comprimentoPes, 7. final String _nomeSubclasse) { 8. super("Aqutico"); // Chamando o construtor da superclasse 9. this.comprimentoPes = _comprimentoPes; 10. this.nomeSubclasse = _nomeSubclasse; 11. } 12. public int getComprimentoPes () { 13. return this.comprimentoPes; 14. } 15. public String getNomeSubclasse (){ 16. return this.nomeSubclasse; 17. } 18.}
Note que ambas as classes, Transporte e Aquatico possuem um mtodo getNomeSubClasse(). Quem poderia chamar o mtodo getNomeSubclasse() da classe Transporte?
Derivamos de Aquatico a classe Motor:

1. public class Motor extends Aquatico { 2. 3. protected String nomeSubclasse; 4. protected int capacidadeTanque; 5. protected int quantidadeCombustivel; 6. 7. public Motor (final int _capacidadeTanque, 8. final int _comprimentoPes, 9. final String _nomeSubclasse) { 10. super(_comprimentoPes,"Motor"); 11. this.nomeSubclasse = _nomeSubclasse; 12. this.capacidadeTanque = _capacidadeTanque; 13. } 14. public void abastece (final int _litros) { 15. if (_litros + quantidadeCombustivel < capacidadeTanque) 16. quantidadeCombustivel += _litros; 17. else 18. System.out.println("Combustvel excede a capacidade do tanque."); 19. } 20. public int getQuantidadeCombustivel() { 21. return this.quantidadeCombustivel; 22. } 23. public String getNomeSubclasse (){ 24. return this.nomeSubclasse; 25. } 26.}
Continuando nosso caminho pela rvore, da classe Motor vamos derivar a classe Lancha
1. final public class Lancha extends Motor { 2. 3. private int capacidadePassageiros; 4. private String nomeLancha; 5. 6. public Lancha (final String _nomeLancha, 7. final int _capacidadeTanque, 8. final int _comprimentoPes, 9. final int _capacidadePassageiros) { 10. super(_capacidadeTanque,_comprimentoPes,"Lancha"); 11. this.nomeLancha = _nomeLancha; 12. this.capacidadePassageiros = _capacidadePassageiros; 13. } 14. public String getNomeLancha() { 15. return this.nomeLancha; 16. } 17. public int getCapacidadePassageiros() { 18. return this.capacidadePassageiros; 19. } 20.}
A classe Lancha foi declarada como final. Isto significa que no ser possvel estender a classe lancha (no poderemos derivar nenhuma classe dela). Este o significado do modificador final usado em declaraes de classes.
Finalmente vamos examinar a declarao e uso de um objeto da classe final.

1. public class TesteHierarquia { 2. 3. 4. 5. 6. // 7. 8. 9. 10. 11. 12. 13. 14. 15. public static void main (String args []) { Lancha flechaDoMar Lancha crepusculo Motor teste Transporte teste2 = = = = new new new new Lancha ("Flecha Do Mar",200,30,6); Lancha ("Crepsculo", 400, 20,4); Motor (400, 20,""); Transporte ("");
flechaDoMar.abastece(250); flechaDoMar.abastece(150); System.out.println ("Tanque de " + flechaDoMar.getNomeLancha() + " est com "+ flechaDoMar.getQuantidadeCombustivel() + " Litros."); System.out.println ("Lancha com capacidade para " + flechaDoMar.getCapacidadePassageiros() +" Passageiros."); System.out.println("Nome da classe: " + flechaDoMar.getNomeSubclasse());
16. System.out.println("Objetos:" + teste.getNumeroObjetos()); 17. System.out.println("Objetos:" + crepusculo.getNumeroObjetos()); 18. System.out.println("Objetos:" + flechaDoMar.getNumeroObjetos()); 19. } 20.}
Imprime: Combustvel excede a capacidade do tanque. Tanque de Flecha Do Mar est com 150 Litros. Lancha com capacidade para 6 Passageiros Nome da classe: Lancha Objetos: 3 Objetos: 3 Objetos: 3 Finished executing Vamos analisar nosso exemplo? Porque a linha 6 est comentada? As linhas 16, 17 e 18 mostram o mesmo valor... porque? Consideraes sobre Herana O uso inadequado de herana pode tornar o cdigo mais sujeito a erros. Para que o uso de herana seja seguro importante que a superclasse utilizada esteja dentro do contexto da API que est sendo desenvolvida. Estender classes de superclasses que no conhecemos bem, ou que podem ser modificadas sem critrio por terceiros, pode provocar erros que no sero fceis de localizar. Utilize herana dentro de pacotes de classes que esto sob sua responsabilidade ou da equipe responsvel pela arquitetura do sistema. As classes que no possuem vocao para ser estendida devem ser declaradas como finais como uma forma de diminuir a chance de algum us-la como superclasse. Se no desejar proibir extenses de sua classe, cuide pelo menos de declarar os mtodos crticos como finais para impedir que sejam sobrescritos. Quando estamos utilizando API's j testadas e consagradas, muito confortvel para o cliente se abstrair da implementao. Mas isso pode ser um problema durante o desenvolvimento de projetos onde as classes ainda no esto amadurecidas e sofrem constantes alteraes que podem comprometer o funcionamento de todas as classes que foram estendidas dela.
Composio de classes comparada com Herana A composio de classes pode ser uma alternativa para herana trazendo todo o poder da reutilizao de cdigo sem as limitaes da herana. Vamos imaginar uma classe Pessoa, uma classe Aluno e outra Professor. Ambas Professor e Aluno so estendidas de Pessoa e o diagrama de classes abaixo modela esta arquitetura:
Implementamos herana indicada no diagrama desta forma:

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 1. 2. 3. 4. 5. 6. 7. 1. 2. 3. 4. 5. 6. 7. public class Pessoa { private String nome; public Pessoa(String nome) { // Construtor this.nome = nome; } public String getNome() { return this.nome; } // Restante do corpo da classe. } public class Aluno extends Pessoa { public Aluno(String nome) { // Construtor super(nome); } // Restante do corpo da classe. } public class Professor extends Pessoa { public Professor(String nome) { // Construtor super(nome); } // Restante do corpo da classe. }
Na hora de usar as classes Aluno e Professor subclasses de Pessoa, podemos fazer:

1. public class TesteHeranca { 2. 3. public static void main(String args[]) { 4. Professor p = new Professor("Rangel"); 5. Aluno a = new Aluno("Pedro"); 6. System.out.println(p.getNome() + " professor de " + 7. a.getNome()); 8. } 9. }
No caso da composio o diagrama seria assim:
Implementamos Composio declarando um objeto da classe Pessoa dentro das classes Aluno e Professor. Vejamos o exemplo:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. public class Aluno {
private Pessoa pessoa; public Pessoa getPessoa() { return this.pessoa; } public Aluno(String nome) { this.pessoa = new Pessoa(nome); } // Restante do corpo da classe.
public class Professor { private Pessoa pessoa; public Pessoa getPessoa() { return this.pessoa; } public Professor(String nome) { this.pessoa = new Pessoa(nome); } // Restante do corpo da classe.
Na hora de usar as classes Aluno e Professor que compem Pessoa, podemos fazer:
1. public class TesteComposicao { 2. public static void main(String args[]) { 3. Professor p = new Professor("Rangel"); 4. Aluno a = new Aluno("Pedro"); 5. System.out.println(p.getPessoa().getNome() + " professor de " + 6. a.getPessoa().getNome()); 7. } 8. }
Imprime: Rangel professor de Pedro Note que quando fazemos associaes de classe por composio, continuamos nos beneficiando da reutilizao de cdigo mas temos a idia exata de qual mtodo estamos utilizando e onde eles esto definidos.
Mtodos e Classes Abstratas Classes abstratas no podem ser instanciadas, isto , no podem ser usadas para criar objetos. O motivo de sua existncia a criao de superclasses puras. Normalmente estas classes no fazem grande coisa. So projetadas para servir de "gancho para outras classes. Os mtodos abstratos (linha 19) existem basicamente para servir como referncia para polimorfismo. Um mtodo abstrato no pode conter cdigo nenhum. Deve terminar com um ; (ponto e vrgula) Exemplo:
1. public abstract class Funcionario { 2. private String nome; 3. private String sobrenome; 4. public Funcionario (final String _nome, 5. final String _sobrenome) { 6. this.nome = _nome; 7. this.sobrenome = _sobrenome; 8. } 9. public String getNome () { 10. return this.nome; 11. } 12. public String getSobrenome () { 13. return this.sobrenome; 14. } 15. public String getNomeCompleto() { 16. return this.nome + " " + this.sobrenome; 17. } 18. // O mtodo abstrato abaixo vai servir para o prximo tpico 19. public abstract double salario(); 20.}
Polimorfismo O Polimorfismo em Java foi implementado de uma maneira simples, mas sem que sua essncia tenha se perdido. Polimorfismo, como o nome sugere, significa mltiplas formas, ou seja, podemos usar o "nome de um mtodo (abstrato) para acessar dois ou mais mtodos (no abstratos). Por isso dizemos que pode adotar muitas formas. Polimorfismo muitas vezes confundido com sobrecarga. No o caso porque na sobrecarga o compilador que procura e decide qual mtodo usar levando em conta para isso o tipo e a quantidade de argumentos passados. No polimorfismo a lgica do programa que faz este papel. Apesar de sobrecarga e sobrescrita no ser rigorosamente considerados como polimorfismo, alguns autores tratam o assunto no captulo de polimorfismo. Basicamente usamos polimorfismo quando existe um trecho significativo de cdigo que se referencia a um determinado mtodo que na realidade pode ser mais de um... No melhorou muito n? Espere s mais um pouco. Vejamos o exemplo: Continuando no esprito do exemplo da classe abstrata acima. Vamos construir mais duas classes que sero derivadas da classe Funcionario: Classe Horista e Classe Mensalista. O clculo do salrio em cada uma depende de regime de trabalho respectivo. Enquanto o mensalista recebe salrio fixo, o horista recebe por horas trabalhadas. (No bem assim... mas s para simplificar o exemplo.)
A classe Horista:
1. public class Horista extends Funcionario { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16.} public double salarioHora; public double horasTrabalhadas = 240; public Horista(final double _salarioHora, final String _nome, final String _sobrenome) { super(_nome,_sobrenome); // Argumentos para o construtor. this.salarioHora = _salarioHora; } public void setHorasTrabalhadas (double _horasTrabalhadas) { this.horasTrabalhadas = _horasTrabalhadas; } @Override // Indica que o mtodo salario() sobrescrito. public double salario() { return this.salarioHora * this.horasTrabalhadas; }
Como voc pode notar, existe um mtodo salario (linha 13), (que por sinal no , nem pode ser, abstrato), que retorna o valor do salrio do funcionrio horista. Sua assinatura idntica ao mtodo abstrato salario da super classe Funcionario (vai l e d uma espiadinha). A classe Mensalista:
1. public class Mensalista extends Funcionario { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15.} public double salarioMensal; public Mensalista (double _salarioMensal, String _nome, String _sobrenome){ super(_nome,_sobrenome);// Chamando o construtor da superclasse Funcionario this.salarioMensal = _salarioMensal; } public void setSalarioMensal (final double _salarioMensal) { this.salarioMensal = _salarioMensal; } @Override public double salario() { return _salarioMensal; }
Novamente apareceu o mtodo salario( ) (linha 12) com assinatura idntica ao mtodo abstrato salario( ) (Linha 20) da superclasse Funcionario.
Agora estamos prontos para ver nosso exemplo de polimorfismo:

1. public class TestePolimorfismo { 2. public static void main (String [] args) { 3. 4. if (args.length != 1) { 5. System.out.println ("Na linha de comando, informe argumento H ou M."); 6. return; 7. } 8. Horista fun1 = new Horista ( 15.85,"Jos","Silva"); 9. Mensalista fun2 = new Mensalista (4578.55,"Adam","Smith"); 10. Funcionario fun; // No estamos instanciando nenhum objeto real! 11. 12. if("M".equals(args[0])) fun = fun1; // mensalista 13. else if("H".equals(args[0])) fun = fun2; // horista 14. else fun = null; // O usurio errou 15. if (fun != null) 16. System.out.println(Fun.getNomeCompleto()+" - Valor a receber: R$ "+ 17. fun.salario()); 18. else { 19. System.out.println("Uso errado do programa."); 20. System.out.println("Na linha de comando, informe argumento H ou M."); 21. } 22.} 23.}
Notas:
Na linha 10 foi declarado um objeto virtual (fun). Um objeto virtual no um objeto de verdade, na realidade apenas uma referncia. (Se fosse C++ diramos um ponteiro). Nas linhas 12 e 13, atribuiremos a ele a referncia do objeto que realmente queremos usar conforme seleo do usurio. Este exemplo para ser testado digitando o argumento se o funcionrio horista ou mensalista na linha de comando. Note que estamos usando o argumento String args[] da main. Observe na linha 17 que o mtodo salario() invocado. Quando o programador usou o mtodo salario() no tinha como saber qual dos mtodos (O mtodo salario( ) de Horista ou o mtodo salario() de Mensalista) seria usado naquele momento. Neste ponto do programa o mtodo salario() poderia fazer qualquer coisa... dependendo do objeto que foi atribudo ao objeto virtual fun. Por isso dizemos que a referncia fun polimrfica.
A seguir o que impresso na tela nos trs casos previstos: (horista, mensalista e erro)
C:\Java\Java TestePolimorfismo H Jose Silva - Valor a receber: R$ 3804.00
C:\Java\Java TestePolimorfismo M Adam Smith - Valor a receber: R$ 4578.55
C:\Java\Java TestePolimorfismo Horista Uso errado do programa. Na linha de comando, informe argumento H ou M
Interface Interface como se fosse uma classe totalmente abstrata onde todos os seus mtodos so abstratos. Usamos a interface para organizar e disciplinar os usurios das classes em pacotes. O uso de interface a justificativa para o fato de Java no implementar herana mltipla. (Como exemplo de herana mltipla podemos citar: Duas classes: Relogio e Radio. Ambas servindo de superclasse para uma terceira classe RadioRelogio)
A interface no realmente uma classe mas, deve ser declarada e compilada em um arquivo independente. Todos os mtodos de uma interface so abstratos e pblicos, mesmo que o usurio no os declare explicitamente como tal. Todas as variveis membros declarada em uma interface so finais e pblicas, por default. No so permitidas declaraes de variveis verdadeiras. Como vimos o modificador final transforma a declarao de varivel em declarao de constantes. claro que no possvel instanciar um objeto de uma interface. Qualquer classe que implemente uma interface ter acesso as constantes da interface e ser obrigada a implementar pelo menos um mtodo com a mesma assinatura dos declarados na interface. Desta forma os programadores sero obrigados a escrever os mtodos declarados na interface em suas classes. Exemplo:
1. public interface Figuras { 2. 3. 4. 5. 6. 7. 8. } public String nomeInterface = "Figuras"; abstract public String getNome(); abstract public void setNome(String Nome); public double getArea(); public double getPerimetro(); double getDiagonal();
Notas:
Repare que nas linhas 5, 6 e 7 no foi usado abstract. Como foi dito os mtodos declarados na interface so por default abstratos Nas linhas 3 e 4 Foi usado o abstract. Poderia ser suprimido. Na linha 7 foi suprimido o public. Sem problemas. Como o compilador 'sabe' que uma interface assume que a declarao pblica.
Abaixo outra verso da mesma interface com as declaraes completas:
1. public interface Figuras { 2. 3. 4. 5. 6. 7. 8. } final public String nomeInterface = "Figuras"; abstract abstract abstract abstract abstract public public public public public String void double double double getNome(); setNome(String Nome); getArea(); getPerimetro(); getDiagonal();
Uma classe Base para as figuras. Esta classe no tem compromisso com a interface:
1. public class BaseFigura { 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.} protected double lado1; protected double lado2; protected String nome; protected String nomeClasse; String getNomeClasse () { return this.nomeClasse; } BaseFigura (double lado1, double lado2, String nome) { this.lado1 = lado1; this.lado2 = lado2; this.nome = nome; } public double getArea() { // Tem na interface return this.lado1 * this.lado2; } public double getPerimetro(){ // Tem na interface return (this.lado1 + this.lado2) * 2.0; } public String getNome(){ // Tem na interface return this.nome; } public void setNome (String _nome) { // Tem na interface this.nome = _nome; }
Uma classe Quadrado estendida da superclasse BaseFigura e que implementa a interface Figuras.
1. public class Quadrado extends BaseFigura 2. implements Figuras { 3. 4. 5. 6. 7. 8. 9. 10.} Quadrado(final double _lado,final String _nome) { super(_lado,_lado,_nome); // Argumentos para a superclasse this.nomeClasse = "Quadrado"; } public double getDiagonal(){ return Math.sqrt(2.0) * this.lado1; }
A classe Quadrado est comprometida com a interface Figuras e dever possuir necessariamente no mnimo os mtodos: getNome(), setNome(), getArea(), getPerimetro() e getDiagonal(). Todos os mtodos com exceo de getDiagonal() j existem na superclasse BaseFigura que estendida por ela. Assim, o compilador j dispe destes mtodos e no ir "cobrar sua falta. Apenas o mtodo getDiagonal(), que no existe na superclasse BaseFigura, ter que ser implementado. A classe Retangulo tambm ser estendida da superclasse BaseFigura e implementa a interface Figuras
1. public class Retangulo extends BaseFigura implements Figuras { 2. Retangulo(double _lado1, double _lado2, String _nome) { 3. super(_lado1, _lado2, _nome); 4. this.nomeClasse = "Retngulo"; 5. } 6. public double getDiagonal(){ 7. return Math.sqrt(Math.pow(this.lado1,2) + 8. Math.pow(this.lado2,2)); 9. } 10.}
Os comentrios feitos para a classe Quadrado so os mesmos aqui. Reparem no uso da classe esttica Math. Agora vamos a classe de teste da Interface Figuras:
1. public class TestaFiguras { 2. 3. static public void main (String[] args) { 4. 5. Quadrado fig1 = new Quadrado (10, "Quadrado 1"); 6. Retangulo fig2 = new Retangulo (3,4,"Retangulo 1"); 7. 8. 9. 10. 11. 12.} System.out.println(fig1.getNome() + ": " + fig1.getDiagonal()); System.out.println(fig2.getNome() + ": " + fig2.getDiagonal()); }
Imprime:
Quadrado 1: 14.142135623730951 Retangulo 1: 5
Notas:
O mtodo getNome() usado pelos objetos fig1 e fig2 foram implementados na superclasse BaseFigura e esto presentes na interface Figura. Os mtodos getDiagonal() so mtodos diferentes, cada um pertencente a sua respectiva classe. A interface Figuras exige que todos os mtodos que a implemente escrevam um mtodo um getDiagonal() prottipo.
O recurso do uso da interface, gera um conjunto de classes afins, que fazem com que o usurio do pacote trabalhe despreocupado, sabendo que as figuras que tiverem propriedades em comum tero mtodos de mesmo nome e mesma funcionalidade para trat-las. Exatamente como cada classe implementou a soluo, fica transparente para o usurio. H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 83
Tipos Genricos
Adicionados linguagem Java a partir da verso 1.5, principalmente para aumentar a segurana no manuseio de listas e colees. Como as listas foram projetadas inicialmente para aceitar referncias sem compromisso com o tipo (ou classe a que pertencem), possvel criar listas heterogenias, ou seja, contento objetos de classes distintas. Isso pode ser desejvel em algumas ocasies mas muitas vezes d margem a erros difceis de depurar. Observe que no exemplo abaixo foram adicionados lista alguns objetos, inclusive a prpria lista. Aqui no utilizamos tipos genricos e Java considerou implicitamente que uma lista de Objects.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. public static void main(final String args[]) { ArrayList lista = new ArrayList(); lista.add("Jos"); lista.add(new Integer(10)); lista.add(new Long(50)); lista.add(3); // S pode fazer isso no Java 5 em diante! lista.add(lista); for (Object s: lista) { System.out.println(s); }
Imprime: Jos 10 50 3 [Jos , 10, 50, 3, (this Collection)] Veja que tudo "correu bem e o programa funcionou como o esperado, isso porque, por "sorte todos os Objects da lista possuam um mtodo toString() implementado e fazendo alguma coisa com sentido... E se tivssemos uma lista de Integer's e por engano inserimos um string? O que ia acontecer ao tentar operar matematicamente o String inserido por engano?
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. public static void main(final String args[]) { ArrayList<Integer> lista = new ArrayList<Integer>(); // lista.add("Jos"); lista.add(new Integer(10)); lista.add(new Integer(15)); // lista.add(new Long(50)); lista.add(3); // lista.add(lista); Long soma = 0L; for (Integer n: lista) soma += n; // Nem necessrio usar cast! System.out.println("Total: " + soma);
No mtodo acima, o compilador assume que todos os elementos da lista devem ser da classe Integer e, portanto, no permite inserir na lista objetos de outros tipos. Veja que nem o tipo Long foi permitido.
Imprime:
Total: 28
Listas / Colees
Collection uma interface genrica que implementa mtodos para manipulao de colees e List e ArrayList, so classes que implementam Collection e tambm, claro, so genricas. As listas so uma alternativa importante ao uso de arrays e matrizes. O conceito de array antigo e existe em praticamente todas as linguagens. No caso da linguagem C, por exemplo, os arrays so criados em tempo de compilao. No caso de C++, alm de criados em tempo de compilao, como em Java, tambm podem ser criados em tempo de execuo atravs do comando de alocao new. Em Java, s podemos declarar arrays em tempo de execuo mas, a partir da, usamos exatamente da mesma forma que fazemos em C/C++. Os arrays so rpidos e fceis de usar mas possuem algumas limitaes: Ao trabalharmos com ndices, estamos sempre vulnerveis a erros de execuo quando pode "aparecer um valor de ndice invlido. Em tempo de compilao, nem sempre possvel ao compilador alertar o programador que determinado tipo no pode ser atribudo a um elemento de matriz. Veja o exemplo:
//Falha no tempo de execuo Object [] longos = new Long[10]; longos[0] ="Sou um longo!";
Como o array declarado de Objetos, o compilador no tem como alertar o programador que a atribuio vai falhar em tempo de execuo. Mas, no caso de uma lista:
// No ser compilado List<Long> longos = new ArrayList<Long>(); longos.add("Sou um longo!");
A trecho de cdigo no compilado porque, a partir da verso 1.5 do Java, o compilador pode verificar o tipo que est sendo adicionado e "reclamar que no compatvel com o tipo genrico declarado para o ArrayList (uma lista Long). Claro que descobrir um erro em tempo de compilao melhor que em tempo de execuo... mas isso ainda no tudo, fazendo isso em tempo de compilao, a JVM no ter que ficar fazendo validaes desnecessrias (pois j foram feitas pelo compilador) o que melhora o seu desempenho, ou seja, em Java, as listas so mais eficientes que os arrays tambm no que concerne ao tempo de execuo! Outra vantagem evidente das listas sobre os arrays o fato de que podem receber novos elementos sem que haja uma quantidade mxima pr estabelecida de itens que a lista pode comportar. Usando listas Exemplos:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. public static void main(final String args[]) { List<String> nomes = new ArrayList<String>(); nomes.add("Jos"); nomes.add("Maria"); nomes.add("Zuleica"); nomes.add("Carlos"); nomes.add("Alberto"); System.out.println("Mostrando a lista original"); for (String nome: nomes) System.out.println(" " + nome); System.out.println("Extraindo elementos pelo ndice (ndice 2)"); nomes.remove(2); // Zuleica vai ser retirada da lista
12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25.
for (String nome: nomes) System.out.println(" " + nome); System.out.println("Inserindo novamente a 'Zuleica'"); nomes.add("Zuleica"); // Zuleica vai ser recolocada na lista for (String nome: nomes) System.out.println(nome); System.out.println ("Removendo um objeto especfico da lista ('Maria')"); nomes.remove("Maria"); // Maria vai ser retirada da lista; for (String nome: nomes) System.out.println(" " + nome); System.out.println("Qual o ndice da 'Zuleica'? "); System.out.println("ndice: " + nomes.indexOf("Zuleica")); System.out.println("Podemos ainda 'iterar' as listas"); Iterator<String> a = nomes.iterator(); while (a.hasNext()) System.out.println(" " + a.next()); }
Imprime: Mostrando a lista original Jos Maria Zuleica Carlos Alberto Extraindo elementos pelo ndice (ndice 2) Jos Maria Carlos Alberto Inserindo novamente a 'Zuleica' Jos Maria Carlos Alberto Zuleica Removendo um objeto especfico da lista ('Maria') Jos Carlos Alberto Zuleica Qual o ndice da 'Zuleica'? ndice: 3 Podemos ainda 'iterar' as listas Jos Carlos Alberto Zuleica
Usando listas navegveis (NavigableSet) A verso 6 do Java incorporou a API NavigableSet que permite criar e manipular listas facilmente trabalhando com ordenao, busca de vizinhos (anterior e posterior) e muitas outras facilidades. Os mtodos de Collection, vistos nos itens anteriores, tambm funcionam normalmente. Exemplo:
1. public static void main(String[] args) { 2. NavigableSet<String> nomes = new TreeSet<String>(); 3. nomes.add("Maria"); 4. nomes.add("Zulmira"); 5. nomes.add("Ana"); 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. System.out.println("Lista em ordem crescente (default): "+nomes+"\n"); System.out.println("Primeiro elemento: " + nomes.first()); System.out.println("ltimo elemento: " + nomes.last() + "\n"); // Impresso da lista usando ordenao ASC E DESC System.out.println("Em ordem ascendente (default):\n"); for (String nome : nomes) { System.out.println("Nome corrente:"+nome); System.out.println("\tLado esquerdo:"+ nomes.headSet(nome,false)); System.out.println("\tLado direito:"+nomes.tailSet(nome,false)+"\n"); }
16. System.out.println("Em ordem descendente:"); 17. for (String nome : nomes.descendingSet()) { 18. System.out.println ("Nome corrente: " + nome); 19. System.out.println ("\tLado esquerdo:"+nomes.headSet(nome,false)); 20. System.out.println ("\tLado direito:"+nomes.tailSet(nome,false)+"\n"); 21. } 22. }
Imprime:
Lista em ordem crescente (default): [Ana, Maria, Zulmira] Primeiro elemento: Ana ltimo elemento: Zulmira Em ordem ascendente (default): Nome corrente: Ana Lado esquerdo: [] Lado direito: [Maria, Zulmira] Nome corrente: Maria Lado esquerdo: [Ana] Lado direito: [Zulmira] Nome corrente: Zulmira Lado esquerdo: [Ana, Maria] Lado direito: [] Em ordem descendente: Nome corrente: Zulmira Lado esquerdo: [Ana, Maria] Lado direito: [] Nome corrente: Maria Lado esquerdo: [Ana] Lado direito: [Zulmira] Nome corrente: Ana Lado esquerdo: [] Lado direito: [Maria, Zulmira]
As listas navegveis ainda permitem acessos relativos a um determinado componente da lista conforme o exemplo abaixo:
1. public static void main(String[] args) { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. } NavigableSet<String> nomes = new TreeSet<String>(); nomes.add("Carlos"); nomes.add("Maria"); nomes.add("Zulmira"); nomes.add("Ana"); nomes.add("Jos"); System.out.println("Lista exemplo inicial:" + nomes + "\n"); System.out.println("Elemento System.out.println("Elemento System.out.println("Elemento System.out.println("Elemento System.out.println("Retira o System.out.println("Retira o >= que 'Jos':\t"+nomes.ceiling("Jos")); > que 'Jos':\t"+nomes.higher("Jos")); <= que 'Jos':\t"+nomes.floor("Jos")); < que 'Jos':\t"+nomes.lower("Jos")+"\n"); primeiro elemento:\t"+nomes.pollFirst()); ltimo elemento:\t"+nomes.pollLast());
System.out.println("\nLista exemplo final:" + nomes + "\n");
Imprime: Lista exemplo inicial:[Ana, Carlos, Jos, Maria, Zulmira] Elemento Elemento Elemento Elemento >= > <= < que que que que 'Jos': 'Jos': 'Jos': 'Jos': Jos Maria Jos Carlos
Retira o primeiro elemento: Ana Retira o ltimo elemento: Zulmira Lista exemplo final:[Carlos, Jos, Maria] Veja que os nossos exemplos anteriores utilizaram listas de Strings. Mas as listas podem ser de qualquer tipo como vemos no exemplo abaixo que utiliza uma lista de Integer.
1. public static void main(String[] args) { 2. 3. 4. 5. 6. NavigableSet<Integer> numeros = new TreeSet<Integer>(); numeros.add(10); numeros.add( 4); numeros.add(30); System.out.println("Lista exemplo inicial:" + numeros + "\n"); Retorna Retorna Retorna Retorna >= > <= < que que que que 6:\t"+numeros.ceiling(6)); 6:\t"+numeros.higher (6)); 6:\t"+numeros.floor (6)); 6:\t"+numeros.lower (6) + "\n");
7. System.out.println(" 8. System.out.println(" 9. System.out.println(" 10. System.out.println(" 11. }
Imprime: Lista exemplo inicial:[4, 10, 30, 36] Retorna Retorna Retorna Retorna >= > <= < que que que que 6: 6: 6: 6: 10 10 4 4
Usando listas tipo Pilha (LinkedList) Muitas vezes utilizamos uma lista para armazenar valores. O exemplo clssico de estrutura de armazenamento a pilha. A classe LinkedList facilita o uso de listas como pilhas. Vamos examinar o exemplo:
1. public static void main(String[] args) { 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. 32. LinkedList<String> nomes = new LinkedList<String>(); nomes.add("Maria"); nomes.add("Zulmira"); nomes.add("Ana"); System.out.println("1. Lista populada: " + nomes + "\n"); // possvel inserir em uma posio especfica nomes.add(2,"Pedro"); // Primeira posio =1. System.out.println("2. Lista populada: " + nomes + "\n"); //Podemos inserir no final e no incio da lista nomes.addFirst("Helio"); nomes.addLast("Rangel"); System.out.println("3. Lista populada: " + nomes + "\n"); // Os mtodos de Collection continuam valendo... nomes.remove("Maria"); System.out.println("4. Lista populada: " + nomes + "\n"); // possvel remover o primeiro, ltimo ou um especfico nomes.removeFirst(); nomes.removeLast(); System.out.println("5. Lista populada: " + nomes + "\n"); String primeiro = nomes.pop(); // Mesmo que removeFirst() System.out.println("6. Lista populada: "+nomes+ " Retirou:"+primeiro+"\n"); String segundo = nomes.pop(); // Mesmo que removeFirst() System.out.println("7. Lista populada: "+nomes+ " Retirou: "+ segundo+ "\n"); System.out.println("8. Lista populada: " + nomes + "\n"); nomes.push("Andr"); // Mesmo que addFirst() System.out.println("9. Lista populada: " + nomes + "\n"); nomes.push("Antonio"); // Mesmo que addFirst() System.out.println("10. Lista populada: " + nomes + "\n");
Imprime: 1. Lista populada: [Maria, Zulmira, Ana] 2. Lista populada: [Maria, Zulmira, Pedro, Ana] 3. Lista populada: [Helio, Maria, Zulmira, Pedro, Ana, Rangel] 4. Lista populada: [Helio, Zulmira, Pedro, Ana, Rangel] 5. Lista populada: [Zulmira, Pedro, Ana] 6. Lista populada: [Pedro, Ana] Retirou: Zulmira 7. Lista populada: [Ana] Retirou: Pedro 8. Lista populada: [Ana] 9. Lista populada: [Andr, Ana] 10. Lista populada: [Antonio, Andr, Ana]
Ordenando arrays A classe utilitria Arrays possui um mtodo para ordenao de arrays. A ordenao de primitivos no oferece nenhuma dificuldade conceitual, a idia de menor e maior imediata. Mas mesmo os primitivos podem ser ordenados em ordem crescente e decrescente. Os primitivos, strings e as classes equivalentes aos primitivos so ordenadas normalmente sem que o programador precise se preocupar com a forma usada pelo mtodo Arrays.sort() para decidir quem maior e quem menor. Examine o exemplo:
1. public static void main(String[] args) { 2. 3. int primitivos [] = {10,5,3,9,16,4}; 4. 5. System.out.println("Primitivos Antes:"+Arrays.toString(primitivos)); 6. Arrays.sort(primitivos); 7. System.out.println("Primitivos Depois:"+Arrays.toString(primitivos)); 8. 9. Integer objetos [] = {10,5,3,9,16,4}; 10. 11. System.out.println("Objetos Antes:" + Arrays.toString(objetos)); 12. Arrays.sort(objetos); 13. System.out.println("Objetos Depois:" + Arrays.toString(objetos)); 14. 15. String nomes[] = {"Jos","Maria","Ana","Carlos","Kleber"}; 16. 17. System.out.println("Strings Antes: " + Arrays.toString(nomes)); 18. Arrays.sort(nomes); 19. System.out.println("Strings Depois: " + Arrays.toString(nomes)); 20. }
Imprime: Primitivos Antes: [10, 5, 3, 9, 16, 4] Primitivos Depois: [3, 4, 5, 9, 10, 16] Objetos Antes: [10, 5, 3, 9, 16, 4] Objetos Depois: [3, 4, 5, 9, 10, 16] Strings Antes: [Jos, Maria, Ana, Carlos, Kleber] Strings Depois: [Ana, Carlos, Jos, Kleber, Maria] Muito bem, no caso dos arrays de Integer e String mostrado no exemplo, o mtodo Arrays.sort() soube o que fazer porque as duas classes implementam a interface Comparable e com isso garantido que ambas possuem um mtodo com assinatura: int compareTo(Object obj); Ordenando arrays de objetos do cliente Para que seja possvel utilizar o Arrays.sort() em objetos de uma classe qualquer necessrio que esta classe implemente a interface Comparable e, naturalmente, sobrescreva um mtodo compareTo(). Este mtodo deve retornar 0 (zero) se os objetos forem iguais, 1 (um) se o primeiro for maior que o segundo e -1 (menos um) em caso contrrio. Vamos desenvolver um exemplo onde ordenamos figuras pelas suas reas. Duas classes de figura, uma de Quadrado outra de Circulo estendidas de uma classe abstrata Figuras que implementa a interface Comparable e define o mtodo compareTo();
A superclasse abstrata Figuras:

1. package figuras; 2. 3. public abstract class Figuras implements Comparable<Figuras> { 4. 5. protected double area; 6. protected String nome; 7. public double getArea() { 8. return this.area; 9. } 10. @Override 11. public int compareTo(Figuras o) { 12. double dif = this.area - o.area; 13. return dif == 0 ? 0 : (dif > 0 ? 1 : -1); 14. } 15. public String getNome() { 16. return this.nome; 17. } 18. }
A Classe Quadrado:
1. package figuras; 2. 3. public class Quadrado extends Figuras { 4. private double lado; 5. public Quadrado(double lado, String nome) { 6. this.nome = nome; 7. setLado(lado); 8. } 9. public double getLado() { 10. return this.lado; 11. } 12. public void setLado(double lado) { 13. this.lado = lado; 14. this.area = this.lado * this.lado; 15. } 16. }
A Classe Circulo:
1. public class Circulo extends Figuras { 2. 3. private double raio; 4. 5. public Circulo(double raio, String nome) { 6. this.nome = nome; 7. setRaio(raio); 8. } 9. public double getRaio() { 10. return this.raio; 11. } 12. public void setRaio(double raio) { 13. this.raio = raio; 14. this.area = Math.PI * this.raio * this.raio; 15. } 16. }
A Classe de teste:
1. package figuras; 2. 3. import java.util.Arrays; 4. 5. public class TesteFiguras { 6. 7. public static void main(String[] args) { 8. 9. Quadrado q1 = new Quadrado(10,"Quadrado 1"); 10. Quadrado q2 = new Quadrado(20,"Quadrado 2"); 11. Circulo c1 = new Circulo (10,"Crculo 1"); 12. Circulo c2 = new Circulo (5,"Circulo 2"); 13. 14. Figuras figuras[] = {q1,q2,c1,c2}; 15. 16. for (Figuras fig: figuras) { 17. System.out.printf("rea do %s antes: %.2f\n", 18. fig.getNome(),fig.getArea()); 19. } 20. 21. Arrays.sort(figuras); 22. 23. System.out.println("\n-------- ORDENANDO FIGURAS ----------\n"); 24. 25. for (Figuras fig: figuras) { 26. System.out.printf("rea do %s depois:%.2f\n", 27. fig.getNome(),fig.getArea()); 28. } 29. 30. System.out.println("\n Comparando figuras diretamente:\n"); 31. 32. if (c1.compareTo(c2) > 0) 33. System.out.printf("%s maior que %s.",c1.getNome(),c2.getNome()); 34. else 35. if (c1.compareTo(c2) < 0) 36. System.out.printf("%s menor que %s.",c1.getNome(),c2.getNome()); 37. else 38. System.out.printf("%s e %s tem o mesmo tamanho.", 39. c1.getNome(),c2.getNome()); 40. } 41. }
Imprime: rea rea rea rea do do do do 'Quadrado 'Quadrado 'Crculo 'Circulo 1' 2' 1' 2' antes: 100,00 antes: 400,00 antes: 314,16 antes: 78,54
-------- ORDENANDO FIGURAS ---------rea rea rea rea do do do do 'Circulo 'Quadrado 'Crculo 'Quadrado 2' 1' 1' 2' depois: 78,54 depois: 100,00 depois: 314,16 depois: 400,00
Comparando figuras diretamente: Crculo 1 maior que Circulo 2.
Navegando em listas com Interator e ListInterator Interator e ListInterator so interfaces utilizadas para facilitar e dar mais segurana ao manuseio de listas. Elas existem, a partir de Java 1.2, para evitar referenciar os elementos das listas atravs de ndices ou de suas posies. As verses mais recentes de Java, disponibilizaram novas classes de colees que j contam com excelentes solues para interao. Tambm passamos a contar com o prtico e enxuto lao for/each, desenvolvido especialmente para percorrer listas. Estas novidades diminuram um pouco a aplicabilidade dos interators, mas mesmo assim, ainda existem muitas situaes onde seu uso indicado. Exemplos:
1. public class TesteInterators { 2. 3. 4. 5. 6. 7. 8. 9. public static void main(String arg[]) { ArrayList<String> nomes = new ArrayList<String>(); nomes.add("Maria"); nomes.add("Jos"); nomes.add("Pedro"); nomes.add("Diego"); nomes.add("Nina"); Iterator<String> i = nomes.iterator();
10. while(i.hasNext()) { 11. System.out.println(i.next()); 12. } 13. ArrayList<Integer> numeros = new ArrayList<Integer>(); 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. numeros.add(15); numeros.add(20); numeros.add(12); numeros.add(22); numeros.add(34); java.util.ListIterator<Integer> n = numeros.listIterator(numeros.size()); // Percorrendo uma lista de trs para frente (no d para fazer isso // utilizando for/each). Integer soma = 0; while(n.hasPrevious()) { Integer valor = n.previous(); soma += valor; System.out.println("Valor: " + valor); } System.out.println("Soma: " + soma); } }
Imprime: Maria Jos Pedro Diego Nina Valor: 34 Valor: 22 Valor: 12 Valor: 20 Valor: 15 Soma: 111
Trabalhando com Map, HashMap e TreeMap

Mapas so colees que usamos para guardar objetos. Para cada objeto armazenado associamos uma chave que quem permite recuperar o objeto guardado quando necessrio. Map uma interface e HashMap uma classe que implementa a interface Map. O HashMap pode ser usado para armazenar objetos de vrios tipos ou trabalhar com tipos homognios predefinidos utilizando genricos. A diferena bsica entre um HashMap e um ArrayList que o que o acesso aos objetos da lista no feito por intermdio de um ndice nem pelo objeto diretamente mas por uma chave arbitrria definida no momento que o objeto foi adicionado. Uma das principais aplicaes dos HashMaps na passagem de mensagens compostas por vrios argumentos. Os mtodos passam o mapa com os objetos colados e quem recebe o mapa extrai os objetos que necessitar, em qualquer ordem, utilizando as chaves convencionadas. Esse procedimento simplifica as assinaturas dos mtodos que manipulam vrios argumentos e torna possvel alterar a quantidade e/ou os tipos dos argumentos passados sem alterao das assinaturas. Exemplo:
1. public class TesteHashMap { 2. 3. public static void listaFiguras (Map<String, Figuras> map) { 4. 5. // Retirando os objetos do mapa (em qualquer ordem) 6. // Note que no retirou o LIXO, apenas as figuras. 7. Figuras figuras[] = { 8. map.get("C2"), map.get("Q1"), map.get("Q2"), map.get("C1") 9. }; 10. for (Figuras f: figuras) { 11. System.out.printf("Nome: %s, rea: %.2f m2\n", 12. f.getNome(), f.getArea()); 13. } 14. } 15. public static void main(String[] args) { 16. Quadrado q1 = new Quadrado(10,"Quadrado 1"); 17. Quadrado q2 = new Quadrado(20,"Quadrado 2"); 18. Circulo c1 = new Circulo (10,"Crculo 1"); 19. Circulo c2 = new Circulo (5,"Circulo 2"); 20. // Declarando o mapa. 21. Map mapa = new HashMap<String, Figuras>(); 22. // Colocando os objetos no mapa... 23. mapa.put("Q1", q1); 24. mapa.put("Q2", q2); 25. mapa.put("LIXO", new Circulo(0,"Lixo")); 26. mapa.put("C1", c1); 27. mapa.put("C2", c2); 28. // Passando a lista como argumento para listaFiguras 29. listaFiguras(mapa); 30. } 31. }
Imprime: Nome: Nome: Nome: Nome: Circulo Quadrado Quadrado Crculo 2, 1, 2, 1, rea: rea: rea: rea: 78,54 m2 100,00 m2 400,00 m2 314,16 m2
Note que os objetos so impressos na ordem em que foram colocados no array figuras e no na ordem em que foram inseridos no mapa. H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 94
A classe TreeMap, que tambm implementa a interface Map, organiza automaticamente as chaves e os objetos em ordem. Para que isso seja possvel, o objeto que est sendo inserido no mapa deve implementar o mtodo int compareTo() da interface Comparable como o caso das classes Quadrado e Circulo utilizadas no exemplo. O mesmo exemplo usando TreeMap
1. public class TesteTreeMap { 2. public static void listaFiguras (Map<String, Figuras> map) { 3. 4. // Retirando os objetos do mapa (em qualquer ordem) 5. // Note que no retirou o LIXO, apenas as figuras. 6. Figuras figuras[] = { 7. map.get("C2"), map.get("Q1"), map.get("Q2"), map.get("C1") 8. }; 9. for (Figuras f: figuras) { 10. System.out.printf("Nome: %s, rea: %.2f m2\n", 11. f.getNome(), f.getArea()); 12. } 13. } 14. public static void main(String[] args) { 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. Quadrado Quadrado Circulo Circulo q1 q2 c1 c2 = = = = new new new new Quadrado(10,"Quadrado 1"); Quadrado(20,"Quadrado 2"); Circulo (10,"Crculo 1"); Circulo (5,"Circulo 2");
Set<String> chaves = map.keySet() ; for (String s: chaves) System.out.println("->"+s); // Declarando o mapa. Map mapa = new TreeMap<String, Figuras>(); // Colocando os objetos no mapa... mapa.put("Q1", q1); mapa.put("Q2", q2); mapa.put("LIXO", new Circulo(0,"Lixo")); mapa.put("C1", c1); mapa.put("C2", c2); // Passando a lista como argumento para listaFiguras listaFiguras(mapa);
Imprime:
->C1 ->C2 ->LIXO ->Q1 ->Q2
Nome: Nome: Nome: Nome:
Circulo Quadrado Quadrado Crculo
2, 1, 2, 1,
rea: rea: rea: rea:
78,54 m2 100,00 m2 400,00 m2 314,16 m2
Veja que as chaves (C1, C2, LIXO, Q1 e Q2) foram colocadas em ordem de alfabtica e os objetos em ordem de tamanho da rea da figura conforme determinado pelo mtodo compareTo() implementado na superclasse Figuras graas a interface Comparable.
Classes e mtodos genricos

As classes genricas podem manipular objetos desde que os mtodos utilizados estejam definidos em uma interface ou superclasse abstrata. A classe exemplificada abaixo pode receber qualquer objeto estendido de Number. Esta soluo poderia ter sido implementada usando sobrecarga... seria o caso de escrever um construtor para cada tipo numrico e um mtodo para cada uma das quatro operaes para cada um dos tipos (BigDecimal, BigInteger, Byte, Double, Float, Integer, Long e Short). Como pode se verificar neste exemplo, a classe fica bem mais "enxuta e fcil de ler e manter (5 mtodos ao invs de 40!). Exemplo:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. public class Calcula<E extends Number> { private E parcela; public Calcula(E p1) { this.parcela = p1; } public double soma(E p2){ return this.parcela.doubleValue() } public double multiplica(E p2){ return this.parcela.doubleValue() } public double divide(E p2){ return this.parcela.doubleValue() } public double subtrai(E p2){ return this.parcela.doubleValue() }
+ p2.doubleValue(); * p2.doubleValue(); / p2.doubleValue(); - p2.doubleValue();
Usando a classe Calcula:

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. public static void main(final String args[]) { Calcula<Number> x = new Calcula<Number>(30); Float Long Double Integer Byte a b c d e = 12.6F; = 10L; = 12.3; = 23; = 'A'; " " " " " " " " + + + + + + + + x.soma(a)); x.soma(b)); x.soma(c)); x.soma(d)); x.soma(e)); x.soma(10)); x.soma(3.6)); x.soma("quinze"));
System.out.println("Soma: System.out.println("Soma: System.out.println("Soma: System.out.println("Soma: System.out.println("Soma: System.out.println("Soma: System.out.println("Soma: // System.out.println("Soma: }
Imprime: Soma: Soma: Soma: Soma: Soma: Soma: Soma: 42.60000038146973 40.0 42.3 53.0 95.0 40.0 33.6
Um mtodo genrico O mtodo abaixo recebe duas listas genricas e retorna as duas listas concatenadas. A graa est em poder concatenar listas genricas quaisquer:
1. 2. 3. 4. 5. public static <E> Set<E> concatena(Set<E> s1, Set<E> s2) { Set<E> retorno = new HashSet<E>(s1); retorno.addAll(s2); return retorno; }
Usando o mtodo:
public static void main(final String args[]) { 1. Set<String> meninos = new HashSet<String>(Arrays.asList("Helio","Vitor","Diego")); 2. Set<String> meninas = new HashSet<String>(Arrays.asList("Nina","Natlia","Clarisse")); 3. Set<String> galera = concatena(meninos,meninas); 4. Set<Integer> idadeMeninos = new HashSet<Integer>(Arrays.asList(55,20,19)); 5. Set<Integer> idadeMeninas = new HashSet<Integer>(Arrays.asList(50,22,13)); 6. Set<Integer> idades = concatena(idadeMeninos,idadeMeninas); 7. for (String pessoa: galera) System.out.println("Nomes: " + pessoa); 8. for (Integer idade: idades) System.out.println("Idades: " + idade);
Note que neste exemplo, os argumentos do mtodo concatena e o retorno so todos do mesmo tipo. Imprime: Nomes: Natlia Nomes: Vitor Nomes: Helio Nomes: Nina Nomes: Diego Nomes: Clarisse Idades: 50 Idades: 19 Idades: 55 Idades: 20 Idades: 22 Idades: 13 O mtodo esttico da classe utilitria Arrays tambm um exemplo de mtodo genrico e ainda usando varargs que ser visto mais adiante.
1. 2. 3. public static <T> List<T> asList(T... a) { return new ArrayList<T>(a); }
Enumeraes
A verso 1.5 do Java trouxe mais uma novidade: o tipo enum. Antes do enum, o programador java "se virava com listas de inteiros finais e estticos. Esta idia funciona bem mas possui limitaes fortes como a impossibilidade do compilador encontrar inconsistncias entre tipos. Veja um exemplo tpico: // Dias da semana public public public public public public public static static static static static static static int int int int int int int SEG TER QUA QUI SEX SAB DOM = = = = = = = 0; 1; 2; 3; 4; 5; 6;
// Meses do ano public public public public . static static static static int int int int JAN FEV MAR ABR = = = = 0; 1; 2; 3;
// Veja agora o trecho de cdigo: if (JAN < TER) { System.out.println("Esta comparao no faz sentido..."); }
No exemplo acima, o compilador no tem como ajudar o programador apontando que esta comparao no faz sentido: comparar dia da semana com ms! Usando enum's:
// Dias da semana public enum Semana { SEG,TER,QUA,QUI,SEX,SAB,DOM }; // Meses do ano public enum Meses { JAN,FEV,MAR,ABR,MAR,FEV,MAR,ABR,MAI, };
Tentando novamente a mesma comparao, mas dessa vez o compilador exige a declarao do tipo antes da "constante e mostra que a comparao no pode ser realizada.
if (Meses.JAN < Semana.TER) { System.out.println("Esta comparao no faz sentido..."); }
At aqui, o enum do Java se assemelha aos seus correlatos de C, C++ e C#. Mas Java no para aqui, existe ainda a possibilidade de criar o que se parece com uma classe mas que na realidade um enum encapsulado e com recursos realmente muito poderosos. A nossa "classe enum no pode ser estendida nem instanciada j que todas sua propriedades so necessariamente finais. Vejamos um exemplo:
1. public enum Semana { 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. } DOM(0,"Domingo",0), // na ordem: ndice, nome e horas normais dia. SEG(1,"Segunda",8), TER(2,"Tera",8), QUA(3,"Quarta",8), QUI(4,"Quinta",8), SEX(5,"Sexta",8), SAB(6,"Sbado",4); private final int indice; private final String nome; private final int horasNormais; //Construtor do enum private Semana (int _indice, String _nome, int _horasNormais) { this.indice = _indice; this.nome = _nome; this.horasNormais = _horasNormais; } public int indice() { return this.indice; } public String nome() { return this.nome; } public int horasNormais() { return this.horasNormais; }
Note que declaramos no como class mas como enum. Como uma classe ser compilada e salva com extenso .class. Tambm no existem mtodos set porque todas as propriedades so finais. Usando o enum Semana que declaramos:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. public static void main(final String args[]) { int horasSemanais = 0; for(Semana dia: Semana.values()) { horasSemanais += dia.horasNormais(); System.out.println(dia.nome() + " tem " + dia.horasNormais() + " horas de trabalho!"); } System.out.println("\nEm uma semana cheia temos " + horasSemanais + " horas de trabalho!"); Semana sem = Semana.TER; System.out.print("\nCardpio de " + sem.nome() + ": "); switch (sem) { case SEG: System.out.println("Virado a Paulista."); break; case TER: System.out.println("Frango grelhado."); break; case QUA: System.out.println("Feijoada."); break; case QUI: System.out.println("Bisteca."); break; case SEX: System.out.println("File de pescada grelhado."); break; case SAB: System.out.println("Macarronada a bolonhesa."); break; case DOM: System.out.println("Lasanha."); } }
Imprime: Domingo tem 0 horas de trabalho! Segunda tem 8 horas de trabalho! Tera tem 8 horas de trabalho! Quarta tem 8 horas de trabalho! Quinta tem 8 horas de trabalho! Sexta tem 8 horas de trabalho! Sbado tem 4 horas de trabalho! Em uma semana cheia temos 44 horas de trabalho! Cardpio de Tera: Frango grelhado. Ainda possvel acessar todos os elementos do enum atravs de um array. Todos os enums possuem um mtodo esttico values() que retorna o array de elementos do enum. O lao for each do exemplo acima poderia ser escrito assim utilizando ndice:
1. 2. 3. 4. 5. 6. for(int i=0 ; i < Semana.values().length ; i++) { horasSemanais += Semana.values()[i].horasNormais(); System.out.println(Semana.values()[i].nome() + " tem " + Semana.values()[i].horasNormais() + " horas de trabalho!"); }
Existem ainda outras formas de utilizar enum's que vale a pena estudar. possvel associar operaes a uma lista de enum's. Considere um enum Operacoes como declarado abaixo:
1. public enum Operacoes { 2. 3. SOMA('+') {public double opera(double x, double y) 4. SUBTRAI('-') {public double opera(double x, double y) 5. MULTIPLICA('*'){public double opera(double x, double y) 6. DIVIDE('/') {public double opera(double x, double y) 7. 8. private final char operador; 9. 10. public String toString() { 11. return "" + this.operador; 12. } 13. private Operacoes(char op) {this.operador = op;} 14. 15. abstract public double opera(double x, double y); 16. } {return {return {return {return x+y;}}, x-y;}}, x*y;}}, x/y;}};
Usando o enum Operacoes:

1. public class TesteEnumOperacoes { 2. 3. public static void main(final String args[]) { 4. for (Operacoes op: Operacoes.values()) { 5. double a = Double.parseDouble(args[0]); 6. double b = Double.parseDouble(args[1]); 7. System.out.println(args[0]+op+args[1] + " = " + op.opera(a,b)); 8. } 9. } 10. }
Imprime: 2+4 = 6.0 2-4 = -2.0 2*4 = 8.0 2/4 = 0.5
Importao de constantes estticas.

Mais uma contribuio do Java 5 para facilitar a vida dos programadores Java. Esta atualizao visa diminuir a necessidade de digitar o nome da classe esttica onde foram definidas constantes estticas. Naturalmente que isso pode causar alguma confuso caso existam duas constantes estticas de mesmo nome mas pertencentes a classes diferentes. Mas se o programador estiver prevendo e considerando essa possibilidade, a nova facilidade pode tornar o cdigo mais leve e menos burocrtico. O exemplo que vamos mostrar foi extrado de Fred Swartz - Homepage e adaptado para mostrar a importao de constantes estticas. Ele desenha um pequeno painel com dois crculos cujas cores mudam aleatoriamente ao se clicar em um boto. Mas a frente vamos estudar aplicaes Java AWT e Swing. Por hora ele vai servir tambm para matar a curiosidade do aluno de como se faz uma aplicao grfica em java:
1. 2. 3. 4. 5. 6. 7. import java.awt.Color; import java.awt.Dimension; import java.awt.Graphics; import static java.awt.Color.*; // Aqui estamos importando as constantes import javax.swing.JPanel; class Painel extends JPanel { private Color cor;
8. public Painel() { 9. this.cor = GREEN; // Antes era necessrio: Color.GREEN 10. setPreferredSize(new Dimension(100,100)); 11. } 12. @Override 13. public void paintComponent(Graphics g) { 14. super.paintComponent(g); 15. g.setColor(this.cor); 16. g.fillOval(0, 0, getWidth(), getHeight()); 17. } 18. public void setNovaCor(Color cor) { 19. this.cor = cor; 20. repaint(); 21. } 22. }
Criando o painel...
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. import import import import java.awt.BorderLayout; java.awt.Color; java.awt.event.ActionEvent; java.awt.event.ActionListener;
import static java.awt.BorderLayout.*; // Importando constantes import static java.awt.Color.*; // Importando constantes import static javax.swing.JFrame.*; // Importando constantes import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JPanel; public class Cores extends JFrame { private Painel ladoEsquerdo = new Painel(); private Painel ladoDireito = new Painel();
14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44.
public Cores() { this.ladoEsquerdo.setBackground(white); // Color.white this.ladoDireito.setBackground(black); // Color.black JButton changeColorBtn = new JButton("Cores randmicas"); changeColorBtn.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { Cores.this.ladoEsquerdo.setNovaCor(corRandomica()); Cores.this.ladoDireito.setNovaCor(corRandomica()); } }); JPanel content = new JPanel(); content.setLayout(new BorderLayout(5, 5)); content.add(changeColorBtn, NORTH); // BorderLayout.NORTH content.add(this.ladoEsquerdo, WEST); // BorderLayout.WEST content.add(this.ladoDireito, EAST); // BorderLayout.EAST setContentPane(content); setDefaultCloseOperation(EXIT_ON_CLOSE); // JFrame.EXIT_ON_CLOSE setTitle("Demo Cores"); setLocationRelativeTo(null); pack();
private static Color corRandomica() { return new Color((int) (Math.random() * 256), // Vermelho (int) (Math.random() * 256), // Verde (int) (Math.random() * 256)); // Azul } public static void main(String[] args) { JFrame window = new Cores(); window.setVisible(true); }
Imprime:
Varargs: usando argumentos em quantidade varivel

Mais uma novidade do Java 1.5, foi inspirado no recurso existente na Linguagem C de passagem de argumentos de nmero varivel. Os argumentos devem ser todos do mesmo tipo. Para o mtodo que recebe a lista, funciona exatamente como um array. Para quem chama (ou evoca) o mtodo a diferena aparece. Quem chama o mtodo passa uma lista de argumentos e no um array. Vamos ao exemplos:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. public static double media(double... valores) throws Exception { double soma = 0.; if (valores.length == 0) throw new Exception("Mdia no existe!"); for (double num : valores) soma += num; return soma/valores.length; } public static void main(final String args[]) { try { double m1 = media(2, 7, 6, 8, 9, 9, 8); double m2 = media(3.5, 4.6, 10.7,2); double m3 = media('a','b','c'); System.out.println("Mdias: " + (int) m1 + ", " + (float) m2 + " e '" + (char) m3 + "'");
} catch (Exception e) { System.out.println("Erro: " + e.getMessage()); }
Imprime: Mdias: 7, 5.2 e 'b' O mtodo media escrito sem uso de varargs seria praticamente idntico, s se diferenciando na forma de declarar o argumento valores. Como ilustrao, vamos ver como seria a mesma soluo sem o uso de varargs:
1. public static double media2(double []valores) throws Exception { 2. double soma = 0; 3. if (valores.length==0) throw new Exception("Mdia no existe!"); 4. for (double num : valores) soma += num; 5. return soma/valores.length; 6. } 7. public static void main(final String args[]) { 8. try { 9. double inteiros[] = {2,7,6,8,9,9,8}; 10. double reais[] = {3.5, 4.6, 10.7,2}; 11. double caracteres[] = {'a','b','c'}; 12. 13. double m1 = media2(inteiros); 14. double m2 = media2(reais); 15. double m3 = media2(caracteres); 16. System.out.println("Mdias: " + (int) m1 + ", " + 17. (float) m2 + " e " + (char) m3); 18. } 19. catch (Exception e) { 20. System.out.println("Erro: " + e.getMessage()); 21. } 22. }
Notas importantes:

O argumento varargs deve ser o ltimo da lista de argumentos; No abuse de varargs, pode dificultar e tornar mais complexo o reuso (sobrecarga e sobreposio); Os argumentos tm que ser de mesmo tipo ou tipo conversvel (equivalente a um array); Este recurso permitiu implementar em java a formatao de sadas como o printf do C/C++ com veremos a seguir.
Transformao de texto
Formatter: Permite formatar (e imprimir) em estilo C/C++ Utilitrio em System.out: mtodo printf(); As funes da famlia printf concebidas para a biblioteca padro do C/C++ possuem como argumento um string de formatao e a seguir a lista de argumentos que devem preencher os formatos definidos na string de formatao. Os toquens de formatao devem determinar o formato de cada uma das sadas e a ordem e quantidade devem ser respeitadas sob pena de ocorrer um erro em tempo de execuo. Os toquens e convenes de formatao so realmente idnticos ao C/C++ e ainda aceitam os formatos definidos para a classe de formatao java Formatter. Exemplo:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. public static void main(final String args[]) { double salario = 4500.5; String nome = "Jos da Silva"; int dependentes = 3; System.out.printf("Hora: %tT\n", Calendar.getInstance()); System.out.printf( "O funcionrio %s tem %d dependentes e recebe R$%,.2f de salrio.\n", nome, dependentes, salario);
Imprime:
Hora: 10:32:40 O funcionrio Jos da Silva tem 3 dependentes e recebe R$4.500,50 de salrio.
Tambm existe o equivalente ao sprintf() do C/C++ mas utilizando objeto String ao invs de um char[]: Exemplo:
String nome = "Rangel"; String buf = String.format("Niver do ~%s: %02d/%02d", nome, 11,4); System.out.println(buf);
Imprime:
Niver do ~Rangel: 11/04
Executando programas externos

Muitas vezes precisamos rodar algum programa executvel. A classe ProcessBuilder, novidade da verso 1.5, permite que o programador execute qualquer programa externo, em java ou no, passando para ele argumentos se for necessrio. No exemplo rodamos o utilitrio HELP do MS DOS passando como argumento o comando type.
1. import java.io.BufferedReader; 2. import java.io.InputStreamReader; 3. public class TesteProcessBuilder { 4. public static void main(String args[]) { 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. // Programa: utilitrio help do MS DOS // Argumento (apenas 1) comando para o help ProcessBuilder pBuilder = new ProcessBuilder("HELP", "type"); String line = null; try { pBuilder.redirectErrorStream(true); // Para capturar a sada na console // do programa Process p = pBuilder.start(); // Roda o programa help (do MSDOS) BufferedReader reader=new BufferedReader(new InputStreamReader(p.getInputStream()));
19. //Aguarda o retorno que o programa far do que foi enviado para console; 20. while ((line=reader.readLine())!= null) { 21. System.out.println(line); 22. } 23. } 24. catch (Exception ex) { 25. ex.printStackTrace(); 26. } 27. } 28. }
Imprime: Exibe o contedo de um ou mais arquivos de texto. TYPE [unidade:][caminho]nomeDeArquivo
Trabalhando com pacotes

O pacote uma entidade que agrupa classes. Na prtica, o pacote uma pasta abaixo da pasta classes que por sua vez est abaixo da pasta do projeto corrente. Quando no se declara o pacote, classe compilada (.class) ser armazenada na prpria pasta class do projeto. Existem duas palavras reservadas relacionadas aos pacotes (package e import): package Deve ser a primeira coisa a aparecer no corpo do arquivo da classe. Java vai considerar que a classe pertence ao pacote referenciado. Todas as classes definidas como fazendo parte deste pacote, podero compartilhar mtodos pblicos e, principalmente os mtodos sem declarao. Como vimos, declarao default. Na prtica uma pasta onde esto armazenados varias classes compiladas. (Arquivos .class) Exemplo: (Este exemplo no est completo. apenas ilustrativo.)
1. package utilitariosSaude; // Declarao do pacote
2. public class Internacao extends Saude { 3. private Data data; 4. private Paciente paciente; 5. private Medico medico; 6. private Unidade unidade; 7. public Internacao(Paciente _paciente, Data _data, Medico _medico){ 8. this.data = _data; 9. this.paciente = _paciente; 10. this.medico = _medico; 11. } 12. public void setUnidade (final Unidade _unidade) { 13. this.unidade = _unidade; 14. } 15. // .......... outros mtodos ................. 16. }
1. package utilitariosSaude; 2. public class Remocao extends SuperSaude { 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. private Data data; private Paciente paciente; private Medico medico; private Unidade unidadeOrigem; private Unidade unidadeDestino; private Funcionario motorista; private Patrimonio veiculo; public Remocao(Data _data, Paciente _paciente, Medico _medico, Unidade _unidadeOrigem, Unidade _unidadeDestino ){ this.data = _data; this.paciente = _paciente; this.medico = _medico; this.unidadeOrigem = _unidadeOrigem; this.unidadeDestino = _unidadeDestino; } public void setMotorista(final Funcionario _motorista) { this.motorista = _motorista; }
Muitas outras classes poderiam fazer parte do pacote utilitariosSaude. Como exemplo, certamente as classes Paciente, Medico e Unidade seriam classes deste pacote. J a classe Funcionario poderia fazer parte do pacote de RH enquanto Patrimonio caberia melhor, talvez, no pacote de classes da contabilidade. Alguns pacotes Java disponveis java.awt java.io java.lang java.net java.util java.applet java.sql import A palavra reservada import usada para importar pacotes total ou parcialmente. At agora no importamos nenhum pacote porque Java considera alguns pacotes como pacotes nativos (java.lang por exemplo). Isto , carrega os pacotes por demanda quando o usurio faz alguma referncia a eles. Caso o usurio faa alguma importao de pacote, esta dever aparecer abaixo da declarao package e antes da definio da classe. Exemplo: import Saude.*; import RH.* import Contabilidade.*; public class Atendimento extends SuperSaude { public Atendimento(final final final final String _rgPac, String _rgMed, Unidade _origem, Unidade _destino) { Interfaces grficas Entrada e sada de dados importado implicitamente pelo compilador Relacionadas com rede Utilitrios diversos Classes para criao de applets Classes para acesso a Banco de Dados
Paciente paciente = new Paciente(_rgPac); Medico medico = new Medico(_rgMed); Data data = new Data(); .......................... Remocao remocao = new Remocao(data,paciente, medico, _origem, _destino); Internacao internacao = new Internacao(paciente,data, medico, _destino); ...................................... }
Outros exemplos de import: import java.util.*; import java.util.List import java.swing.JButton // Importando o pacote inteiros // Importando apenas a classe List do pacote java.util // importando apenas a classe JButton
Nota: Os pacotes java so instalados em uma pasta default de Java criada na instalao do j2sdk H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 107
Tratamento de Excees
O que tratamento de excees Um dos principais desafios do projetista de sistemas interativos (on line) tentar prever e tratar todas as possveis situaes que o usurio, o sistema operacional, o prprio programa e o hardware podem provocar. Eventos como: Estouro de ndice de matrizes, operaes matemticas impossveis (diviso por zero, raiz quadrada de nmero negativo, logaritmo natural de nmeros negativos etc.), argumentos de mtodos invlidos e tantas outras situaes, de agora em diante sero tratadas genericamente como: Excees. Em COBOL, por exemplo, a forma natural de lidar com estes problemas tratar os possveis erros caso a caso e sempre nas vizinhanas do local em que ocorre. Via de regra testamos uma varivel de status a procura de informaes sobre o sucesso ou falha de operaes de IO ou verificamos o contedo de uma varivel em programas chamados. O tratamento opcional e no existe garantia de que o programador previu e tratou as possveis excees corretamente. Em VBx, como outro exemplo, temos o recurso do On Error. Realmente facilita bastante... Mas muitas vezes pode nos pregar peas j que qualquer erro ocorrido no escopo do On Error provocar um desvio para o label de tratamento (que ter que ser escrita no corpo da funo ou procedimento onde ocorre o erro). No trecho de tratamento do erro, temos que verificar o nmero do erro para proceder nossa ao corretiva. Alm disso, temos que cuidar do fluxo do programa. Por volta de 1990 foi publicado um trabalho de autoria de Andrew Koenig e Bjarne Stroustrup de ttulo: Exception Handling for C++. Os projetistas de Java utilizaram quase que integralmente este trabalho para implementar o tratamento de excees de Java. Praticamente todas as classes disponveis de Java geram excees que podem ser tratadas pelo programa que as usa. A idia seria "capturar estas excees, quando ocorrerem e a seguir tratar cada caso separadamente. Existe uma extensa hierarquia de classes de excees (que veremos mais adiante) e ainda podemos estender outras excees escritas por ns. (Caso as existentes no nos atenda plenamente...)
Conhecendo o funcionamento do bloco try/catch/finally Veja abaixo a sintaxe bsica de captura de exceo:
1. 2. 3. 4. 5. 6. 7. 8. 9.
try { // ....................................... // Cdigo onde pode ocorrer alguma exceo // ....................................... } catch (Exception erro) { // ....................................... // Cdigo onde tratamos a exceo // ....................................... }
Notas: O interior dos parnteses do catch: Exception erro (linha 5), est na realidade instanciando um objeto da classe Exception chamado erro. Como foi dito anteriormente, existem muitas classes de tratamento de erro e Exception apenas uma delas (Por acaso, Exception uma superclasse ou supertipo de segundo nvel. Veja mais adiante em Entendendo hierarquia das excees). Quando ocorre uma exceo, no h como continuar o bloco definido dentro do try. O projetista dever encontrar uma soluo que no contemple esta possibilidade. Um exemplo completo
1. public class ExemploTryCatch { 2. 3. public static void main (String [] args) { 4. 5. int soma = 0; 6. int inicio = 100; 7. 8. try { 9. while (inicio > -100) { 10. soma += (100/inicio--); 11. 12. } catch (Exception erro) { 13. System.out.println(erro.getMessage()); 14. System.out.println("Valor da soma at aqui: " + soma); 15. 16. } finally { 17. System.out.println("Esta mensagem sair na tela."); 18. } 19.}
Nota: Java no considera diviso de float ou double por zero como erro. Na realidade ele retorna um "valor que pode ser testado e representado por uma varivel de ambiente: Infinity. Ratificando: Apenas diviso de inteiros (char, byte, int e long) gera uma exceo ao dividir por zero. Repare o bloco finally (linha 16) . Ele executado incondicionalmente independente de ocorrer ou no uma exceo. Podemos usar o bloco finally para liberar recursos alocados... (Arquivos abertos, portas de IO etc.). A justificativa da existncia do finally realizar algumas operaes que independente de ocorrer ou no alguma exceo dever ser executado.
Disparando excees Vamos ver agora uma situao muito comum em que estamos desenvolvendo um mtodo que pode verificar uma ou mais situaes de excees mas no pode tratar localmente. O principal motivo de no poder fazer este tratamento seria: do usurio (do mtodo) a responsabilidade de decidir o que fazer caso ocorra uma exceo. Para disparar uma exceo, usamos o comando throw. Exemplo:
1. public void subHoras (int hora) { 2. // ................................................ 3. if (hora < 0 || hora > 23) 4. throw new 5. IllegalArgumentException("Argumento invlido"); 6. // ................................................ 7. }
Comentrios: Note a classe de tratamento de excees IllegalArgumentException. Esta classe uma sub classe de RuntimeException que por sua vez um sub classe de Exception. Veja que na linha 4 temos o throw. Caso a condio da linha 3 seja verdadeira, ou seja, a hora recebida como argumento invlida, o comando throw ir instanciar um novo objeto da classe IllegalArgumentException, passando o argumento "Argumento invlido" para seu construtor. No uso do mtodo subHoras, podemos (ou no) colocar a chamada do mtodo dentro de um bloco try. Caso o usurio opte por no usar o try, Java no ter como perceber o erro. Assim, se ocorrer uma exceo fatal, o programa ser abortado com a mensagem default de Java. Exemplo:
1. // .................................... 2. MyTime HoraCorrente = new MyTime(); 3. //..................................... 4. int hora = 30; 5. try { 6. int novaHora = HoraCorrente.subHoras(hora); 7. System.out.println("Hora corrente: " + novaHora); 8. } catch( IllegalArgumentException erro) { 9. System.out.println("Hora deve estar entre 0 e 23."); 10. } 11. finally { 12. System.out.println("Hora informada:" + hora); 13. } 14.// ....................................
Notas:

Na linha 2 foi criado um objeto hipottico (HoraCorrente) apenas para uso no exemplo. Caso ocorra uma exceo, a linha 7 no ser executada. A execuo saltar para linha 9. Na linha 9, foi decidido que a mensagem gerada no throw (dentro de subHoras) no seria usada. Em seu lugar foi usada uma outra mensagem considerada mais adequada pelo usurio. Se fosse necessrio utilizar a mensagem passada como argumento dentro de subHoras bastaria fazer: System.out.println(erro.getMessage()); Genericamente, todas as classes de tratamento de erros possuem um mtodo getMessage(); Tratando excees
possvel que um trecho de cdigo interno a um bloco try possa gerar mais de um tipo de exceo. comum que mtodos utilizem outros mtodos de forma que o "lanador da exceo possa estar em um nvel mais interno ou ainda existirem mais de um tipo de exceo lanadas por um mesmo mtodo. Para tratar sem "confuso todas estas excees, podemos usar um ou mais blocos catch para apenas um bloco try. Os blocos catch sero testados na sequncia de cima para baixo obedecendo a hierarquia das classes de tratamento de exceo. (As sub classes devem aparecer antes das super classes respectivas) Exemplo:
1. // .................................... 2. MyTime DataCorrente = new MyTime(); 3. //..................................... 4. try { 5. int diasMes = HoraCorrente.diasMes(mes); 6. System.out.println("Mes: "+(mes+1)+" tem "+diasMes+" dias."; 7. } catch( NumberFormatException erro ) { 8. System.out.println("O argumento deve ser numrico."); 9. } 10. catch ( ArrayIndexOutOfBoundsException erro) { 11. System.out.println("Valores vlidos de 0 at 11.(0 = Jan)"); 12. } 13. catch ( Exception erro ) { 14. System.out.println("Erro: " + erro.getMessage()); 15. } 16. finally { 17. System.out.println("Mes informado:" + mes); 18. } 19. // ....................................
Notas: Veja que no exemplo, no usamos o mtodo getMessage() nos dois primeiros blocos catch porque preferimos mostrar nossas prprias mensagens. No ltimo bloco catch usamos a classe Exception, que a classe de hierarquia mais alta, para o caso de uma exceo imprevista. Neste caso usamos o mtodo getMessage() para mostrar a mensagem default uma vez que no temos idia do que poderia ter ocorrido.
O bloco finally ir mostrar na tela, em qualquer hiptese, o ms informado.
O mtodo diasMes (chamado no exemplo anterior):

1. public int diasMes (String mes) { 2. final int [] diasAno = {31,28,31,30,31,30, 3. 31,31,30,31,30,31}; 4. int mesInteiro = Integer.parseInt(mes); // Converte para string 5. return diasAno[mesInteiro]; 6. }
Notas:

Nas linhas 2 e 3 foi declarado um array final com 12 elementos (ndices de 0 at 11) Na linha 4 usamos um mtodo da classe esttica Integer que converte um string para inteiro (parseInt). Este mtodo "lana internamente uma exceo da classe NumberFormatException (que uma sub classe de IllegalArgumentException que por sua vez sub classe de RuntimeException. Por ltimo derivada de Exception).
Reforando: Note que no existe throw lanando possveis excees devido ao uso do mtodo parseInt. Este throw certamente foi colocado l (no fonte do parseInt) pelo seu autor.
A linha 5 usa o valor retornado por Integer.parseInt(mes) como ndice do array diasAno. Caso o valor do ndice seja invlido, ou seja um ms menor que zero ou maior que onze, ser lanada uma exceo ArrayIndexOutOfBoundsException. Hierarquia: Exception RunTimeException IndexOutOfBoundsException ArrayIndexOutOfBoundsException
Importante: Nunca use em uma sequncia de catch's uma classe de tratamento de exceo hierarquicamente superior antes de sua sub classe. Se fizer isto, o bloco catch abaixo jamais ser usado. Examine com cuidado o exemplo da pgina anterior (Tratando excees).
Forando o tratamento de excees Java distingue Exceptions verificadas de RuntimeException no-verificadas e Error's. As excees verificadas de um mtodo precisam na clusula throws desse mtodo (calma ai... vamos ver isso j j.). Error's e RuntimeException's podem ser disparadas de quase todos os mtodos, de modo que seria incmodo para os programadores listar todas as definies e mtodos cada vez que fosse fazer uso delas. (Veja: Excees verificadas e no verificadas) As excees no verificadas ocorrem independentemente de estarem ou no dentro de um bloco try (RuntimeException e Error) Assim, sempre que o programador de um mtodo utilizar a clusula throws, o usurio do mtodo passa a ser obrigado a colocar a chamada do mtodo dentro de um bloco try. |Exemplo:
1. public int diasMes (final String _mes) 2. throws ArrayIndexOutOfBoundsException { 3. final int [] diasAno = {31,28,31,30,31,30, 4. 31,31,30,31,30,31}; 5. int mesInteiro = Integer.parseInt(_mes); 6. return diasAno[mesInteiro]; 7. }
Desta forma, graas ao throws que aparece na linha 2, se o usurio no colocar o chamada de diasMes dentro de um bloco try com catch para ArrayIndexOutOfBoundsException o programa no compilar. Neste caso a opo de tratar ou no a exceo NumberFormatException fica a cargo do usurio. Para forar o uso do bloco catch para ela tambm, seria necessrio fazer a seguinte modificao no mtodo diasMes.
1. public int diasMes (final String _mes) 2. throws ArrayIndexOutOfBoundsException, NumberFormatException { 3. final int [] diasAno = {31,28,31,30,31,30,31,31,30,31,30,31}; 4. int mesInteiro = Integer.parseInt(_mes); 5. return diasAno[mesInteiro]; 6. }
Excees verificadas e no verificadas Alguma excees no podem ser resolvidas automaticamente nem muito menos ignoradas. So os nossos conhecidos erros fatais em tempo de execuo. Quando este tipo de erro ocorre, tenha ou no sido previsto pelo programador, Java aborta o programa mostrando sua mensagem default para a situao. Naturalmente estando o trecho com erro dentro de um bloco try/catch ou no o programa terminar. Este tipo de exceo so conhecidas como excees verificadas. Recomendamos que o programador use um bloco try/catch para tentar tratar estas excees sempre que possvel (pelo menos mostrar uma mensagem que faa sentido para o usurio). O outro tipo, as excees no verificadas, podem ou no ser capturadas. Se o usurio no usar o bloco try/catch esta exceo no ser capturada por ningum e consequentemente ser perdida.
Exemplos de excees Verificadas

Passagem de argumento (Sobra, falta ou tipo incompatvel). Uso de ndice de array invlido. Diviso inteira por zero. Erros de IO Converso de tipo invlido. Argumentos fora de faixa. (Exemplo: Verificao de faixa: Minutos entre 0 e 59, horas entre 0 e 23 etc.) Determinado campo de uma tela em branco. Nmero de dgitos invlido em um campo de senha. Campo de idade negativo. Check digit no bate. (CPF, Contas bancrias etc.)
Exemplos de excees No Verificadas

Observaes: No uma regra geral mas, podemos ver as Excees Verificadas como as excees laadas por Java enquanto as Excees No Verificadas geralmente so "lgicas e programadas para melhorar a segurana e robustez do cdigo. Se quisermos forar o usurio de nossa classe a usar blocos try/catch para tratar nossas excees temos que usar o comando throws no header do mtodo em questo (Veja acima: Forando o tratamento de excees). Todas as excees derivadas de RuntimeException no necessitam necessariamente de tratamento em bloco try/catch. Entendendo hierarquia das excees Como sabemos, Java foi projetada usando o conceito de Orientao a Objetos, onde pensamos de forma hierrquica. Com relao as excees, foram organizadas em dois grandes grupos, ambos estendidos da super classe Throwable. Obs: Note a hierarquia das classes mostrada via edentao.
Error (Geralmente so erros de sistema ou hardware.) Alguns Exemplos: LinkageError ClassCircularityError ClassFormatError IncompatibleClassChangeError AbstractMethodError IllegalAccessError ThreadDeath VirtualMachineError (Classe abstrata) InternalError OutOfMemoryError StackOverflowError AWTError (GUI Grfica usando recursos do SO Cliente)
Exceptions Alguns exemplos: Pacote java.lang Exception ClassNoFoundException IllegalAccessException RuntimeException InterruptedException ArithmeticException ArrayStoreException IllegalArgumentException IllegalThreadStateException NumberFormatException IndexOutOfBoundsException ArrayIndexOutOfBoundsException StringIndexOutOfBoundsException NegativeArraySizeException NullPointerException Pacote java.util Exception RuntimeException EmptyStackException MissingResourseException TooManyListenersException Pacote java.io Exception IOException CharConversionException EOFException FileNotFoundException ObjectStreamException InvalidClassException StreamCorruptedException WriteAbortedException UnsuportedCodingException Pacote java.awt Exception AWTException RuntimeException IllegalStateException IllegalComponentStateException
Pacote java.net Exception IOException BindException MalformedURLException ProtocolException SocketException ConnectException NoRouteToHostException UnknownHostException UnknownServiceException Criando nossas prprias excees Apesar das diversas classes de erro disponveis nos inmeros pacotes Java, no muito improvvel que voc precise escrever sua prpria classe de tratamento de excees. Esta necessidade est longe de ser rara ou improvvel. Escrever classes de tratamento de excees pode melhorar o entendimento do cdigo, padronizar mensagens e procedimentos. Para que voc consiga escrever uma classe de exceo que possa ser "lanada, indispensvel que ela seja estendida de uma outra classe de exceo j existente. Exemplo:
1. public class TrataErroArgumentoHora extends Exception { 2. 3. private String mens; 4. 5. TrataErroArgumentoHora (final String _mens) { 6. this.mens = _mens; 7. } 8. TrataErroArgumentoHora (final int _hora) { 9. this.mens = "Erro em argumento de Hora. Digitado:" + _hora; 10. } 11. public String getMessage (){ 12. return this.mens; 13. } 14.}
O mtodo que vai lanar sua exceo dever possuir o comando throws especificando a classe de tratamento de erro que ns escrevemos: (Forar sempre o uso de try/catch)
1. public void setHora (final int _hora) 2. throws TrataErroArgumentoHora { 3. 4. if (_hora < 0 || 5. _hora > 23 ) throw new TrataErroArgumentoHora(_hora); 6. 7. this.hora = _hora; 8. }
Note que no mtodo setHora a exceo foi lanada utilizando o construtor que recebe a hora como argumento. (Linha 8 de class TrataErroArgumentoHora)
Usando o mtodo setHora:
1. // .................................... 2. MyTime DataCorrente = new MyTime(); 3. //..................................... 4. try { 5. DataCorrente.setHora(24); 6. } 7. catch (TrataErroArgumentoHora erro) { 8. System.out.println(erro.getMessage()); 9. } 10. //...................................
O bom e correto uso do tratamentos de excees que Java nos dispe, realmente facilita, traz mais segurana e d forma mais profissional a nossas aplicaes. Contudo o uso inconsequente pode confundir o usurio quanto a verdadeira natureza do problema. muito comum que o programador por "economia de trabalho generalize as excees usando sempre a classe Exception para todos os seus throws. Dicas:

Procure sempre usar a classe de exceo mais adequada para cada caso. Prefira usar uma classe de tratamento de exceo j disponvel Java. S escreva uma especfica caso realmente as existentes no atendam suas necessidades. Consulte a documentao dos sistemas Java de sua empresa. Procure se inteirar do cdigo de tratamento de erros j desenvolvido e disponvel para no reinventar a roda. Use quantos catch forem necessrios em um bloco try. Isso melhora a segurana e clareza do seu programa. Durante o desenvolvimento, use o mtodo de Exception printStackTrace() para mostrar as linhas e descrio dos erros no cdigo.
Classe Internas
So classes declaradas dentro de outras classes e at dentro de mtodos. So sempre privadas classe onde esto declaradas. As classes internas so principalmente usadas nos tratamento de eventos em interfaces grficas. (GUI). O conceito de classe interna no existe em outras linguagens OO como o C++ por exemplo. Notas:
O objeto da classe interna tem permisso de acesso a todas as propriedades e mtodos da classe e o definiu. Permite-se que uma classe interna definida em um mtodo acesse diretamente todas as variveis de instncia e mtodos do objeto da classe externa que a definiu. Porm apenas as variveis finais do mtodo podem ser acessadas. Mtodos estticos no podem criar objetos de classes internas. No pode ser usado this dentro de um mtodo esttico. A classe interna local ao mtodo s poder ser instanciada dentro do mtodo em que foi definida.
Exemplo: (Estamos usando a superclasse Emprego j vista anteriormente)

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 23. public final class Chefe extends Funcionario { private double remuneracaoSemanal; public Chefe(final String nome, final String sobrenome,final double salario){ super( nome, sobrenome, 'A' ); setRemuneracaoSemanal( salario ); } public void setRemuneracaoSemanal(final double salario) { class Compara { // interna de setRemuneracaoSemanal public double valor1, valor2; public Compara(final double valor1,final double valor2){ this.valor1 = valor1; this.valor2 = valor2; } public boolean comparaMaior() { return this.valor1 > this.valor2; } public boolean comparaMenor() { return this.valor1 < this.valor2; } } // Fim da classe interna Compara Compara c1 = new Compara(salario,remuneracaoSemanal);
22.
24. remuneracaoSemanal = (c1.comparaMaior() ? salario : 25. remuneracaoSemanal); 26. Mensagem m = new Mensagem("Remunerao semanal: " + 27. remuneracaoSemanal); 28. m.show(); // Mostra a mensagem... 29. }
30. public double recebimentos() { 31. 32. 33. 34. 35. 36. 37. 38. Mensagem m = new Mensagem("Valor: "+remuneracaoSemanal); m.show(); return remuneracaoSemanal; } public String toString() { return "Chefe: " + super.toString(); } class Mensagem { // Classe interna de Chefe
39. private String mens; 40. public Mensagem (String m) { 41. mens = m; 42. } 43. public void show (){ 44. System.out.println(mens); 45. } 46. }// Final da classe interna Mensagem 47.} // Final da classe Chefe
Notas:

A classe chefe, possui duas classes internas declaradas. Classe Compara (linha 9) e Classe Mensagem (linha 37) A classe compara, alm de ser interna a classe Chefe, tambm interna ao mtodo setRemuneracaoSemanal
A classe de teste:
1. public class TestaReajuste { 2. 3. 4. 5. 6. 7. 8. } public static void main (String[] args) { Chefe c = new Chefe("Helio","Rangel", 1000.00); c.setRemuneracaoSemanal(500.00); c.setRemuneracaoSemanal(1500.00);
Imprime: Remunerao semanal:1000.0 Remunerao semanal:1000.0 Remunerao semanal:1500.0 Finished executing Note que a segunda linha no imprime o valor 500.00 (mantm o salrio anterior de 1000) porque o mtodo setRemuneracaoSemanal no permite reduo de salrio.
Classe internas annimas As classes annimas so subclasses ou subtipos usados para substituir um ou mais mtodos da superclasse. So classes internas que no tem um nome de classe. Elas so geradas com a criao da instncia de uma nova classe no nomeada que seja uma subclasse de um tipo de classe nomeado ou uma classe de implementao de um tipo de interface nomeado. Veremos muitos exemplos de classes annimas quando estudarmos as interfaces grficas (GUI's) Exemplo:
1. 2. 3. 4. 5. TesteBotao.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } });
Algumas palavras reservadas 'avulsas'

synchronized Indica que o mtodo s pode ser acessado por uma thread de cada vez. native Indica que o mtodo ser implementado por outra linguagem que no o Java. Isso porque muitas vezes precisamos fazer algum tipo de acesso (I/O) que no pode ser feito diretamente via JVM. A sada escrever o cdigo em C ou C++ e compilar para o Sistema Operacional nativo e acess-lo via biblioteca (DLL no caso do Windows). Naturalmente o mtodo native apenas uma assinatura, no tem corpo uma vez que o corpo do mtodo est implementado em outro local e em outra linguagem. Exemplo (retirado da classe Object):
public final native void wait(long timeout) throws InterruptedException;
O cdigo nativo, no Java, deve ser usado com muito critrio por principalmente duas razes: O cdigo nativo no seguro, ou seja, no faz as verificaes de segurana de endereamento por exemplo; Anula o fato de Java ser multiplataforma uma vez que o cdigo nativo faz acesso direto ao IO da plataforma para a qual foi escrita. strictfp Sobre a classe: Indica que todas as operaes com ponto flutuante realizadas por qualquer mtodo da classe, deve ser realizada via padro IEE754 Sobre o mtodo: Idem ao anterior, sendo que atuar apenas sobre o mtodo. O motivo da existncia de strictpf que os processadores de ponto flutuante (hardware) das diversas plataformas onde uma aplicao java esta rodando, podem fazer clculos e aproximaes ligeiramente diferentes. Para garantir sempre o mesmo resultado, java assume a responsabilidade de fazer os clculos por software. Naturalmente este processo diminuir a velocidade de execuo dos clculos mas garantir sempre o mesmo resultado independente da plataforma. Exemplo:
1. 2. 3. 4. 5. public strictfp class Arquivo { public strictfp double media (double valor) { // .................................. }
Nota: strictfp no pode ser aplicado diretamente sobre a variveis locais nem variveis membro. H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 120
transient Afeta variveis de instncia. Quando queremos transportar algum dado que est armazenado em um objeto Java atravs da rede ou mesmo torn-lo persistente em algum dispositivo de armazenamento, devemos serializar o objeto, isto , transform-lo em uma sequncia de bytes que posteriormente poder ser completamente restaurada para gerar novamente o objeto original. Usamos o modificador transient para impedir serializao de alguma varivel membro que por qualquer motivo no queremos serializar. Exemplo:
1. public class Senha implements Serializable { 2. transient public String senha; 3. private String usuario; 4. private String grupo; 5. public Senha(String senha,String usuario,String grupo) { 6. this.senha = senha; 7. this.usuario = usuario; 8. this.grupo = grupo; 9. } 10.}
1. public class TestaTransient { 2. public static void main(String args[]) throws Exception { 3. Senha senha = new Senha(args[0], args[1], args[2]); 4. ObjectOutputStream salva = 5. new ObjectOutputStream("C:\\Temp\\usuario.bin); 6. salva.writeObject(senha); 7. 8. Thread.sleep(1000); // D um tempinho (1 segundo) 9. 10. ObjectInputStream le = 11. new ObjectInputStream("C:\\Temp\\usuario.bin); 12. senha = le.readObject(); 13. } 14.}
volatile Afeta variveis de instncia e tambm pode ser aplicada a variveis locais. Especifica que esta varivel pode ser modificada por uma thread e que compilador no deve procurar fazer otimizaes com ela.
O Uso do Ponto-e-Vrgula
Usamos o ponto-e-vrgula para indicar que estamos terminando um comando ou expresso; Vamos analisar o cdigo abaixo:
1. public class TestandoRunnable { 2. public static void main (String args[]) {
3. int i; 4. for (i=1;i<10;i++); 5. if (i%2 == 0); System.out.println("O nmero " +i+ " par."); 6. } 7. }
Imprime: O nmero 10 par. Naturalmente no era essa a inteno do programador.... Provavelmente o cdigo est tentando mostrar na tela os nmeros pares de 2 at um nmero menor que 10... Ao invs disso, na tela foi mostrado apenas o nmero 10! Que, por sinal, nem est na faixa de 1 9... Como foi possvel? O ponto e vrgula usado no final do for (linha 4 e assinalado com uma seta), faz com que o for percorra todas as interaes antes de prosseguir. Desta forma o if (na linha 5 tambm assinalado com uma seta) ficou independente do for. O valor mostrado na tela o ltimo valor assumido pelo i gerado pelo lao for. Mas depois do if, tambm foi usado erroneamente outro ponto-e-vrgula que ser responsvel pelo isolamento do if (linha 5) . Desta forma o if fica sem nenhum comando associado a ele. Na realidade como se no existisse. Retirando os ponto-e-vrgulas errados e tentando novamente:
1. public class TestandoRunnable { 2. public static void main (String args[]) { 3. int i; 4. for (i=1;i<10;i++) 5. if (i%2 == 0) System.out.println("O nmero " + i + " par."); 6. } 7. }
Imprime:
O numero 2 e par O numero 4 e par O numero 6 e par O numero 8 e par Press any key to continue...
Threads
So rotinas que compartilham o tempo da CPU, possibilitando a aplicao rodar mais de um servio de forma concorrente. A idia das threads de "enfileirar" cdigo para ser executado e, de forma controlada, fazer com que o sistema operacional permita a cada thread uma determinada fatia de tempo de uso da CPU. Alguns cuidados importantes devem ser tomados: No dever haver concorrncia de cada thread com recursos de IO (entrada e sada) ou acesso simultneo a variveis. Como uma thread pode ser interrompida pelo sistema operacional no meio de uma atividade para dar vez a uma outra,. se no tomarmos cuidado, possvel que ambas escrevam em uma mesma varivel "ao mesmo tempo. Java implementou threads de forma simples e segura, ao contrrio das outras linguagens como C++ e Pascal que exigem grande experincia e conhecimento de seus programadores. Apesar de em Java termos a classe Thread, realmente quem est por traz fazendo tudo o Sistema Operacional. O mrito de Java ter criado uma classe de utilizao segura e responsvel pela "descomplicao do uso de threads. O corpo de uma thread o seu mtodo run(), nele que so executadas as tarefas as quais a thread se destina. Podemos implementar threads de duas maneiras distintas:
Criando uma subclasse estendida de Thread e definindo seu mtodo run() de maneira adequada a realizao da tarefa desejada. Instanciando um objeto de Thread que recebe como argumento um objeto que implemente a interface Runnable. Este objeto ser responsvel em fornecer o mtodo run() para a thread rodar.
Uma vez que a thread foi colocada na fila de tarefas do sistema operacional, ela ser executada por partes at que termine. Uma thread pode receber a espao na CPU milhares de vezes antes que efetivamente termine. Quando uma thread instanciada, no entra imediatamente em servio. Aguarda que o mtodo start seja chamado.
Nascimento Aguardando Start
Pronta
Em execuo
Esperando (wait)
Adormecida (sleep)
Morta
Bloqueada Fazendo IO
Estados possveis de uma thread

Nascimento, aguardando o mtodo start. Pronta para rodar (o estado executvel). Est na fila aguardando a vez. Em execuo Ganha a CPU. Est bloqueada quando faz solicitao de IO e fica bloqueada at que o IO termine. Adormecida, quando o programa chama o mtodo sleep. A thread adormecida volta a ficar pronta quando o tempo designado para permanecer dormindo expira ou quando o programa chama o mtodo interrupt(). Fica em wait, quando ela entra em estado de espera pelo objeto particular para o qual wait foi chamado. Sai do estado de espera tornando-se pronta quando o mtodo notify chamado. possvel tirar todas as threads no estado de espera chamando-se o mtodo notify-all. A thread entra no estado de morta quando o seu mtodo run chega ao final da execuo.
Vamos examinar os exemplos de uso de threads. Um de cada forma: Herdando da classe Thread ou de subclasses da classe Thread
1. class myTask extends Thread { 2. 3. public void run () { 4. System.out.println("Use aqui uma tarefa importante. "); 5. for (int i=0; i < 5; i++){ 6. System.out.println(this.toString() + " " + i); 7. } 8. } 9. }
1. public class TestandoThread { 2. public static void main (String args[]) { 3. myTask task1 = new myTask(); 4. task1.start(); 5. myTask task2 = new myTask(); 6. task2.start(); 7. } 8. }
Imprime: Use aqui uma tarefa importante. Thread[Thread-1,5,main] - 0 Thread[Thread-1,5,main] - 1 Thread[Thread-1,5,main] - 2 Thread[Thread-1,5,main] - 3 Thread[Thread-1,5,main] - 4 Use aqui uma tarefa importante. Thread[Thread-2,5,main] - 0 Thread[Thread-2,5,main] - 1 Thread[Thread-2,5,main] - 2 Thread[Thread-2,5,main] - 3 Thread[Thread-2,5,main] - 4 Press any key to continue... Nota: Veja que no exemplo a primeira thread rodou antes da segunda. Todas as sadas esto na ordem e na sequncia esperada... Troque o valor mximo de interaes do lao (linha 5 da classe MyTask) de 5 para 100 e verifique o resultado... Neste exemplo cada thread to pequena que roda toda de uma nica vez assim que toma o controle da CPU. Passando o objeto a ser executado como argumento de Thread
1. class myTask implements Runnable { 2. public void run() { 3. System.out.println("Use aqui uma tarefa importante. "); 4. for (int i=0; i < 100; i++) 5. System.out.println(this.toString() + " " + i); 6. }
1. public class TestandoRunnable { 2. public static void main (String args[]) { 3. myTask task1 = new myTask(); 4. Thread t = new Thread(r); 5. t.start(); 6. } 7. }
Neste caso, possvel estender outras classes

1. public class Super { 2. public void msgShow(String mensagem) { 3. System.out.println (mensagem); 4. } 5. } 1. public class myTask extends Super implements Runnable { 2. public void run() { 3. System.out.println("Use aqui uma tarefa importante. "); 4. for (int i=0; i < 100; i++) 5. msgShow(this.toString() + " " + i); 6. } 7. } 1. public class TestandoRunnable { 2. public static void main (String args[]) { 3. myTask task1 = new myTask(); 4. Thread t = new Thread(r); 5. t.start(); 6. } 7. }
Outro exemplo de thread
1. public class TestandoRunnable { 2. public static void main (String args[]) { 3. myTask task1 = new myTask(); 4. Thread t1 = new Thread(task1); 5. t1.start(); 6. 7. 8. myTask task2 = new myTask(); Thread t2 = new Thread(task2); t2.start();
9. myTask task3 = new myTask(); 10. Thread t3 = new Thread(task3); 11. t3.start(); 12. } 13.}
1. class myTask extends Thread { 2. public void run () { 3. System.out.println("Use aqui uma tarefa importante."); 4. for (int i=0 ; i < 100 ; i++) 5. System.out.println(getName() + " " + i); 6. } 7. }
Imprime: Use aqui uma tarefa importante. Thread-1 - 0 Thread-1 - 1 Thread-1 - 2 Thread-1 - 3 Thread-1 - 4 Thread-1 5 Use aqui uma tarefa importante. Use aqui uma tarefa importante. Thread-3 - 0 Thread-5 - 0 Thread-3 1 ................................. ................................. Note que a Thread-1 rodou seis interaes do for antes de ceder a CPU para outra thread. Apesar do exemplo mostrar em contrrio, no temos garantia que a primeira thread realmente seja a primeira a rodar. Isso depender do sistema operacional e do esquedulador da JVM. Not Runnable um estado da thread. Significa que est impedida de ser executada. As condies que uma thread pode assumir o status not Runnable so:

Receber uma mensagem suspend, sai com resume. Receber a mensagem sleep, sai quando o tempo em milessegundos se expirar. A thread usa o mtodo wait enquanto espera por algum evento. Sai com notify ou notifyAll A thread est bloqueada esperando um IO, s sai quando o IO se completar.
O mtodo Sleep
1. class myTask extends Thread { 2. public void run () { 3. System.out.println("Use aqui uma tarefa importante. "); 4. try { 5. for (int i=0 ; i < 3 ; i++) { 6. Thread.sleep(100); 7. System.out.println(getName() + " - " + i); 8. } 9. } catch(InterruptedException e) { } // try obrigatrio 10. } 11.}
bom lembrar que, o simples fato do tempo do sleep terminar, no implica que a thread ganhar imediatamente a CPU. Ela passar ao estado de pronta at que chegue a sua vez.
Imprime: Use aqui uma tarefa importante. Use aqui uma tarefa importante. Use aqui uma tarefa importante. Thread-1 - 0 Thread-3 - 0 Thread-5 - 0 Thread-1 - 1 Thread-3 - 1 Thread-5 - 1 Thread-1 - 2 Thread-3 - 2 Thread-5 - 2 Finished executing Notas:

Forando as threads a dormir, elas rodaram na sequncia. O mtodo sleep deve se chamado obrigatoriamente dentro de um bloco try (Tratamento do erro: InterruptedException)
O mtodo stop() Ao usar este mtodo, interrompemos definitivamente a thread. Podemos usar o mtodo stop para interromper uma thread que foi projetada para rodar em loop infinito. Os mtodos getPriority() e setPriority() possvel alterar a prioridade das threads, fazendo com que o sistema operacional aloque mais ou menos tempo para ela em relao as outra threads concorrentes. O projetista dever usar este recurso com cautela para que uma atividade de pouca urgncia no acabe tomando desnecessariamente muito tempo da CPU. Isso poderia acarretar em que o sistema, como um todo, se torne demasiadamente lento.
1. public class TestandoRunnable { 2. public static void main (String args[]) { 3. myTask task1 = new myTask(); 4. Thread t1 = new Thread(task1); 5. t1.setPriority(1); // Menor prioridade possvel 6. t1.start(); 7. 8. 9. 10. myTask task2 = new myTask(); Thread t2 = new Thread(task2); t2.setPriority(5); // Prioridade default t2.start();
11. myTask task3 = new myTask(); 12. Thread t3 = new Thread(task3); 13. t3.setPriority(10); // Maior prioridade possvel 14. t3.start(); 15. } 16.}
1. class myTask extends Thread { 2. public void run () { 3. System.out.println("Tarefa:" + getName()); 4. for (int i=0 ; i < 3 ; i++) { 5. System.out.println(getName() + " - " + i); 6. } 7. } 8. }
Imprime: Tarefa: Thread-5 Thread-5 - 0 Thread-5 - 1 Thread-5 - 2 Tarefa: Thread-3 Thread-3 - 0 Thread-3 - 1 Thread-3 - 2 Tarefa: Thread-1 Thread-1 - 0 Thread-1 - 1 Thread-1 - 2 Press any key to continue... Note que as threads foram executadas completas segundo a prioridade de cada uma. O captulo de threads no se esgota por aqui. Para saber mais recomendamos o livro de Deitel & Deitel: Java como programar. (Veja bibliografia)
Usando Banco de Dados em Java

Java pode ser conectado a qualquer banco de dados sem nenhum tipo de limitao. Para efeito de nossos estudos, vamos usar uma conexo com MS Access. Escolhemos o Access por ser largamente difundido e disponvel na grande maioria das estaes de trabalho. Crie um banco de dados vazio chamado Empresas Para usar o Access teremos que configurar o ODBC no Windows (XP por exemplo). No painel de controle, em Desempenho e manuteno, Ferramentas administrativas, paleta Fontes de dados do usurio, selecionamos a fonte de dados: Banco de Dados MS Access Configurando o ODBC
Em seguida clicamos em Adicionar
Selecionamos: Drive do Microsoft Access e em seguida clicamos em Concluir
Para finalizar, digitamos no campo Nome da fonte de dados: Empresas Por ltimo, usando o boto selecionar, procurar o banco de dados Empresas que criamos no primeiro passo.
Estudando uma Conexo Vamos examinar passo a passo uma classe que implementa uma conexo com Bancos de dados.
1. // 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19.} Exemplo de uma conexo import java.sql.*; public class NomeDaClasse { public static void main (String args[]) { try { String url = "jdbc:odbc:nomeFonteDados"; String usuario = ""; String senha = ""; Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection com; com = DriverManager.getConnection(url,usuario,senha); System.out.println ("Conexo OK"); com.close(); } catch (Exception e) { System.out.println("Conexo falhou"); } }
Notas:

Linha 2, importa o pacote que implementa o acesso a banco de dados; Os pacotes principais so importados por default. Linha 3 at linha 20. Corpo da classe de criao de conexo. Linha 6, 7 e 8, criam as variveis de conexo. Linha 9: Carrega o driver que ser usado pela aplicao para realizar comunicao com o banco de dados. Linha 10: Cria uma referncia de objeto da classe Connection. Linha 11: Instncia o objeto de Connection (com) passando para o seu construtor as variveis definidas nas linhas 6, 7 e 8. Linha 13: Fecha a conexo aberta na linha 11. Linha 15: Trata eventuais erros de conexo.
Testando a conexo
1. import java.sql.*; 2. 3. public class TestaConexao { 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. } 20.} public static void main (String args[]) { try { String url = "jdbc:odbc:Empresa"; String usuario = ""; String senha = ""; Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection con; con = DriverManager.getConnection(url,usuario,senha); System.out.println("Conexo realizada com sucesso."); con.close(); } catch(Exception e) { System.out.println("Erro: " + e.getMessage()); }
Criando uma tabela
1. import java.sql.*; 2. 3. public class CriaTabela { 4. 5. public static void main (String args[]) { 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. } 27.} try { String url = "jdbc:odbc:Empresa"; String usuario = ""; String senha = ""; Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection con; con = DriverManager.getConnection(url,usuario,senha); Statement st = con.createStatement(); String criterio = "CREATE TABLE Pedidos (CodPedido"; criterio = criterio + " SMALLINT,CodCli SMALLINT,"; criterio = criterio + " Descricao VARCHAR(50), Valor "; criterio = criterio + " CURRENCY, DataPedido DATE)"; st.executeUpdate(criterio); System.out.println("Tabela criada com sucesso."); st.close(); con.close(); } catch(Exception e){ System.out.println("Erro: " + e.getMessage()); }
Um exemplo completo O exemplo que vamos apresentar tentar mostrar como acessar um banco de dados de forma orientada a objeto. Vamos consider-lo apenas um esforo de exemplificar uma aplicao do mundo real. Nos exemplos anteriores criamo uma tabela de clientes. Esta ser a tabela que iremos usar. Inicialmente, vamos imaginar uma superclasse Banco, com propriedades: nomeBanco, usuario e senha. A superclasse Banco
1. public abstract class Banco { 2. protected String nomeBanco, usuario, senha; 3. public Banco(String nomeBanco, String usuario, 4. String senha ) { 5. this.nomeBanco = nomeBanco; 6. this.usuario = usuario; 7. this.senha = senha; 8. } 9. }
Observe que a classe Banco abstrata e que possui apenas 3 propriedades, todas protegidas. A interface BancoInterface
1. import java.sql.*; 2. public interface BancoInterface { 3. 4. 5. 6. 7. 8. 9. 10. 11.} public void deleta(String codigo) throws SQLException ; public void insere(String campos, String conteudos) throws SQLException; public void atualiza (String codigo, String campo, String conteudo) throws SQLException; public String getPedido (String codigo, String campo) throws SQLException; public ResultSet getPedido () throws SQLException ;
A Classe Conexao A classe Conexao faz a conexo com o banco de dados. A idia de que na aplicao manteremos um objeto de conexo aberto para manipulao das tabelas.
1. 2. 3. 4. 5. import java.sql.*; public class Conexao extends Banco { private Statement st; private Connection con; private boolean status;
6. public Conexao(String banco, String usuario, String senha) 7. throws SQLException, ClassNotFoundException { 8. super(banco, usuario, senha); 9. 10. try { 11. abre(); 12. } 13. catch (SQLException e) {
14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38.
} public void executeUpdate (String criterio) throws SQLException { try { st.executeUpdate(criterio); } catch (SQLException e) { throw new SQLException(e.getMessage()); } } public ResultSet executeQuery(String criterio) throws SQLException { try { return st.executeQuery(criterio); } catch (SQLException e) { throw new SQLException(e.getMessage()); } } public void fecha() throws SQLException {
throw new SQLException(e.getMessage()); } catch (ClassNotFoundException e) { throw new ClassNotFoundException(e.getMessage()); }
39. try { 40. con.close(); 41. st.close(); 42. status = false; 43. } 44. catch (SQLException e) { 45. throw new SQLException(e.getMessage()); 46. } 47. } 48. public void abre() throws SQLException, 49. ClassNotFoundException { 50. try { 51. Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); 52. } 53. catch (ClassNotFoundException e) { 54. status = false; 55. throw new ClassNotFoundException(e.getMessage()); 56. } 57. try { 58. con = DriverManager.getConnection("jdbc:odbc:" + 59. nomeBanco,usuario,senha); 60. st = con.createStatement(); 61. status = true; 62. } 63. catch (SQLException e) { 64. status = false; 65. throw new SQLException (e.getMessage()); 66. } 67. } 68. public boolean getStatus(){ 69. return status; 70. } 71.} // Fim da classe Conexao
A classe Pedido Escolhemos a tabela Pedido, que conhecemos a estrutura.

1. 2. import java.sql.*; public class Pedido implements BancoInterface {
3. private Conexao con; 4. 5. public Pedido (Conexao con) { 6. this.con = con; 7. } 8. public ResultSet getPedido () throws SQLException { 9. ResultSet rs; 10. try { 11. rs = con.executeQuery("SELECT * FROM Pedidos "); 12. } 13. catch(SQLException e) { 14. throw new SQLException (e.getMessage()); 15. } 16. return rs; 17. } 18. public String getPedido (String codigo, String campo) 19. throws SQLException { 20. String retorno = "", criterio = ""; 21. criterio = "SELECT " + campo + " From Pedidos "; 22. criterio = criterio + "WHERE codPedido =" + codigo; 23. try { 24. ResultSet rs = con.executeQuery(criterio); 25. rs.next(); 26. retorno = rs.getString(campo); 27. } catch(SQLException e) { 28. throw new SQLException (e.getMessage()); 29. } 30. return retorno; 31.} 32. public void deleta(String codigo) throws SQLException { 33. String criterio = ""; 34. criterio = "Delete from Pedidos where "; 35. criterio = criterio + " CodPedido =" + codigo; 36. try { 37. con.executeUpdate(criterio); 38. } 39. catch (SQLException e) { 40. throw new SQLException(e.getMessage()); 41. } 42. criterio = null; 43. } 44. public void insere(String campos, String conteudos) 45. throws SQLException { 46. String criterio = ""; 47. criterio = "Insert Into Pedidos (" + campos + ")"; 48. criterio = criterio + " Values (" + conteudos + ")"; 49. try { 50. con.executeUpdate(criterio); 51. } 52. catch(SQLException e) { 53. throw new SQLException(e.getMessage()); 54. } 55. criterio = null; 56. } 57. public void atualiza (String codigo, String campo, 58. String conteudo) throws SQLException { 59. String criterio; 60. criterio = "Update Pedidos Set "; 61. criterio = criterio + campo + " = " + conteudo;
62. criterio = criterio + " Where CodPedido = " + codigo; 63. try { 64. con.executeUpdate(criterio); 65. } 66. catch (SQLException e) { 67. throw new SQLException(e.getMessage()); 68. } 69. criterio = null; 70. } 71.} // Final da classe Pedido
Testando o nosso Banco

1. import java.sql.*; 2. public class TesteBanco { 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. 32. 33. 34. 35. 36.} public static void main (String args[]) { String banco = "Empresa"; String usuario = ""; String senha = ""; try { Conexao con = new Conexao(banco, usuario, senha); Pedido pedido = new Pedido(con); pedido.insere("CodPedido,CodCli, Descricao, Valor, DataPedido", "3529,1896,'Aprendendo C++',92.50,#10-02-2005#"); pedido.deleta("3529"); pedido.insere("CodPedido, CodCli, Descricao, Valor,DataPedido", "3529,1896,'Aprendendo C++',92.50,#10-02-2005#"); pedido.insere("CodPedido, CodCli, Descricao, Valor, DataPedido", "3530,1897,'SQL Server Avanado',92.50,#15-03-2003#"); pedido.insere("CodPedido, CodCli, Descricao, Valor, DataPedido", "1522,1896,'Livro',92.50,#10-02-2005#"); pedido.atualiza("3530","Descricao","'Aprendendo C++ Bblia'"); pedido.atualiza("3530","Valor","120.87 "); System.out.println(pedido.getPedido("1522","Descricao")); ResultSet rs = pedido.getPedido(); while (rs.next()) { System.out.print(rs.getString("CodPedido") + "\t"); System.out.print(rs.getString("CodCli") + "\t"); System.out.print(rs.getString("Descricao") + "\t"); System.out.print(rs.getString("Valor") + "\t"); System.out.println(rs.getString("DataPedido")); }; con.fecha(); } catch (Exception e) { System.out.println(e.getMessage()); } }
Imprime:
Java para todos III 1501 1887 Java para todos 75.5000 2005-11-04 00:00:00 1502 1886 Java para todos II 72.5000 2005-04-13 00:00:00 1522 1866 Java para todos III 52.5000 2005-04-13 00:00:00 3530 1896 Aprendendo C++ avanado 120.8700 2005-10-02 00:00:00 Finished executing
Modificando a tabela de Pedidos para trabalhar com Pedido/Item Faremos agora algumas modificaes no projeto que acabamos de analisar. Nossa primeira providncia ser modificar a interface, retirando os mtodos getPedido(): A nova BancoInterface
1. 2. 3. 4. 5. 6. 7. 8. } import java.sql.*; public interface BancoInterface { public void deleta(String codigo) throws SQLException; public void insere(String campos, String conteudos) throws SQLException; public void atualiza (String codigo, String campo, String conteudo) throws SQLException;
A Classe CriaTabelaPedido com nova estrutura
1. import java.sql.*; 2. class CriaTabelaPedido { 3. public static void main (String args[]) throws 4. SQLException, ClassNotFoundException { 5. try {String url = "jdbc:odbc:Empresa"; 6. String usuario = ""; 7. String senha = ""; 8. Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); 9. Connection con; 10. con = DriverManager.getConnection(url,usuario,senha); 11. Statement st = con.createStatement(); 12. String criterio = "CREATE TABLE Pedidos ("; 13. criterio = criterio + " CodPedido SMALLINT,"; 14. criterio = criterio + " CodCli SMALLINT,"; 15. criterio = criterio + " CodVen SMALLINT,"; 16. criterio = criterio + " DataPedido DATE)"; 17. st.executeUpdate("Drop table pedidos"); 18. st.executeUpdate(criterio); 19. System.out.println("Tabela criada com sucesso."); 20. st.close(); 21. con.close(); 22. } 23. catch(SQLException e){ 24. throw new SQLException(e.getMessage()); 25. } 26. } 27.}
Criando a tabela PedidoItem

1. import java.sql.*; 2. 3. public class CriaTabelaItens { 4. 5. public static void main (String args[]) throws 6. ClassNotFoundException, SQLException { 7. try { 8. String url = "jdbc:odbc:Empresa"; 9. String usuario = ""; 10. String senha = ""; 11. Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); 12. Connection con; 13. con = DriverManager.getConnection(url,usuario,senha); 14. Statement st = con.createStatement(); 15. String criterio = "CREATE TABLE ItensPedidos ("; 16. criterio = criterio + " CodItem SMALLINT,"; 17. criterio = criterio + " CodPedido SMALLINT,"; 18. criterio = criterio + " Descricao VARCHAR(50),"; 19. criterio = criterio + " Quantidade SMALLINT,"; 20. criterio = criterio + " ValorUnitario CURRENCY)"; 21. st.executeUpdate(criterio); 22. System.out.println("Tabela criada com sucesso."); 23. st.close(); 24. con.close(); 25. } 26. catch(SQLException e){ 27. throw new SQLException(e.getMessage()); 28. } 29. } 30.}
A Classe PedidoItem
1. import java.sql.*; 2. 3. public class PedidoItem implements BancoInterface { 4. 5. private Pedido pedido; 6. private Conexao con; 7. 8. public PedidoItem (Pedido pedido, Conexao con) { 9. this.pedido = pedido; 10. this.con = con; 11. } 12. public void deleta (String codigo )throws SQLException {}; 13. public void deleta (String codigoPed, String codigoItem) 14. throws SQLException { 15. String criterio = ""; 16. try { 17. criterio= "Delete from ItensPedidos where CodItem="+codigoItem; 18. criterio = criterio + " And CodPedido = " + codigoPed; 19. con.executeUpdate(criterio); 20. criterio = null; 21. 22. ResultSet rs = con.executeQuery 23. ("Select Itens from ItemsPedidos Where CodPedido = " + codigoPed); 24. if (!rs.next()) // No existe nenhum item no pedido. 25. pedido.deleta(codigoPed); 26. } 27. catch (SQLException e) { 28. throw new SQLException(e.getMessage());
29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71.
} public ResultSet getItemPedido (String codigoPed) throws SQLException { ResultSet rs; try { String criterio = "Select * From ItensPedidos I, Pedidos P "; criterio = criterio + "Where I.codPedido = " + codigoPed + " And" ; rs = con.executeQuery(criterio); } catch (SQLException e) { throw new SQLException (e.getMessage()); } return rs; } }
} } public void insere(String campos, String conteudos) throws SQLException { String criterio = ""; criterio = "Insert Into ItensPedidos (" + campos + ")"; criterio = criterio + " Values (" + conteudos + ") "; try { con.executeUpdate(criterio); } catch(SQLException e) { throw new SQLException(e.getMessage()); } criterio = ""; } public void atualiza (String codigo, String campo, String conteudo) throws SQLException { String criterio = ""; criterio = "Update ItensPedidos Set " + campo + " = " + conteudo + " Where "; criterio = criterio + " CodItem = " + codigo; try { con.executeUpdate(criterio); criterio = null; } catch (SQLException e) { throw new SQLException(e.getMessage()); }
Testando as classes de Pedido e PedidoItem

1. public class Insere { 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. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. public static void main (String args[]) { String banco = "Empresa"; String usuario = ""; String senha = ""; try { Conexao con = new Conexao(banco,usuario,senha); Pedido pedido = new Pedido(con); try { pedido.deleta("2000"); pedido.deleta("2100"); } catch (Exception e) { // Para o caso dos registros no existirem } pedido.insere("CodPedido, CodCli, CodVen, DataPedido", "2000, 1000, 3000, #10-02-2005#"); pedido.insere("CodPedido, CodCli, CodVen, "2100, 1000, 3000, DataPedido", #10-01-2005#");
PedidoItem item = new PedidoItem(pedido,con); item.insere("CodItem,CodPedido,Descricao,Quantidade, ValorUnitario", "0001, 2000, 'Caneta', 100, 1.23"); item.insere("CodItem, CodPedido, Descricao, Quantidade, ValorUnitario", "0002, 2000, 'Borracha', 300, 0.53"); item.insere("CodItem, CodPedido, Descricao, Quantidade, ValorUnitario", "0003, 2000, 'Lapis', 200, 0.29"); ResultSet rs = pedido.getPedido(); while (rs.next()) { System.out.print (rs.getString("CodPedido") + "\t"); System.out.print (rs.getString("CodCli") + "\t"); System.out.print (rs.getString("CodVen") + "\t"); System.out.println(rs.getString("DataPedido"));
} rs = item.getItemPedido("2000");
while (rs.next()) { System.out.print (rs.getString("CodPedido") + "\t"); System.out.print (rs.getString("CodItem") + "\t"); System.out.print (rs.getString("Descricao") + "\t"); System.out.print (rs.getString("Quantidade") + "\t"); System.out.println(rs.getString("ValorUnitario")); }
43. String criterio = "Select SUM(Quantidade * ValorUnitario); 44. criterio = criterio + " As Total From ItensPedidos "; 45. criterio = criterio + " Where CodPedido = 2000 "; 46. rs = con.executeQuery(criterio); 47. 48. rs.next(); 49. System.out.println("Total do pedido: "+rs.getString("Total")); 50. 51. con.fecha(); 52. } 53. catch (Exception e) { 54. System.out.println(e.getMessage()); 55. } 56. } 57.}
GUI Interface Grfica com o Usurio

Os recursos grficos usados nos computadores, normalmente so definidos em dll's que fazem parte do sistema operacional. Um claro exemplo o Windows XP que reformulou a aparncia das janelas e ainda permite ao usurio mudar tambm seu desenho, no apenas as cores. Outra caracterstica importante das GUI's fornecer recursos que permitam que as aplicaes possam "reagir a eventos como movimento de mouse, cliques dos mais diversos, arrastes de mouse etc. O Java, por ser multiplataforma, precisa "arrumar um jeito de criar e manipular objetos grficos na tela, de forma que funcione em qualquer plataforma. J de cara, podemos dizer que no exatamente assim que as coisas funcionam... Aplicaes Java para palms e celulares por exemplo, por limitaes de espao, no podem ter suas GUI's com o mesmo formato e dinmica do que em estaes de trabalho. De qualquer forma, se faz o que possvel. Existem alguns pacotes usados para criar GUI's. Os mais conhecidos so: AWT Abstract Windows Toolkit A coleo de classes disponveis em AWT utilizam as DLL's do sistema operacional corrente. Assim, as janelas e botes por exemplo, tero a mesma aparncia das outras aplicaes desenvolvidas em VB, Deplhi etc. O problema principal que os SO's possuem alguns recursos em suas DLL's que podem no existir nos outros. Ai nossa portabilidade vai para o espao. Swing O pacote Swing 100% desenvolvido em Java e, portanto no depende do SO corrente. Desta forma se soluciona o problema da portabilidade. Como consequncia a aplicao ficar mais pesada uma vez que o cdigo necessrio para construir os objetos dever estar 100% includo nos pacotes Java. Outra desvantagem que a aparncia dos componentes grficos da tela ser padronizada para todas as aplicaes Java, trazendo um certo desconforto ao usurio acostumado com o "jeito de sua rea de trabalho. Usando objetos grficos Como em outras linguagens que trabalham com com GUI's, cada elemento da tela um objeto independente dom suas propriedades e seu mtodos. Botes, janelas, barras de ferramenta, caixas de texto etc, precisam ter tratamento individual, tanto em sua criao como monitoramento de eventos. Em Java teremos um pouco mais de trabalho para controlar tudo isso do que em VB por exemplo. No caso de VB, que uma IDE desenvolvida para rodar apenas em Windows, a interao entre a IDE e o SO total. possvel esconder do usurio o que realmente est acontecendo quando gerado um evento de mouse por exemplo. Em Java teremos que fazer parte desta "integrao SO/IDE pessoalmente.
Exemplo de uma GUI em Java

1. import java.awt.*; 2. import javax.swing.*; 3. import java.awt.event.*; 4. 5. public class TesteGUI extends JComponent { 6. 7. public static void main (String args[]) { 8. JFrame f = new Jframe("Exemplo de uma GUI"); 9. f.setSize(400,300); // width, height 10. f.setLocation(200,200); // left, top 11. f.getContentPane().add(new TesteGUI()); 12. f.setVisible(true); 13. f.addWindowListener(new WindowAdapter() { 14. public void windowClosing(WindowEvent e) { 15. System.exit(0); 16. } 17. }); 18. } 19.public void paintComponent(Graphics g) { 20. g.drawString("E ai geeeente !!!",150,150); 21. } 22.}
Imprime:
Notas:

Repare que TesteGUI estende a classe JComponent que a classe de componentes Swing Na linha 8, instanciamos um objeto da classe Jframe. (Um form completo, com botes e barra) Na linha 11 adicionamos a classe corrente ( TesteGUI ) ao frame. Na linha 12, mostramos o frame. Na linha 13 escrevemos a subclasse annima responsvel por "cuidar do boto de fechar. Ela necessria para efetivamente fechar a aplicao. Na linha 19 escrevemos o cdigo para rodar quando o frame for mostrado (show).
A GUI passo a passo (AWT) Frame O frame a janela como conhecemos. Nele que vamos "colocar nossos componentes. Possui bordas, ttulo e botes de maximizar, minimizar e fechar. No exemplo acima usamos uma frame para mostrar nossa mensagem na tela. Exemplo:
1. import java.awt.*; 2. import java.awt.event.*; 3. import javax.swing.*; 4. 5. public class TesteFrame { 6. public static void main(String s[]) { 7. JFrame TesteFrame = new JFrame(); 8. TesteFrame.setTitle("Exemplo de Frame."); 9. TesteFrame.setLocation(150,150); 10. TesteFrame.setSize(300,300); 11. TesteFrame.setVisible(true); 12.//------------------------------------------------------13. TesteFrame.addWindowListener( new WindowAdapter() { 14. public void windowClosing(WindowEvent e) { 15. System.exit(0); 16. } 17. }); // Fim da sub classe annima 18.//------------------------------------------------------19. } 20.}
Notas:
Nas linhas 1, 2 e 3 Importamos os pacotes AWT e Swing e ainda o pacote de tratamento de eventos o Listener (java.awt.event) Dentro do main, na linha 7, criamos um frame instncia da classe JFrame com o mesmo nome da classe TesteFrame. Na linhas 8,9 e 10 passamos para o Frame algumas propriedades bsicas. Na linha 12, exibimos o Frame. Na linha 13 iniciamos a declarao de uma classe interna annima responsvel pelo tratamentos dos eventos relacionados como Frame. O nico evento tratado dentro do Listening o windowClosing que invocado quando o usurio fecha a janela.
Panel (Painis) Como em VB, Delphi etc, os painis funcionam como rea de desenho e tambm como recipientes para outros componentes. O painel deve ser criado e adicionado a um frame. Usando Labels em Painis Como sabemos, labels so textos que escrevemos nos Frames, Panels etc.. Exemplo:
1. import java.awt.*; 2. import java.awt.event.*; 3. import javax.swing.*; 4. public class TesteLabel extends JPanel { 5. JLabel lb1, lb2, lb3; 6. 7. public TesteLabel() { 8. 9. setLayout(new GridLayout(3,1)); 10. 11. lb1 = new JLabel(" Nome: ",JLabel.LEFT); 12. lb2 = new JLabel(" Endereo: ",JLabel.LEFT); 13. lb3 = new JLabel(" E-Mail: ",JLabel.LEFT); 14. 15. add(lb1); // Adiciona os objetos na ordem que deve 16. add(lb2); // aparecer na tela 17. add(lb3); 18. } 19. public static void main(String[] args) { 20. JFrame frame = new JFrame("Exemplo de LABEL"); 21.//-----------------------------------------------------------22. frame.addWindowListener(new WindowAdapter() { 23. public void windowClosing(WindowEvent e) { 24. System.exit(0); 25. } 26. }); 27.//-----------------------------------------------------------28. frame.setContentPane(new TesteLabel()); 29. frame.setSize(300,120); // width, height 30. frame.setLocation(100,100); // left, top 31. frame.setVisible(true); 32. } 33.}
Notas:

Repare que a classe (aplicao) TesteLabel estendida de JPanel. Na linha 6, criamos 3 referncias a objetos do tipo label. Note que so propriedades da classe TestaLabel. N alinha 8, veja que definimos o construtor TestaLabel onde instaciamos os objetos lb1, lb2 e lb3. Na linha 10, estabelecemos um grid na painel com uma coluna e 3 linhas. Nas linhas 12, 13 e 14 instanciamos os 3 labels. Nas linhas 16, 17 e 18 acrescentamos ao painel os 3 labels. Eles sero ajustados no grid definido na linha 10. Esta apenas uma das formas de posicionar objetos no Frame. Na linha 21, j dentro do mtodo main, instaciamos um Frame. Na linha 23 definimos nosso Listener. Na linha 29 acrescentamos o contedo da classe corrente (os labels) ao frame. Na linha 30, definimos o tamanho do Frame Na linha 31, posicionamos o Frame na tela Na linha 32, mostramos o conjunto Frame/Panel/Labels
Imprime:
O TextField (Caixa de texto)

1. import java.awt.*; 2. import java.awt.event.*; 3. import javax.swing.*; 4. public class TesteCaixaTexto extends JPanel { 5. 6. JTextField txt1, txt2, txt3; 7. JLabel lb1, lb2, lb3; 8. 9. 10. 11. 12. 13. 14. 15. 16. public TesteCaixaTexto() { // Construtor setLayout(new GridLayout(6,1)); // Seis linhas, uma coluna. lb1 = new JLabel(" Nome: ",JLabel.LEFT); lb2 = new JLabel(" Endereo: ",JLabel.LEFT); lb3 = new JLabel(" E-Mail: ",JLabel.LEFT); txt1 = new JTextField("",20); txt2 = new JTextField("",20); txt3 = new JtextField("",20);
17. add(lb1 ); // Acrescenta os componentes 18. add(txt1); // na ordem que deve aparecer na tela 19. add(lb2 ); 20. add(txt2); 21. add(lb3 ); 22. add(txt3); 23. } 24. public static void main(String[] args) { 25. JFrame frame = new JFrame("Exemplo de Caixa de Texto"); 26.//-----------------------------------------------------------27. frame.addWindowListener(new WindowAdapter() { 28. public void windowClosing(WindowEvent e) { 29. System.exit(0); 30. } 31. }); 32.//-----------------------------------------------------------33. frame.setContentPane(new TesteCaixaTexto()); 34. frame.setSize(500,100); 35. frame.setLocation(100,100); 36. frame.setVisible(true); 37. } 38.}
Imprime:
Notas:

Observe que nossa classe TesteCaixaTexto estende a classe JPanel Na linha 10, definimos um layout de 6 linhas e uma coluna. Quando usamos layout (setLayout - linha10) , os componentes se ajustam nas clulas de forma a ocupar todo o espao do frame (experimente alterar o tamanho do painel usando o mouse) Na linha 36, acrescentamos todos os componentes criados (caixas de texto e labels) ao painel.
Botes Os botes acionam eventos do mouse ou teclado. Eles so acionados principalmente por eventos de clique do mouse. Quando acrescentamos botes em nossos painis, precisamos ativar o(s) boto(es) via mtodo addActionListener. O mtodo actionPerformed responsvel pelo tratamento dos eventos sobre o boto. Exemplo:
1. import java.awt.*; 2. import java.awt.event.*; 3. import javax.swing.*; 4. public class TesteBotao extends JPanel implements 5. JLabel l1; 6. JTextField c1; 7. JButton b1; 8. public TesteBotao() { 9. l1 = new JLabel("Nome: "); 10. c1 = new JTextField("",15); 11. b1 = new JButton("Fechar"); 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33.} add(l1); add(c1); add(b1); b1.addActionListener(this); ActionListener {
} public void actionPerformed(ActionEvent evt) { // Object source = evt.getSource(); System.exit(0); } public static void main(String[] args) { JFrame frame = new JFrame("Exemplo com JLabel, JTextField e JButton"); frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); frame.setContentPane(new TesteBotao()); frame.setSize(400,80); frame.setVisible(true)
Imprime:
Note que a classe TesteBotao teve que ser estendida de ActionListener por precisar "ouvir eventos do tipo click do mouse. A linha 19 est comentada porque no est sendo usada neste exemplo;
Interface Grfica + Banco de Dados

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. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. import import import import import java.awt.*; java.awt.event.*; java.sql.*; javax.swing.*; java.util.*;
public class ExemploGrid extends Jframe { private Conexao con; private JTable tabela; public static void main(String args[]) { JFrame janela = new ExemploGrid(); // Cria uma janela janela.show(); // Mostra WindowListener x = new WindowAdapter(){ public void windowClosing(WindowEvent e) { System.exit(0); } }; janela.addWindowListener(x); } public ExemploGrid() { // Construtor setTitle("Banco Empresa - Tabela de Pedidos"); try { con = new Conexao("Empresa","",""); // Conectando... } catch (ClassNotFoundException e) { System.out.println("Falha na conexo:" + e.getMessage()); } catch (SQLException e) { System.out.println("Falha na conexo:" + e.getMessage()); } setSize(400,300); setLocation(100,100); buscaTabela(); } private void buscaTabela() { Statement st; ResultSet rs; try { // Vetor de objetos genricos (Container) Vector cabecalho = new Vector(); Vector linhas = new Vector(); rs = con.executeQuery("SELECT * FROM Pedidos"); ResultSetMetaData rsmd = rs.getMetaData(); // Cabealho do Grid for (int i = 1; i <= rsmd.getColumnCount(); ++i) cabecalho.addElement(rsmd.getColumnName(i)); // Preenche o grid while (rs.next()) { linhas.addElement(proximaLinha(rs,rsmd)); } tabela = new JTable(linhas,cabecalho); //Criando painel com scroll JScrollPane scroller = new JScrollPane( tabela ); getContentPane().add(scroller, BorderLayout.CENTER); validate(); con.fecha(); } catch (SQLException e) { // No faz nada } } private Vector proximaLinha(ResultSet rs, ResultSetMetaData rsmd ) {
67. Vector LinhaAtual = new Vector(); 68. try 69. { 70. for (int i = 1; i <= rsmd.getColumnCount(); ++i) 71. switch(rsmd.getColumnType(i)) 72. { 73. case Types.VARCHAR: LinhaAtual.addElement(rs.getString(i)); 74. break; 75. case Types.TIMESTAMP: LinhaAtual.addElement(rs.getDate(i)); 76. break; 77. case Types.SMALLINT: 78. LinhaAtual.addElement(new Long(rs.getLong(i))); 79. break; 80. } 81. } 82. catch(SQLException e) { /* No faz nada... */ } 83. return LinhaAtual; 84. } 85.}
Imprime:
Notas:

Tabela foi declarada como uma instncia da classe JTable (linha 9); Declaramos uma referncia para objeto da classe Conexao como varivel membro da classe (linha8); O mtodo BuscaTabela() e responsvel pela construo da tabela que futuramente ser inserida na janela; Instanciamos os objetos responsveis pela consulta: rt e rs (linhas 35 e 36); Criamos dois vetores para armazenamento de objetos. Um para o cabealho e outro para as linhas. (linha 41 e 42); Usamos o mtodo do objeto con da classe Conexao para obter o rs (linha 44); Realizamos a consulta, solicitando todos os registros da tabela de pedidos (linha 44); Armazena informaes sobre o banco de dados (Formatos, tipos de campos etc) obtendo os metadados do banco e armazenando em um objeto da classe ResultSetMetaData (linha 46). Estas informaes sero usadas na formatao do grid;. Loop montando o cabealho (linha 49); Loop montando a tabela propriamente dita (linha 54); O mtodo proximaLinha() cria internamente um outro vetor (de colunas) para armazenar cada coluna. Ele retornar este vetor para ser adicionado como elemento no vetor linha; Cria a tabela passando os vetores linhas e cabealho (linha 58); Cria um painel do tipo scroll passando a tabela como argumento (linha 61); Acrescenta no for o painel scroller (linha 63).
Modificando o Projeto para Inserir no Formulrio um Boto Sair

1. 2. 3. 4. 5. 6. 7. 8. import import import import import import import java.awt.*; java.awt.event.*; java.sql.*; javax.swing.*; java.util.*; java.io.*; javax.swing.JOptionPane;
public class ExemploGrid extends JFrame {
9. private Conexao con; 10. private JTable tabela; 11. 12. public static void main(String args[]) { 13. 14. JFrame janela = new ExemploGrid(); // Cria uma janela 15. 16. janela.show(); // Mostra a janela 17. 18. WindowListener x = new WindowAdapter() { 19. public void windowClosing(WindowEvent e) { 20. String textoDigitado = ""; 21. textoDigitado = JoptionPane.showInputDialog 22. (null,"Digite o texto de despedida","At breve!"); 23. JOptionPane.showMessageDialog(null,textoDigitado); 24. System.exit(0); 25. } 26. }; 27. janela.addWindowListener(x); 28. } 29. public ExemploGrid() { // Construtor 30. setTitle( "Banco Empresa - Tabela de Pedidos" ); 31. JButton btnSair = new Jbutton("Sair"); 32. 33. btnSair.addActionListener(new ActionListener() { 34. public void actionPerformed(ActionEvent e) { 35. int resp = JOptionPane.showConfirmDialog(null, 36. "Confirma sair ?", "Ateno", JOptionPane.YES_NO_OPTION); 37. if (resp == JFileChooser.APPROVE_OPTION) 38. System.exit(0); 39. } 40. }); 41. 42. btnSair.setLocation(200,300); // left, top 43. btnSair.setBounds (100,220,200,30); //Left, top, width, height 44. 45. getContentPane().add(btnSair); 46. try { 47. con = new Conexao("Empresa","",""); 48. } catch (ClassNotFoundException e) { 49. System.out.println("Falha na conexo" + e.getMessage()); 50. } 51. catch (SQLException e) { 52. System.out.println("Falha na conexo" + e.getMessage()); 53. } 54. setSize(400,300); // width e heigth 55. setLocation(200,100); // left e top 56. buscaTabela(); 57. } 58. 59. private void buscaTabela() { 60. Statement st; 61. ResultSet rs; 62. 63. 64. try { Vector cabecalho = new Vector();
65. // Vetor de objetos genericos (container) 66. Vector linhas = new Vector(); 67. rs = con.executeQuery("SELECT * FROM Pedidos"); 68. ResultSetMetaData rsmd = rs.getMetaData(); 69. // Cabealho do Grid 70. for (int i = 1; i <= rsmd.getColumnCount(); ++i) 71. cabecalho.addElement(rsmd.getColumnName(i)); 72. // Preenche o grid 73. while (rs.next()) { 74. linhas.addElement(proximaLinha(rs,rsmd)); 75. } 76. tabela = new Jtable(linhas,cabecalho); 77. //Criando painel com scrool 78. JScrollPane scroller = new JScrollPane( tabela ); 79. 80. getContentPane().add(scroller, BorderLayout.CENTER); 81. validate(); 82. con.fecha(); 83. } 84. catch (SQLException e) { // No faz nada... 85. } 86. } 87. private Vector proximaLinha(ResultSet rs, 88. ResultSetMetaData rsmd ) 89. { 90. Vector LinhaAtual = new Vector(); 91. try { 92. for (int i = 1; i <= rsmd.getColumnCount(); ++i) 93. switch(rsmd.getColumnType(i)) 94. { 95. case Types.VARCHAR:LinhaAtual.addElement(rs.getString(i)); 96. break; 97. case Types.TIMESTAMP:LinhaAtual.addElement(rs.getDate(i)); 98. break; 99. case Types.SMALLINT: 100. LinhaAtual.addElement(new Long(rs.getLong(i))); 101. break; 102. } 103. } 104. catch(SQLException e) { 105. } 106. return LinhaAtual; 107. } 108.}
Caso o usurio use o cone de sair do painel ao invs do boto colocado no formurio, implementamos para efeito de exemplo uma caixa tipo showInputDialog (Mtodo de JoptionPane). Examine o cdigo responsvel na linha 22. Veja o efeito do uso do mtodo abaixo:
Ao confirmar, ser mostrada a mensagem de despedida: (cdigo na linha 24)
JavaServer Pages JSP

O desenvolvimento WEB, como j dissemos anteriormente, uma torre de Babel, com muitas linguagens e tecnologias envolvidas. Para o profissional mais acostumado com linguagens elegantes e formais (como Java por exemplo), no fcil se acostumar. Trabalhando com WEB, estamos atrelados fortemente ao web-browser. Qualquer aplicao WEB ter que se sujeitar as regras impostas pelo mundo WEB. O apelo esttico visual, muito importante para WEB, tambm no deve ser negligenciado. A maioria dos profissionais da rea, os web designers, possuem larga experincia na rea e esto acostumados a usar ferramentas de construo e edio de pginas muito ricas em recursos. Alm disso, uma pgina WEB no possui nenhum tipo de restrio que se misture linguagens scripts das mais diversas. Outra dor de cabea importante para o profissional WEB a diferena existente entre os web-browsers disponveis. Uma mesma pgina pode funcionar de maneira diferente de um webbrowser para outro. O desenvolvedor Java/Web tambm ter que se acostumar com o uso dos limitados recursos de depurao de erros das pginas tratadas pelos web-browsers. Tudo isso o preo a pagar por uma tecnologia no proprietria, onde qualquer um pode desenvolver e propor solues. Ao mesmo tempo em que temos infinitas possibilidades de crescimento e criatividade, temos tambm que conviver com esta gigantesca diversidade tecnolgica e a eterna sensao de que talvez no estejamos usando a melhor soluo disponvel. A tecnologia JSP vem viabilizar o sonho da aplicao multicamada real na WEB. Na verso inicial JSP 1, ainda no era possvel garantir 100% de separao entre a camada de apresentao e as demais, porm, com alguns recursos adicionais a partir do JSP 2.0, podemos desenvolver aplicaes com a camada de apresentao 100% independente. JSP - Como Funciona? Quando uma pgina (extenso JSP) submetida ao servidor da pginas WEB, ela ser repassada ao servidor de aplicaes JSP. Existem alguns servidores capazes de tratar pginas JSP (uns livres outros no), contudo todos trabalham basicamente da mesma forma. Na primeira vez que a verso da pgina submetida ao servidor, a pgina convertida em um arquivo fonte Java, usando classes J2SE (servlets). Esta classe compilada e, a partir da, ser utilizada diretamente toda vez que a pgina for submetida ao servidor. Desta forma, estamos contornando a enfadonha tarefa de codificar servlets. O Tomcat Nos exerccios deste captulo iremos usar o servidor Tomcat. Ele um servidor capaz de suportar o desenvolvimento e a execuo, em ambiente de produo, de aplicaes web criados segundo os padres da plataforma Java. O corao do Tomcat o componente conhecido como Catalina que um container web. Este tem como funo fornecer a infra-estrutura para gerenciamento e execuo de Servlets. O funcionamento de um container web definido pela especificao de Servlets, de modo que Servlets que funcionem no Tomcat devem funcionar com outros servidores que tambm fornecem containes web, como o Jrun ou WebLogic por exemplo. O segundo mais importante componente do Tomcat o Jasper. Ele o compilador/tradutor que transforma as pginas JSP em arquivos fonte Servlets e depois compila para classes executveis.
Instalando o Tomcat 5 Acesse o site http://tomcat.apache.org/ , selecione Tomcat 5. Se voc vai trabalhar com Windows, a verso mais conveniente o Core 5.0.28 ->Widows executable. Abaixe o instalador (aproximadamente 10MB) e instale normalmente. Esta a verso ( 5.0.28 ) mais recente quando escrevo este material em novembro de 2005. S instalar o Tomcat no o suficiente. Temos que "acordar o servidor para que ele possa atender as requisies de nossas pginas JSP. Podemos fazer isto de muitas formas. A mais prtica :
Iniciar->Todos Programas->Apache Tomcat 5.0->Configure Tomcat [Start].
Com o Tomcat j no ar, digite o endereo (localhost) em seu browser: http://127.0.0.1:8080/ A tela abaixo indicar que o Tomcat est instalado e funcionando corretamente..
Estudar e configurar o Tomcat seria um captulo a parte. Todavia, consideramos o que vimos at aqui suficiente para nossos propsitos, Existem alguns plug-ins do Eclipse, por exemplo, que facilitam muito o trabalho com programao de pginas JSP. Porm, neste nosso primeiro exemplo, nossa inteno de que o aluno entenda o mecanismo de funcionamento do JSP. Por este motivo percorreremos nosso caminho "a p. Ateno: Voc dever ter j instalada uma JVM em seu computador. A estrutura de diretrios do Tomcat Pastas do Tomcat

bin: Contm os executveis e binrios do Tomcat. Os arquivos shutdown.exe e startup.exe por exemplo, podem ser encontrados nesta pasta. common: Classes utilizadas pelo servidor. conf: Arquivos de configurao do Tomcat. logs: Arquivos de log de acesso e de erros. server: Classes que formam o servidorTomcat. shared: Classes que so compartilhadas por diversos projetos. Coloque nesta pasta os .class para serem usadas por todos os projetos JSP instalados no servidor. temp: Arquivos temporrios do Tomcat. webapps: Esta a pasta que mais nos interessa. Nela colocamos nosso projeto, ou seja, colocamos nossos arquivos JSP e todas as classes envolvidas no projeto. (exceto as classes colocadas na pasta shared que citamos acima). Podemos colocar aqui as classes separadamente ou em forma de pacotes WAR fechados. (Arquivos JAR com extenso .war). work: Arquivos gerados pela transformao de pginas JSP em Servlets.
A pasta webapps, como j foi dito, a pasta de maior interesse. Nela colocamos nossos projetos respeitando uma estrutura pr definida para que o Tomcat possa executar o projeto. Todos os projetos devem ser "cadastrados criando-se uma pasta para cada um. Vamos usar um projeto genrico j pr definido pelo Tomcat. O ROOT. Mas no deixe de dar uma espiada na estrutura j existente que foi criada durante a instalao. Voc ver os projetos de exemplo e documentao. Vejamos a estrutura onde instalaremos nosso projeto na pasta webapps:
webapps ROOT calculadora.jsp WEB-INF web.xml (copie este arquivo de outro projeto existente) classes calculadora calculadora.class
Nota: Alm de respeitar a estrutura de diretrios acima, devemos tambm tomar o cuidado de que uma classe para ser carregada e executada pelo Tomcat deve necessariamente pertencer a um pacote.
O projeto Calculadora S para variar, vamos atacar novamente com uma calculadora bsica. Nosso exemplo ser composto por um arquivo .JSP (calculadora.jsp) e uma classe (Calculadora.java) . No nosso caso vamos criar a classe Calculadora dentro do pacote calculadora. Primeiramente vamos construir nossa pgina JSP, usando qualquer editor de texto. (O editor do GEL por exemplo), Aparncia final da interface grfica da calculadora
Cdigo do JSP correspondente

1. <HTML><BODY> 2. <H2><CENTER>Exemplo de Calculadora em JSP</CENTER></H2> 3. 4. <jsp:useBean id='calc' class='calculadora.Calculadora' /> 5. <jsp:setProperty name='calc' property='parcela1' value='${param.parcela1}'/> 6. <jsp:setProperty name='calc' property='parcela2' value='${param.parcela2}'/> 7. 8. <FORM Action='calculadora.jsp' Method='post' > 9. 10. <TABLE ALIGN='CENTER'> 11. <TR> 12. <TD>Parcela 1:</TD> 13. <TD><INPUT Type='TEXT' Name='parcela1' Value='0'></TD> 14. </TR> 15. <TR> 16. <TD>Parcela 2:</TD> 17. <TD><INPUT Type='TEXT' Name='parcela2' Value='0'></TD> 18. </TR> 19. 20. <TR><TD>&nbsp</TD><TD>&nbsp</TD></TR> 21. 22. <TR> 23. <TD>Soma: </TD> 24. <TD><INPUT Type='TEXT' Name='resulSoma' Value='${calc.soma}'></TD> 25. </TR> 26. <TR> 27. <TD>Diferena:</TD> 28. <TD><INPUT Type='TEXT' Name='resulSubt' Value='${calc.subtrai}'></TD> 29. </TR>
30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40.
<TR> <TD>Produto:</TD> <TD><INPUT Type='TEXT' Name='resulMult' Value='${calc.multiplica}'></TD> </TR> <TR> <TD>Diviso: </TD> <TD><INPUT Type='TEXT' Name='resulDivi' Value='${calc.divide}' ></TD> </TR> </TABLE> <CENTER><INPUT Type ='SUBMIT' Name='Calcular' Value='Calcular'></CENTER> </FORM></BODY> </HTML>
Analisando o cdigo, observamos que:
Na linha 4, estamos instanciando um objeto da classe Calculadora de nome (id) calc. Note que no possvel passar argumento algum durante a criao do objeto. As linhas 5 e 6 fazem a leitura dos parmetros HTML param.parcela1 e param.parcela2 declarados pelas tags HTML INPUT nas linhas 13 e 17. Na linha 8 estamos indicando que o form ser "recarregado quando for "clicado o boto (linha 30) Nas linhas 24, 28, 31 e 36, Estamos obtendo os resultados das operaes. (Mtodos JavaBeans getXxxx) As tags <jsp:setProperty .../> esto na realidade invocando os mtodos da classe Calculadora setParcela1() e setParcela2() (Veja a seguir o cdigo fonte da classe Calculadora.java). Os tags delimitados por '${...}' so na realidade chamadas a mtodos get da classe Calculadora.
O arquivo JSP acima dever ser salvo na pasta: /webapps/ROOT/calculadora.jsp A Classe Calculadora.java
1. package calculadora; 2. 3. public class Calculadora { 4. 5. private double parcela1; 6. private double parcela2; 7. 8. public void setParcela1(final String _sParcela1) { 9. if (!"".equals(_sParcela)) 10. this.parcela1 = Double.parseDouble(_sParcela1); 11. else 12. this.parcela1 = 0.0; 13. } 14. public final void setParcela2(final String _sParcela2) { 15. if (!"".equals(_sParcela2)) 16. this.parcela2 = Double.parseDouble(_sParcela2); 17. else 18. this.parcela2 = 0.0; 19. } 20. public final String getSoma() { 21. return parcela1 + parcela2 + ""; 22. } 23. public final String getMultiplica() { 24. return parcela1 * parcela2 + ""; 25. } 26. public final String getSubtrai() { 27. return parcela1 - parcela2 + ""; 28. } 29. public String getDivide() { 30. if (parcela2 == 0) return "Erro"; 31. return (parcela1 / parcela2) + ""; 32. } 33.}
O arquivo bytecode .class gerado pela compilao deste fonte deve estar na pasta: /webapps/ROOT/WEB-INF/classes/calculadora/Calculadora.class Para testar o funcionamento da aplicao, digitamos o endereo no browser: http://127.0.0.1:8080/calculadora.jsp Classes JavaBean & Pginas JSP As tags <jsp:useBean ... /> que servem para instanciar um objeto e as tags <jsp:setProperty .. > e as marcas ${objeto.propriedade} que servem para setar propriedades da classe e obter suas propriedades respectivamente, possuem limitaes definidas pelas regras de construo de classes JavaBeans. Estas classes, para que posam ser usadas nas pginas JSP, devem possuir um construtor vazio (ou nenhum construtor) e para cada propriedade de interesse deve ser escrito um mtodo set e um mtodo get.
Regras para construo e uso dos mtodos get/set
O nome da propriedade acessada deve ser escrito sempre com o primeiro caracter em minsculo.
Exemplo: private double parcela1;
O nome dos mtodos get/set devem sempre colocar o nome da propriedade imediatamente a seguir dos prefixos get/set mas devem usar o primeiro caracter em maisculo.
Exemplos: public String getParcela1( ) { return parcela1+; } public void setParcela1(String sParcela1) { this.parcela1 = Float.parseFloat(sParcela1); }
No permitido o uso de argumentos em mtodo get, nem retorno diferente de void em mtodos set. Os argumentos existentes em pginas web so sempre tipo texto. Assim devemos usar argumentos e retorno nos mtodos get/set do tipo String. possvel tambm receber arrays de Strings.
Exemplo:
1. 2. 3. 4. 5. 6. 7. 8.
public String getEstadoCivil() { String lista[] = { "Casado, "Solteiro, "Separado, }; return lista; }
Construindo uma aplicao JSP usando o Eclipse e JSF

Construmos um projeto WEB mostrando como fazer, passo a passo, uma aplicao utilizando o Eclipse/JSF, que monta um formulrio onde o usurio digita os dados do paciente como: peso, altura e sexo, para que o programa calcule e mostre o valor do seu IMC (ndice de Massa Corporal) e em que faixa de peso se encontra. Para desenvolvimento do exemplo, usamos a verso GANYMEDE do Eclipse. O JSF (Java Server Faces) um framework desenvolvido a partir do Struts e que ainda est em franco desenvolvimento sendo fomentado por grandes empresas da rea de TI como IBM, SUN, Oracle entre outras. Ele ajuda na construo de pginas JSP/JSF facilitando a navegao, criao, manipulao e controle de componentes grficos como caixas de texto, combos, grids etc. Criando o projeto: prjIMC Clicando com o boto direito do mouse na janela Package Explorer, siga o caminho: File New Project Web Dinamic Web Project Na sequncia, digitamos o nome do projeto e clicamos Next Next Finish preenchendo os assistentes conforme o exemplo. Observe que no campo Configuration da janela Dynamic Web Project, foi selecionado: JavaServer Faces v1.2 Project.
Sequncia do assistente de criao de Dinamic Web Project com JSF
A aparncia inicial do projeto Eclipse que acabamos de criar pode ser vista abaixo:
Aparncia do projeto prjIMC Como primeiro passo, vamos criar nossa classe ManagedBean, onde trataremos os dados digitados, as consistncias necessrias e tambm vamos calcular o valor do IMC solicitado pelo usurio. Na pasta do projeto Project Explorer, clicando com o boto direito, criaremos o pacote managedBean para armazenar nossas classes.
Assistente da criao de pacotes
A classe ControleIMC.java Agora criaremos a classe Managed Bean. Com o cursor sobre o pacote recm criado, selecionamos: New Class e na caixa de dilogo New Java Class digitamos o nome da nova classe: ControleIMC e por ltimo clicamos em Finish.
Depois de confirmado:
Classe ControleIMC criada no pacote managedBean H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 161
As classes que fazem interface com as pginas JSP so chamadas de classes Managed Bean. Para garantir que a classe funcione corretamente, recomendamos que seja estendida da superclasse: ManagedBean. Depois de criado o arquivo da classe, vamos escrever a classe de controle:
1. public class ControleIMC extends ManagedBean { 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. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. private String peso = ""; private String altura = ""; private String sexo = "M"; public void setSexo(String _sexo) { this.sexo = _sexo; } public String getSexo() { return this.sexo; } public void setPeso(String _peso) { this.peso = _peso; } public void setAltura(String _altura) { if (_altura != null) this.altura = _altura; } public String getPeso() { return this.peso; } public String getAltura() { return this.altura; } public String ok() { return ""; } public String getImc() { if ("".equals(this.altura) || "".equals(this.peso)) return ""; try { double alt = Double.parseDouble(this.altura); double pes = Double.parseDouble(this.peso); if (alt < 1) return "Vlido apenas para adultos."; double imc = pes /(alt*alt); return String.format("IMC: %10.2f (%s)",imc,diagnostico(imc)); } catch (NumberFormatException e) { return "Dados informados so invlidos."; } catch (Exception e){ return "Falha desconhecida."; } } private String diagnostico(double imc) { if ("F".equals(sexo)) { if (imc < 19.1) return "Abaixo do peso"; if (imc < 25.8) return "Peso normal"; if (imc < 27.3) return "Marginalmente acima do peso"; if (imc < 32.3) return "Acima do peso ideal."; } else { if (imc < 20.7) return "Abaixo do peso"; if (imc < 26.4) return "Peso normal"; if (imc < 27.8) return "Marginalmente acima do peso"; if (imc < 31.1) return "Acima do peso ideal."; } return "Obeso"; } }
Nota: faixas de IMC para homens e mulheres extradas de National Health and Nutrition Examination Survey (http://www.copacabanarunners.net/imc.html) H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 162
Configurando o servidor Tomcat no Eclipse Antes de iniciar o desenvolvimento da camada de apresentao vamos acrescentar ao projeto o servido de aplicaes WEB Tomcat. Clique com o boto direito sobre a janela Project Explorer e siga a caminho: New Other Server Server Next
Seleo do servidor Selecione o Tomcat que aparece na lista e que j est instalado e pressione Next>. Na tela seguinte, usando o boto Browse... procure a pasta onde est o Tomcat.
Definindo o caminho do Tomcat Use o boto Next> novamente e uma nova janela pede para que voc selecione o projeto que ser executado pelo Tomcat. Selecione o projeto prjIMC na caixa a esquerda e clique no boto Add>. O projeto passa para a janela do lado direito indicando que est selecionado para execuo. Nota importante: No exemplo JSP/Calculadora, utilizamos o Tomcat 5. Nesse caso, recomendamos o Tomcat 6 porque mais provvel que as bibliotecas que voc conseguir na internet sejam compatveis com ele. H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 163
Configurando o projeto para ser ouvido pelo servidor. Depois de tudo isso sua IDE / Eclipse dever mostrar alguma coisa como visto abaixo:
Viso do projeto prjIMC/Eclipse at aqui.
Bibliotecas Necessrias para utilizar o JSF O Tomcat nos disponibiliza duas importantes bibliotecas necessrias para trabalhar com JSF. So elas: jsf-api.jar e jsf-impl.jar. Mas elas no so as nicas e, portanto, precisamos baixar mais algumas da internet e coloc-las na pasta lib de WEB-INF. importante que as bibliotecas obtidas sejam compatveis com a verso do Tomcat utilizado. Procure no colocar na pasta lib bibliotecas que j estejam referenciadas em outros locais do Build Path. As mensagens de erro levantados pelo Tomcat, quando encontra conflitos de biblioteca, nem sempre so elucidativas. O mais garantido e verificar cuidadosamente se est tudo correto.
Bibliotecas que devem ficar na pasta WEB-INF/lib Antes de continuar, devemos testar o ambiente para verificar se as bibliotecas at aqui esto corretas. Sabemos que quanto mais cedo encontrar um eventual problema, menor ser o custo de sua reparao. A simples carga do Tomcat j suficiente para fazer algumas verificaes de compatibilidade das bibliotecas.
Levantando o Tomcat
Levantando o servidor Clique na seta verde para dar partida Selecione a paleta Servers e clique no cone assinalado com a seta. Se estiver tudo bem, voc ver na paleta Console uma sada como esta. Se uma ou mais das bibliotecas estiverem com problema, o Tomcat vai mostrar um ou mais erros fatais (SEVERE) e o servidor no ser iniciado corretamente.
Tomcat iniciado corretamente.
A camada de apresentao Pgina JSP A camada de apresentao ser bem simples: Duas caixas de texto: uma para digitao do peso e outra para digitao da altura, dois Radio Buttons para seleo do sexo do paciente, uma sada para mostrar o resultado e um boto para comandar a execuo. Para criar o imc.jsp, selecione a pasta WebContent. Clique com o boto direito e siga o caminho: New JSP New JavaServer Page (Digite o nome do arquivo: imc) ->Next ->(Selecione New Java Server Faces (JSP) Page (html)) Finish
O Eclipse gera um fonte padro JSP preparado para JSF com o seguinte cabealho:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <%@ taglib prefix="f" uri="http://java.sun.com/jsf/core"%> <%@ taglib prefix="h" uri="http://java.sun.com/jsf/html"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Insert title here</title> </head> <body> <f:view> </f:view> </body> </html>
Neste momento, mesmo antes de introduzir qualquer cdigo, vamos verificar se o nosso JSP/JSF recm criado est sendo visto pelo Tomcat corretamente. No arquivo web-xml da pasta WEB-INF digite o texto abaixo para que o Tomcat saiba que o seu .jsp vai virar um arquivo .faces:
<servlet-mapping> <servlet-name>Faces Servlet</servlet-name> <url-pattern>*.faces</url-pattern> </servlet-mapping>
No campo de url de seu navegador digite:
Se a sada obtida for esta, est tudo indo bem. Mas no prossiga se o Tomcat mostrar qualquer coisa diferente de uma tela em branco e, neste caso, volte e verifique se no existe problemas nas bibliotecas; se no existe alguma faltando; duplicada ou com verso incompatvel. Repare no campo da url do navegador a extenso do arquivo imc: faces. H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 168
Configuraes A extenso das pginas no web.xml Quando trabalhamos com JSF, o framework necessita de algumas configuraes. No exemplo anterior (projeto da Calculadora), chamamos a pgina JSP diretamente pelo seu nome mas, quando usamos JSF, o framework modifica e renomeia o arquivo JSP original mantendo o mesmo nome mas trocando a extenso para uma outra que ele encontra no arquivo web.xml. As linhas 10,11,12 e13, que voc j acrescentou no web.xml, permitem que o framework saiba que extenso usar. Desta forma, determinamos para o framework que a extenso de nossas pginas ser: .faces (linha 12) As opes para extenses normalmente utilizadas em projetos JSF.so: *.faces ou *.jsf. O arquivo web.xml completo pode ser visto abaixo:
1. <?xml version="1.0" encoding="UTF-8"?> 2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5"> 3. <display-name>prjIMC</display-name> 4. <servlet> 5. <servlet-name>Faces Servlet</servlet-name> 6. <servlet-class>javax.faces.webapp.FacesServlet</servlet-class> 7. <load-on-startup>1</load-on-startup> 8. </servlet> 9. 10. <servlet-mapping> 11. <servlet-name>Faces Servlet</servlet-name> 12. <url-pattern>*.faces</url-pattern> 13. </servlet-mapping> 14. 15. <context-param> 16. <param-name>org.richfaces.SKIN</param-name> 17. <param-value>blueSky</param-value> 18. </context-param> 19. <filter> 20. <display-name>RichFaces Filter</display-name> 21. <filter-name>richfaces</filter-name> 22. <filter-class>org.ajax4jsf.Filter</filter-class> 23. </filter> 24. <filter-mapping> 25. <filter-name>richfaces</filter-name> 26. <servlet-name>Faces Servlet</servlet-name> 27. <dispatcher>REQUEST</dispatcher> 28. <dispatcher>FORWARD</dispatcher> 29. <dispatcher>INCLUDE</dispatcher> 30. </filter-mapping> 31. </web-app>
As classes Managed Bean no faces-config.xml Diferentemente das pginas JSP puras, nas pginas JSF no instanciamos objetos nem passamos argumentos como fizemos nas pginas JSP do exemplo Calculadora. O framework JSP trata de instanciar o objeto para ns. Mas para isso, temos que informar qual a classe Managed Bean que ser usada como interface de nossa pgina JSF. O arquivo que utilizamos para isso o faces-config.xml que tambm fica na pasta WEB-INF e, se voc fez tudo como orientamos at aqui, foi criado automaticamente. Abra o arquivo e edite as linhas de 8 at 14 de forma que sua aparncia final seja assim:
1. <?xml version="1.0" encoding="UTF-8"?> 2. 3. <!DOCTYPE faces-config PUBLIC 4. "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN" 5. "http://java.sun.com/dtd/web-facesconfig_1_1.dtd"> 6. 7. <faces-config> 8. <managed-bean> 9. <managed-bean-name>controleIMC</managed-bean-name> 10. <managed-bean-class> 11. managedBean.ControleIMC 12. </managed-bean-class> 13. <managed-bean-scope>request</managed-bean-scope> 14. </managed-bean> 15. </faces-config>
Onde:

Linha 9: Linha 11: Linha 13:
Nome do objeto que ser instanciado e usado na pgina JSF; Nome da classe Managed Bean que ser instanciada; Escopo da instncia. Neste caso request mas pode ser tambm application, page ou session.
Todas as classes Managed Bean devem ser cadastradas no faces-config.xml. Escrevendo o cdigo JSF Todo o cdigo HTML/JSP/JSF dever der digitado entre os toquens: <f:view> (Cdigo aqui!) <f:view/> Examine o cdigo acabado:
1. <%@ page language="java" contentType="text/html; charset=ISO-8859-1" 2. pageEncoding="ISO-8859-1"%> 3. 4. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 5. "http://www.w3.org/TR/html4/loose.dtd"> 6. 7. <%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%> 8. <%@ taglib uri="http://richfaces.org/rich" prefix="rich"%> 9. <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%> 10. <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
11. 12. 13. 14. 15. 16. 17. 18.
<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>IMC - ndice de Massa Corporal</title> </head> <body> <p> <P>
19. <f:view> 20. <h:form id="form"> 21. <Table border="0" align="center" width="50%" cellpadding="50" 22. cellspacing="50" > 23. <TR> 24. <TD> 25. <fieldset> 26. <legend> 27. <B> Clculo de IMC - ndice de Massa Corporal </B> 28. </legend> 29. <BR> 30. <B><h:outputLabel for="peso" value="Peso (Kg):"/></B> 31. <BR> 32. <h:inputText id="peso" value="#{controleIMC.peso}" size="10"/> 33. <BR> 34. <BR> 35. <B><h:outputLabel for="altura" value="Altura (em metros):"/></B> 36. <BR> 37. <h:inputText id="altura" value="#{controleIMC.altura}" size="10"/> 38. <BR> 39. <BR> 40. <B><h:outputLabel for="sexo" value="Sexo:" /><B> 41. <BR> 42. <h:selectOneRadio id="sexo" value="#{controleIMC.sexo}" > 43. <f:selectItem itemLabel="Masculino" itemValue="M"/> 44. <f:selectItem itemLabel="Feminino" itemValue="F"/> 45. </h:selectOneRadio> 46. <BR> 47. <h:outputLabel for="resultado" value="Resultado:" /> 48. <B><h:outputText id="resultado" value="#{controleIMC.imc}"/></B> 49. <BR> 50. <BR> 51. <h:commandButton id="ok" value="Calcular" 52. action="#{controleIMC.ok}"/> 53. </fieldset> 54. </TD> 55. </TR> 56. </Table> 57. </h:form> 58. </f:view> 59. </body> 60. </html> Notas:

O cdigo JSP foi escrito entre as linhas 19 e 58 assinaladas em negrito. As linhas 30 e 32 mostram na tela a mensagem pedindo digitao do peso e monta a caixa de texto para digitao. As linhas 35 e 37 pedem que o usurio digite a altura (em metros, usando ponto para separar a parte decimal) De 40 at 45, rdios pedindo a informao de sexo do paciente (F ou M). Linhas 47 e 48 mostram o resultado dos clculos do IMC Linha 51, boto para executar os clculos.
Se o servidor estiver rodando. Pare o servidor e logo em seguida reinicialize-o e observe se no vai aparecer nenhum erro SEVERE. Se aparecer alguma coisa errada, mais uma vez direcione suas desconfianas na existncia de alguma biblioteca equivocada. No encontrando nada, volte e confira as etapas anteriores. Resultado no navegador
Apndice
Exemplos 1 - Um exemplo de fluxo de caixa: Vamos montar um projeto a partir do diagrama de classes abaixo:
A classe Lanamento:
1. public class Lancamento { 2. 3. public static final short CREDITO = 1; 4. public static final short DEBITO = 2; 5. 6. private static boolean erro; 7. 8. private float valor; 9. private short tipo; 10. private PMS_Time data; 11. private String descricao; 12. 13. public Lancamento (float valor, PMS_Time data, short tipo, 14. String descricao){ 15. this.valor = valor; 16. this.data = data; 17. this.tipo = tipo; 18. this.descricao = descricao; 19. 20. Lancamento.setErro((tipo != CREDITO && tipo != DEBITO) || valor < 0); 21. } 22. public Lancamento (float valor, short tipo, String descricao) 23. throws Exception { 24. this(valor, new PMS_Time(new PMS_Time().getDataTexto()), tipo, 25. descricao); 26. } 27. public static boolean getErro ( ) { 28. return Lancamento.erro; 29. } 30. public static void setErro(boolean erro) { 31. Lancamento.erro = erro; 32. } 33. public float getValor ( ) { 34. return this.valor; 35. } 36. public short getTipo ( ) { 37. return this.tipo; 38. } 39. public PMS_Time getData ( ) { 40. return this.data; 41. } 42. public String getDescricao( ){ 43. return this.descricao; 44. } 45. @Override 46. public String toString() { 47. return (this.tipo == CREDITO ? "C":"D") + "\tValor: " + 48. String.format("%7.2f",this.valor) + 49. "\tData: " + data.toString() + "\tDescrio: " + descricao; 50. } 51. }
A classe Caixa:
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. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. public class Caixa { ArrayList<Lancamento> lan; public Caixa(float _saldo) { this(_saldo, new PMS_Time()); } public Caixa(float _saldo, PMS_Time data) { lan = new ArrayList<Lancamento>(); this.lan.add(new Lancamento(_saldo, data, Lancamento.CREDITO, "Transporte")); } public boolean credita(float valor, String descricao) { return credita(valor, new PMS_Time(), descricao); } public boolean credita(float valor, PMS_Time data, String descricao) { Lancamento.setErro(false); this.lan.add(new Lancamento(valor, data, Lancamento.CREDITO, descricao)); return Lancamento.getErro(); } public boolean debita(float valor, String descricao) throws Exception { return debita(valor, new PMS_Time(new PMS_Time().getDataTexto()), descricao); } public boolean debita(float valor, PMS_Time data, String descricao) { if (valor <= getSaldo()) { this.lan.add(new Lancamento(valor, data, Lancamento.DEBITO, descricao)); } else Lancamento.setErro(true); return Lancamento.getErro(); } public float getSaldo() { float saldo = 0; for (Lancamento l : lan) { if (l.getTipo() == Lancamento.CREDITO) saldo += l.getValor(); else saldo -= l.getValor(); } return saldo; } void listaMovimeto(PMS_Time ini, PMS_Time fim) throws Exception { for (Lancamento l : lan) if (l.getData().maiorOuIgualQue(ini) && l.getData().menorOuIgualQue(fim)) System.out.println(l); } public float getMovimetoDia(PMS_Time dia) { float saldo = 0; for (Lancamento l : lan) if (dia.getDataTexto().equals(l.getData().getDataTexto())) saldo += (l.getTipo() == Lancamento.CREDITO) ? l.getValor() : -l.getValor(); return saldo; } }
A classe de testes do Caixa

1. public class TesteLancamentos { 2. 3. public static void main(String[] args) { 4. 5. try { 6. 7. Caixa c = new Caixa(890.14F); 8. 9. boolean erro = false; 10. System.out.println(erro); 11. erro = c.credita(324.54F, "Venda balcao jos."); 12. System.out.println(erro); 13. erro = c.credita(100.55F, new PMS_Time("12/08/2010"), 14. "Venda balco Pedro."); 15. System.out.println(erro); 16. erro = c.debita ( 12.68F, "nibus do patrulheiro"); 17. System.out.println(erro); 18. erro = c.debita ( 15.77F, new PMS_Time("31/08/2010"), 19. "Material escritrio."); 20. System.out.println(erro); 21. 22. if (!erro) { 23. c.listaMovimeto(new PMS_Time("12/07/2008"), 24. new PMS_Time("01/09/2011")); 25. System.out.printf("\nSaldo em caixa: %10.2f\n" , c.getSaldo()); 26. System.out.printf( "Movimento de hoje: %10.2f\n " , 27. c.getMovimetoDia(new PMS_Time())); 28. } 29. else System.out.println( 30. "Existe(m) operao(es) de crdito e/ou dbito invlida(s)."); 31. } catch (Exception e) { 32. e.printStackTrace(); 33. } 34. } 35. }
O resultado na console:
false false false false false C C C D D
Valor: Valor: Valor: Valor: Valor:
890,14 324,54 100,55 12,68 15,77
Data: Data: Data: Data: Data: 1286,78 1202,00
02/09/2010 02/09/2010 12/08/2010 02/09/2010 31/08/2010
Descrio: Descrio: Descrio: Descrio: Descrio:
Transporte Venda balcao jos. Venda balco Pedro. nibus do patrulheiro Material escritrio.
Saldo em caixa: Movimento de hoje:
2 - Um exemplo completo de um gerador Faturas A partir do diagrama de classes dado, construa um projeto gerador de faturas. Inicialmente crie todas as classes respeitando as heranas, composies e agregaes. Notas:
A classe Codigo uma superclasse abstrata e responsvel por armazenar o atributo cdigo (ID) gerado para cada instncia criada. Todas as classes concretas geram um ID no seu construtor. O mtodo String id() da classe Codigo, retorna um String formatado com 6 dgitos e com zeros a esquerda; A classe abstrata Pessoa superclasse de outras duas superclasses abstratas: PessoaFisica e PessoaJuridica (no diagrama, o nome de classe representado em itlico significando que so abstratas); As classes Cliente e Vendedor so subclasses de PessoaFisica; A classe Fornecedor subclasse (nica) de PessoaJuridica; A classe Produto possui um objeto da classe Fornecedor declarado como composio. Note que existe no diagrama, uma linha com um "diamante negro" na ponta, ligando a classe Produto a classe Fornecedor. Esta a forma de representar que existe um objeto da classe Fornecedor dentro de um objeto da classe Produto. O diamante negro "colado" na classe Produto significa que o fornecedor compe o produto e no o contrrio. A classe Item (cada linha da fatura) tambm utiliza composio uma vez que contm um objeto da classe Produto. Veja a linha unindo as classes Item e Produto, com o diamante negro "colado" na classe Item (os produtos compem o item). Note que, a classe Item, declara um atributo abstrato (sublinhado) chamado geraCodigo. Este atributo retem o nmero do ltimo ID gerado para que seja possvel criar novos ID's sequencialmente. Todas as classes concretas (Item, Fatura, Produto, Cliente, Vendedor e Fornecedor) declaram este "contador" para gerao de ID's. A gerao do ID pode ser vista no trecho de cdigo exemplificado abaixo.
private static int geraCodigo = 1;
......
public Item(Produto produto, int quantidade) { super(geraCodigo++); this.produto = produto; this.quantidade = quantidade; }
Todos os construtores das classes concretas devem utilizar este mesmo artifcio.
A classe Fatura possui uma agregao, ou seja possui uma lista de itens (ligao com diamante branco). Ela tambm composta pelas classes Cliente e Vendedor conforme indicado pelas linhas com diamantes negros "colados" a ela. O mtodo imprime() da classe Fatura, dever produzir uma sada na console conforme o exemplo abaixo:
O diagrama de classes:
A classe Codigo:
1. public abstract class Codigo { 2. 3. private int codigo; // Armazena o cdigo (ID) das classes concretas. 4. 5. public Codigo(int codigo) { // Construtor 6. this.codigo = codigo; 7. } 8. public int getCodigo() { 9. return codigo; 10. } 11. public String id() { 12. return String.format("%06d",codigo); // Retorna o cdigo formatado. 13. } 14. }
A classe Pessoa:
1. public abstract class Pessoa extends Codigo { 2. 3. private String nome; 4. private String endereco; 5. 6. public Pessoa(String nome,int codigo) { 7. super(codigo); 8. this.nome = nome; 9. } 10. public String getEndereco() { 11. return endereco; 12. } 13. public void setEndereco(String endereco) { 14. this.endereco = endereco; 15. } 16. public String getNome() { 17. return nome; 18. } 19. }
A classe PessoaFisica:
1. public abstract class PessoaFisica extends Pessoa { 2. 3. private String cpf; 4. private String rg; 5. 6. public PessoaFisica(String nome, String cpf, String rg, int codigo) { 7. super(nome,codigo); //Primeira "coisa" que deve aparecer no mtodo 8. this.cpf = cpf; 9. this.rg = rg; 10. } 11. public String getCpf() { 12. return cpf; 13. } 14. public String getRg() { 15. return rg; 16. } 17. }
A classe PessoaJuridica:
1. public abstract class PessoaJuridica extends Pessoa { 2. 3. private String cgc; 4. 5. public PessoaJuridica(String nome, String cgc, int codigo) { 6. super(nome,codigo); 7. this.cgc = cgc; 8. } 9. public String getCgc() { 10. return cgc; 11. } 12. }
A classe Cliente:
1. public class Cliente extends PessoaFisica { 2. 3. private Vendedor vendedor; 4. private static int geraCodigo = 1; 5. 6. public Cliente(Vendedor vendedor, String nome, String cpf, String rg) { 7. super(nome, cpf, rg, geraCodigo++); 8. this.vendedor = vendedor; 9. } 10. public Vendedor getVendedor() { 11. return this.vendedor; 12. } 13. public void setVendedor(Vendedor vendedor) { 14. this.vendedor = vendedor; 15. } 16. }
A classe Vendedor:
1. public class Vendedor extends PessoaFisica { 2. 3. private float comissao; 4. private static int geraCodigo = 1; 5. 6. public Vendedor(String nome, String cpf, String rg, float comissao) { 7. super(nome, cpf, rg,geraCodigo++); 8. this.comissao = comissao; 9. } 10. public float getComissao() { 11. return this.comissao; 12. } 13. }
A classe Fornecedor:
1. public class Fornecedor extends PessoaJuridica { 2. 3. private static int geraCodigo = 1; 4. public Fornecedor(String nome, String cgc) { 5. super(nome,cgc,geraCodigo++); 6. } 7. }
A classe Item:
1. public class Item extends Codigo { 2. 3. private Produto produto; // Objeto composio 4. private int quantidade; 5. private static int geraCodigo = 1; 6. 7. public Item(Produto produto, int quantidade) { 8. super(geraCodigo++); 9. this.produto = produto; 10. this.quantidade = quantidade; 11. } 12. public Produto getProduto() { 13. return produto; 14. } 15. public int getQuantidade() { 16. return quantidade; 17. } 18. public static String titulosColunas() { 19. return 20. "|"+String.format("%-15s","Produto" ) + 21. "|"+String.format("%-15s","Fornecedor") + 22. "|"+String.format("%-5s","Quant") + 23. "|"+String.format("%-12s","Apresentao") + 24. "|"+String.format("%10s","Preo R$") + 25. "|"+String.format("%10s","Total R$") + "|"; 26. 27. } 28. public String toString() { 29. return 30. "|"+String.format("%-15s",produto.getNomeProduto()) + 31. "|"+String.format("%-15s",produto.getFornecedor().getNome()) + 32. "|"+String.format("%5d",this.quantidade) + 33. "|"+String.format("%12s",this.produto.getApresentacao()) + 34. "|"+String.format("%10.2f",produto.getPreco()) + 35. "|"+String.format("%10.2f",this.quantidade*produto.getPreco())+ "|" ; 36. } 37. }
A classe Produto:
1. public class Produto extends Codigo { 2. 3. private String apresentacao; 4. private Fornecedor fornecedor; 5. private String nomeProduto; 6. private float preco; 7. private static int geraCodigo = 1; 8. 9. public Produto(Fornecedor fornecedor, 10. String nomeProduto, String apresentacao) { 11. 12. super(geraCodigo++); 13. this.nomeProduto = nomeProduto; 14. this.apresentacao = apresentacao; 15. this.fornecedor = fornecedor; 16. } 17. public String getApresentacao() { 18. return apresentacao; 19. } 20. public String getNomeProduto() { 21. return nomeProduto; 22. }
23. public float getPreco() { 24. return preco; 25. } 26. public void setPreco(float preco) 27. throws IllegalArgumentException { 28. if (preco < 0) { 29. throw new IllegalArgumentException("Preo no pode ser negativo."); 30. } 31. this.preco = preco; 32. } 33. public Fornecedor getFornecedor() { 34. return fornecedor; 35. } 36. }
A classe Fatura:
1. public class Fatura extends Codigo { 2. 3. private Cliente cliente; 4. private Vendedor vendedor; 5. private static int geraCodigo = 1; 6. ArrayList<Item> itens = new ArrayList<Item>(); 7. 8. public Fatura(Cliente cliente, Vendedor vendedor) { 9. super(geraCodigo++); 10. this.cliente = cliente; 11. this.vendedor = vendedor; 12. } 13. public void addItem(Item item){ 14. itens.add(item); 15. } 16. public void imprime() { 17. 18. SimpleDateFormat formatador=new SimpleDateFormat("dd/MM/yyyy"); 19. System.out.println("Fatura nmero: " + this.id() + 20. "\tData: " + formatador.format(new Date())); 21. String linha = "+-----------------------------------" + 22. "-------------------------------------+"; 23. 24. System.out.println("Cliente: " + cliente.getNome()); 25. System.out.println("Vendedor: " + vendedor.getNome()); 26. System.out.println(linha); 27. System.out.println(Item.titulosColunas()); 28. System.out.println(linha); 29. 30. float total=0; 31. for (Item item:itens) { 32. System.out.println(item); 33. total += item.getQuantidade()*item.getProduto().getPreco(); 34. } 35. System.out.println(linha); 36. System.out.println("|Total da fatura: " + 37. String.format("%55.2f",total)+"|"); 38. System.out.println(linha); 39. System.out.println("|Comisso: " + 40. String.format("%55.2f",total*vendedor.getComissao()/100.)+"|"); 41. System.out.println(linha); 42. } 43. }
A classe de teste:
1. public class TesteFatura { 2. 3. public static void main(String args[]) { 4. 5. Vendedor jose = new Vendedor("Jos Maria", "222.222.222/22", 6. "099887779-8", 2.5F); 7. Vendedor maria = new Vendedor("Maria Jos", "111.111.111/11", 8. "087654334-0", 2.3F); 9. Cliente joana = new Cliente(jose, "Joana Darc", "333.333.333/33", 10. "000000003-00"); 11. Cliente pedro = new Cliente(maria, "Pedro Ernesto", "444.444.444/44", 12. "000000005-00"); 13. Fornecedor cocaCola = new Fornecedor("Coca Cola", "111.111.111/11"); 14. Fornecedor nestle = new Fornecedor("Nestl", "222.222.222/22"); 15. 16. try { 17. Produto coca2L = new Produto(cocaCola, "Coca cola pet", "2 litros"); 18. coca2L.setPreco(3.76F); 19. 20. Produto cocaLata = new Produto(cocaCola, "Coca em lata", "350ml"); 21. cocaLata.setPreco(1.05F); 22. 23. Produto coca1L = new Produto(cocaCola, "Coca cola pet", "1 litro"); 24. coca1L.setPreco(2.23F); 25. 26. Produto nescauLata = new Produto(nestle, "Nescau Lata", "250g"); 27. nescauLata.setPreco(2.87F); 28. 29. Produto nescauRefill = new Produto(nestle, "Nescau Refill", "500g"); 30. nescauRefill.setPreco(2.18F); 31. 32. Fatura faturaLixo = new Fatura(pedro, jose); 33. Fatura fatura = new Fatura(joana, maria); 34. 35. fatura.addItem(new Item(coca2L, 10)); 36. fatura.addItem(new Item(coca1L, 5)); 37. fatura.addItem(new Item(cocaLata, 48)); 38. fatura.addItem(new Item(nescauLata, 5)); 39. fatura.addItem(new Item(nescauRefill, 15)); 40. 41. fatura.imprime(); 42. 43. // Teste de gerao de cdigos: 44. System.out.println("\nCdigo do vendedor jos: " + jose.id()); 45. System.out.println("Cdigo do vendedor maria: " + maria.id()); 46. System.out.println("Cdigo do cliente joana: " + joana.id()); 47. System.out.println("Cdigo do cliente pedro: " + pedro.id()); 48. System.out.println("Cdigo do fornecedor coca cola: " 49. + cocaCola.id()); 50. System.out.println("Cdigo do fornecedor nestle: " + nestle.id()); 51. System.out.println("Cdigo do produto: coca2L " + coca2L.id()); 52. System.out.println("Cdigo do produto: nescauRefill " 53. + nescauRefill.id()); 54. System.out.println("Nmero da fatura lixo: " + faturaLixo.id()); 55. System.out.println("Nmero da fatura pra valer: " + fatura.id()); 56. } catch (IllegalArgumentException e) { 57. System.out.println("Ocorreu um erro: " + e.getMessage()); 58. } 59. } 60. }
A sada do programa de teste:

Fatura nmero: 000002 Data: 02/09/2010 Cliente: Joana Darc Vendedor: Maria Jos +------------------------------------------------------------------------+ |Produto |Fornecedor |Quant|Apresentao| Preo R$| Total R$| +------------------------------------------------------------------------+ |Coca cola pet |Coca Cola | 10| 2 litros| 3,76| 37,60| |Coca cola pet |Coca Cola | 5| 1 litro| 2,23| 11,15| |Coca em lata |Coca Cola | 48| 350ml| 1,05| 50,40| |Nescau Lata |Nestl | 5| 250g| 2,87| 14,35| |Nescau Refill |Nestl | 15| 500g| 2,18| 32,70| +------------------------------------------------------------------------+ |Total da fatura: 146,20| +------------------------------------------------------------------------+ |Comisso: 3,36| +------------------------------------------------------------------------+ Cdigo Cdigo Cdigo Cdigo Cdigo Cdigo Cdigo Cdigo Nmero Nmero do do do do do do do do da da vendedor jos: 000001 vendedor maria: 000002 cliente joana: 000001 cliente pedro: 000002 fornecedor coca cola: 000001 fornecedor nestle: 000002 produto: coca2L 000001 produto: nescauRefill 000005 fatura lixo: 000001 fatura pra valer: 000002
Annotations Annotations so informaes precedidas por uma caractere '@' editadas diretamente no cdigo. As regras de criao de novas annotations apareceram a partir da verso 5 do Java, mas j existiam em verses anteriores com finalidade basicamente de auxiliar na documentao do cdigo (Javadoc). A partir da verso 5 as possibilidades se multiplicaram. Existem muitas annotations prontas para o uso como por exemplo:
@Deprecated, @Override, @SuppressWarnings() etc... Exemplo de uso no cdigo:

1. 2. 3. 4.
@Override // Indica que o mtodo sobrescrito public double getPerimetro() { return 4D * this.lado1; }
As annotations devem ser declaradas acima do trecho de cdigo que se deseja tratar. Pode ser usada para "anotar" mtodos ou atributos. A nova verso das annotations pode tambm receber argumentos. Exemplo suprimindo as advertncias de boxing (Converso de long para Long):
1. 2. 3. 4. 5. 6. 7. 8.
@SuppressWarnings("boxing") public Long somaIntervalo(long ini, long fim) { Long soma = 0L; for (Long i = ini; i <= fim ; i++) { soma += i; } return soma; }
Criando annotations Vamos criar uma annotation que verifica se um determinado argumento de uma classe est ou no inicializado... O primeiro passo escrever de uma interface para definir a annotation. A interface:
1. 2. 3. 4. 5. 6.
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD) // Indica que o alvo campo! public @interface Requerido { String argumento(); // Mtodo abstrato para passagem // de argumento }
A classe de tratamento da Annotation Requerido A seguir criamos um mtodo esttico para fazer o tratamento da annotation.
1. public class VerificaRequerido { 2. 3. public static String validar(Object obj) 4. throws IllegalArgumentException, IllegalAccessException 5. 6. for (Field prop : obj.getClass().getDeclaredFields()) { 7. for (Annotation a : prop.getAnnotations()) { 8. if ("Requerido".equals(a.annotationType() 9. .getSimpleName()) { 10. prop.setAccessible(Boolean.TRUE); 11. 12. 13. 14. 15. 16. 17. 18. 19. 20.
if (prop.get(obj) == null) { // Opa!!! Achei um campo null! Requerido r = (Requerido) a; // Pego a annotation... return " necessrio preencher " + r.args(); // E mostro a mensagem! } } } return null; } }
Testando a annotation Requerido:

21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40.
public class Pessoa { @Requerido(args = "Nome da pessoa") private String nome; private Long cpf; public static void main(String args[]) { Pessoa p = new Pessoa(); // p.setNome("Man Manoel"); p.setCpf(new Long("22222222222")); try { String mens = VerificaRequerido.validar(p); if (mens != null) System.out.println(mens); } catch (Exception e) { e.printStackTrace(); } } public void setNome(String nome) {this.nome = nome;} public void setCpf(Long cpf) {this.cpf = cpf;}
Imprime: necessrio preencher o campo: Nome da Pessoa
Padres de projeto Padres de projeto so procedimentos testados e consagrados utilizados para alcanar um objetivo qualquer. A utilizao de padres comuns em vrias reas da engenharia e na rea de TI so conhecidos como Design Patterns ou em portugus, Padres de Projeto. "Cada padro descreve um problema que ocorre repetidas vezes em nosso ambiente, e ento descreve o ncleo da soluo para aquele problema, de tal maneira que pode-se usar essa soluo milhes de vezes sem nunca faz-la da mesma forma duas vezes" Christopher Alexander Singleton Classes Singleton so classes projetadas para criar uma quantidade limitada de instncias (normalmente apenas uma) e oferecer acesso a estas instncias via mtodos estticos que retornam as referncias a estas instncias. Este efeito pode ser obtido de certa forma com uso de classes estticas, porm, classes estticas consomem memria mesmo que no utilizadas e no podem ser estendidas. Nosso exemplo mostra uma classe Singleton que permite trabalhar com trs instncias: A motivao para o desenvolvimento desta soluo poderia ser a necessidade de montar um conjunto de listas que possam ser preenchidas e/ou consultadas de qualquer lugar da aplicao. Neste exemplo todas as trs instncias sero criadas:
1. public class Infracao { 2. 3. 4. 5. // Impede a criao de objetos Infracao via operador new private Infracao() { } private ArrayList<String> descricao = new ArrayList<String>();
6. public void setDescricao(final String descricao) { 7. this.descricao.add(descricao); 8. } 9. public ArrayList<String> getDescricao() { 10. return this.descricao; 11. } 12. // Classes internas auxiliares para criao das instncias. 13. // Evita problemas de sincronizao de threads. 14. private static class GraveHolder { 15. private static Infracao grave = new Infracao(); 16. } 17. private static class ModeradoHolder { 18. private static Infracao moderada = new Infracao(); 19. } 20. private static class LeveHolder { 21. private static Infracao leve = new Infracao(); 22. } 23. // Mtodos de acesso as instncias. 24. public static Infracao getGrave() { 25. return Infracao.GraveHolder.grave; 26. } 27. public static Infracao getModerado() { 28. return Infracao.ModeradoHolder.moderada; 29. } 30. public static Infracao getLeve() { 31. return Infracao.LeveHolder.leve; 32. } 33. }
O programa de teste de Singleton

1. public static void main(final String args[]) { 2. 3. Infracao grave = Infracao.getGrave(); 4. Infracao moderada = Infracao.getModerado(); 5. Infracao leve = Infracao.getLeve(); 6. 7. grave.setDescricao("DEIXAR O CONDUTOR/PASSAGEIRO DE USAR CINTO"); 8. grave.setDescricao("DEIXAR O CONDUTOR DE PRESTAR SOCORRO A VITIMA"); 9. grave.setDescricao("REPARAR VEIC EM ROD E VIA TRANS RAPIDO"); 10. 11. moderada.setDescricao("DEIXAR DE REMOVER VEICULO ENVOLVIDO ACIDENTE"); 12. moderada.setDescricao("ESTACIONAR A MENOS DE 5M DO ALINHAMENTO "); 13. moderada.setDescricao("ESTACIONAR EM DESACORDO COM O ESTABELECIDO"); 14. 15. leve.setDescricao("REPARAR VEICULO NAS DEMAIS VIAS POSS REMOCAO"); 16. leve.setDescricao("ESTACIONAR AFASTADO DA GUIA DE 50CM A 1M"); 17. 18. ArrayList<String> graves = grave.getDescricao(); 19. 20. System.out.println("\nMostrando o contedo da instncia 'grave'.\n"); 21. for (String descricao: graves) 22. System.out.println(descricao); 23. 24. // Buscando a instncia grave mas com outro nome.. 25. Infracao infracao = Infracao.getGrave(); 26. 27. // Acrescenta mais uma descrio 28. infracao.setDescricao("ESTACIONAR SOBRE CICLOVIA OU CICLO FAIXA"); 29. 30. System.out.println( 31. "\nMostra a lista de descries graves com um item acrescentado.\n"); 32. for (String descricao: graves) 33. System.out.println(descricao); 34. }
Imprime:
Mostrando o contedo da instncia 'grave'. DEIXAR O CONDUTOR/PASSAGEIRO DE USAR O CINTO DEIXAR O CONDUTOR DE PRESTAR SOCORRO A VITIMA REPARAR VEIC EM ROD E VIA TRANS RAPIDO Mostra a lista de descries graves com um item acrescentado.
DEIXAR O CONDUTOR/PASSAGEIRO DE USAR CINTO
DEIXAR O CONDUTOR DE PRESTAR SOCORRO A VITIMA QDO SOLIC

REPARAR VEICULO NAS DEMAIS VIAS POSS REMOCAO
ESTACIONAR SOBRE CICLOVIA OU CICLO FAIXA
Note que:
Com este padro conseguimos montar trs listas dinmicas que podem ser alimentadas ou consultadas em qualquer parte da aplicao e a qualquer momento. Cada lista foi criada apenas uma vez e ser sempre a mesma instncia durante todo o tempo em que a aplicao estiver no ar. Um exemplo comum para uso de Singleton poderia ser o caso de um sistema que utiliza em vrias telas, combos populados com listas do tipo: Unidade da Federao; Estado Civil, Sexo etc. Que poderiam servir todas as telas sem necessidade de novos acessos a banco de dados toda vez que uma das telas fosse carregada.
Factory Method uma alternativa muito utilizada para criao de objetos que adia a deciso sobre qual classe concreta se vai realmente instanciar. "Definir uma interface para criar um objeto mas deixar que subclasses decidam que classe instanciar. Factory Method permite que uma classe delegue a responsabilidade de instanciamento s subclasses." [GoF] O acesso a um objeto concreto ser atravs da interface conhecida, atravs de sua superclasse, mas sem saber qual implementao concreta est sendo usada. Um Factory Method define uma interface comum para criar objetos, onde a informao de qual objeto concreto ser utilizado pode ser fornecida de diversas maneiras, via parmetro, arquivo de configurao, etc. Vantagens

Criao de objetos desacoplada do conhecimento do tipo concreto do objeto; Conecta hierarquias de classe paralelas; Facilita a extensibilidade.
Desvantagens
Ainda preciso decidir a classe concreta do gerador de instncias.
Exemplo: A classe abstrata ou interface:

1. public interface Pizza { 2. public float getPreco(); 3. }
As classes concretas, uma para cada tipo de piza:

1. public class Mozarela implements Pizza { 2. public float getPreco() { 3. return 25.50F; 4. } 5. } 1. public class Calabresa implements Pizza { 2. public float getPreco() { 3. return 28.70F; 4. } 5. } 1. public class Portuguesa implements Pizza { 2. public float getPreco() { 3. return 38.54F; 4. } 5. }
A pizzaria
1. public class Pizzaria { 2. 3. public enum Sabor { 4. mozarela, 5. calabresa, 6. portuguesa 7. } 8. // Este o mtodo responsvel por instanciar o objeto selecionado. 9. public static Pizza fabricaPizza(Sabor sabor) { 10. switch (sabor) { 11. case mozarela: return new Mozarela(); 12. case calabresa: return new Calabresa(); 13. case portuguesa: return new Portuguesa(); 14. } 15. throw new 16. IllegalArgumentException(sabor + " no existe no cardpio!"); 17. } 18. }
O programa principal:
1. public static void main(final String args[]) { 2. 3. float soma = 0F; 4. for (Pizzaria.Sabor sabor : Pizzaria.Sabor.values()) { 5. System.out.printf("Preo da pizza sabor %-10s: R$ %6.2f\n", 6. sabor, Pizzaria.fabricaPizza(sabor).getPreco()); 7. soma += Pizzaria.fabricaPizza(sabor).getPreco(); 8. System.out.printf("Total a pagar: R$%6.2f\n" ,soma); 9. }
Imprime: Preo Preo Preo Total da pizza da pizza da pizza a pagar: sabor mozarela : R$ sabor calabresa : R$ sabor portuguesa: R$ R$ 92,74 25,50 28,70 38,54
Notas:

Passamos como argumento para a fbrica de pizza qual o sabor desejado. A fabrica de pizza fabrica o objeto correspondente ao escolhido e retorna sua referncia. Se for necessrio, a interface Pizza, pode ser transformada em uma classe abstrata.
Class Adapter O padro de projeto Adapter procura converter a interface de uma classe em outra interface esperada pelos clientes. Adapter permite a comunicao entre classes que no poderiam trabalhar juntas devido incompatibilidade de suas interfaces. Existem duas formas de implementar um Adapter:

Class Adapter Object Adapter
A principal aplicao para o padro Adapter permitir que a interface de uma classe seja "adaptada" interface de uma outra de forma que ambas possam trabalhar juntas conectando classes que implementam interfaces diferentes e no compatveis. Podemos tambm usar o Adapter caso seja necessrio modificar a interface de uma classe em funo de um novo requisito nos casos em que a modificao do cdigo das classes existentes no possvel por no se ter acesso aos seus fontes. Vamos ver um exemplo de Class Adapter. Supondo duas classes uma j existente e outra que estamos desenvolvendo. J temos uma classe existente Caixa (que ser adaptada) e outra classe ContaCorrente que j implementa a interface TipoContaCorrente. Ambas as classes possuem um servio que calcula e retorna o saldo. A interface:
1. public interface TipoContaCorrente { 2. public Double getSaldo(); 3. public void credita(Double valor); 4. public void debita(Double valor); 5. } 1. public class ContaCorrente implements TipoContaCorrente { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. private List<Double> creditos = new ArrayList<Double>(); private List<Double> debitos = new ArrayList<Double>(); public Double getSaldo() { float soma = 0F; for (Double credito: this.creditos)soma += credito.doubleValue(); for (Double debito: this.debitos )soma -= debito.doubleValue(); return new Double(soma); } public void credita(Double valor) { this.creditos.add(valor); } public void debita(Double valor) { this.debitos.add(valor); }
A classe ContaCorrente:
A classe Caixa j existente que ser Adaptada (no pode ser modificada). O cdigo fonte da interface TipoCaixa irrelevante para o entendimento do exemplo.
1. public class Caixa implements TipoCaixa { 2. private List<Double> lancamentos = new ArrayList<Double>(); 3. public void credita(Double valor) { 4. this.lancamentos.add(valor); 5. } 6. public void debita(Double valor) { 7. double var = valor.doubleValue() * -1; 8. this.lancamentos.add(new Double(var)); 9. } 10. public Double getSaldo() { 11. float soma = 0F; 12. for (Double valor: this.lancamentos) soma += valor.doubleValue(); 13. return new Double(soma); 14. } 15. }
Escrevendo o Adapter da classe Caixa:

1. public class AdaptadorCaixa extends Caixa implements TipoContaCorrente { 2. 3. @Override 4. public Double getSaldo() { 5. return super.getSaldo(); 6. } 7. @Override 8. public void credita(Double valor) { 9. super.credita(valor); 10. } 11. @Override 12. public void debita(Double valor) { 13. super.debita(valor); 14. } 15. }
Nosso mtodo de teste.

1. public static void main(final String args[]) { 2. 3. TipoContaCorrente saldos[] = new TipoContaCorrente[2]; 4. 5. saldos[0] = new ContaCorrente(); 6. saldos[1] = new AdaptadorCaixa(); 7. 8. ContaCorrente cc = (ContaCorrente) saldos[0]; 9. AdaptadorCaixa ac = (AdaptadorCaixa) saldos[1]; 10. 11. cc.credita(new Double(10F)); 12. cc.debita(new Double(5F)); 13. 14. ac.credita(new Double(20F)); 15. ac.debita(new Double(10F)); 16. 17. for (TipoContaCorrente tcc : saldos) { 18. System.out.println("Saldo: " + tcc.getSaldo()); 19. } 20. }
Notem que a classe Caixa no foi utilizada diretamente mas sim sua classe adaptada AdaptadorCaixa. Desta forma a interface original que a classe Caixa implementa (TipoCaixa) foi desativada e substituida pela interface TipoContaCorrente. Notem que, mesmo que no exemplo os mtodos getSaldo(), credita() e debita() tenham a mesma assinatura em ambas as classes, isso no essencial uma vez que a classe adaptadora pode fazer a chamada utilizando o nome original do mtodo na classe adaptada. A chamada tcc.getSaldo() vista na linha 18 mostra o funcionamento da adaptao feita.
Proxy A principal aplicao do padro proxy prover um substituto ou ponto atravs do qual um objeto possa controlar o acesso a um outro objeto [GoF]. comum que uma aplicao precise acessar informaes de um determinado objeto mas no pode faz-lo diretamente por questes de segurana ou porque o objeto pertence a outro sistema. A idia produzir um objeto intermedirio que possua as informaes ou servios necessrios e possa ser acessado em segurana. Como exemplo, uma classe Usuario precisa ser acessada para obter informaes do objeto usurio como nome e endereo. Os dados do usurio como senha e login devem permanecer fora de acesso. A idia criar uma interface proxy que permita acessar a classe Usuario, disponibilizando apenas os mtodos necessrios ao acesso dos dados desejados mas mantendo os demais protegidos. Inicialmente a classe que deve ser protegida deve implementar tambm a interface proxy declarando os mtodos requeridos.
1. public interface UsuarioProxy { 2. public String getNome(); 3. public String getEndereco(); 4. }
A classe que ser protegida (Simplificada para tornar o exemplo mais claro):
1. public class Usuario implements UsuarioProxy { 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. private private private private String String String String nome; endereco; senha; login; Matriz para simulao da base de dados 5 Casa 4" ,"1234", "JOCA" }, 13 de maio" ,"4321", "PEDRO" }, de baixo S/N" ,"4423", "ANINHA"}, Olavo Bilac" ,"8899", "DIEGO" },
public Usuario(int id) { // Mtodo construtor String usuarios[][] = { // {"Jos Carlos" ,"Rua {"Pedro Jos" ,"Rua {"Ana Maria" ,"Rua {"Diego Augusto" ,"Rua }; this.nome this.endereco this.senha this.login } public public public public public public public public } String String String String void void void void = = = =
usuarios[id][0]; usuarios[id][1]; usuarios[id][2]; usuarios[id][3]; { { { { return return return return this.nome; } this.endereco; } this.senha; } this.login; } {this.nome {this.endereco {this.senha {this.login = = = = nome; } endereco;} senha; } login; }
getNome() getEndereco() getSenha() getLogin()
setNome(String nome) setEndereco(String endereco) setSenha(String senha) setLogin(String login)
Mtodo de fabricao de usurios protegidos:

1. public class FabricaUsuario implements UsuarioProxy { 2. 3. private Usuario usuario; 4. // Mtodo quer retorna a referncia do objeto Usuario. 5. public static UsuarioProxy usuario(int id) { 6. return new Usuario(id); 7. } 8. public String getEndereco() { 9. return this.usuario.getEndereco(); 10. } 11. public String getNome() { 12. return this.usuario.getNome(); 13. } 14. }
Utilizando a interface UsuarioProxy

1. public static void main(final String args[]) { 2. 3. UsuarioProxy usuario = FabricaUsuario.usuario(2); 4. 5. System.out.println("Nome: " + usuario.getNome()); 6. System.out.println("Endereo: " + usuario.getEndereco()); 7. }
Prs e contras:
Vantagens

Transparncia: mesma sintaxe usada na comunicao entre o cliente e sujeito real usada no proxy; Permite o tratamento inteligente dos dados no cliente; Permite maior eficincia com caching no cliente;
Desvantagens

Possvel impacto na performance; Transparncia nem sempre 100% (fatores externos como queda da rede podem tornar o proxy inoperante ou desatualizado)
Alguns tipos de proxy:

Remote Proxy - prov um representante local para um objeto em um espao de endereamento diferente; Virtual Proxy - cria objeto sob demanda; Protection Proxy - controla acesso ao objeto original; Smart References - executa operaes adicionais quando o objeto acessado; Copy-on-write - compartilhar grandes objetos, fazendo uma cpia apenas se necessrio.
Facade (faade) O objetivo do Facade oferecer uma interface nica para um conjunto de interfaces de um subsistema. Faade define uma interface de nvel mais elevado que torna o subsistema mais fcil de usar ao oferecer uma interface simples para uma coleo de classes e desta forma o Cliente no precisa conhecer detalhes do subsistema para que possa utiliz-lo. Nosso projeto exemplo contm uma coleo de classes cujos objetos precisam ser manipulados em um determinado escopo de negcio. Vamos imaginar um sistema que manipula faturas onde precisamos trabalhar com clientes, produtos, fornecedores, itens, faturas e o bancos de dados onde obtemos todos os dados. As classes do exemplo esto simplificadas para facilitar o entendimento. A Classe Fatura possui a lista de itens, o id do cliente o o nmero da fatura.
1. public class Fatura { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. } private String numero; private Integer idCliente; private List<Item> itens = new ArrayList<Item>(); public Fatura(Integer _idCliente, final this.numero = _numero; this.idCliente = _idCliente; } public String getNumero() { return public Integer getIdCliente() { return public List<Item> getItens() { return String _numero) {
this.numero; } this.idCliente;} this.itens; }
public void addItem(Item item) { this.itens.add(item); }
A classe item:
1. public class Item { 2. private Integer quantidade; 3. private Produto produto; 4. private Fornecedor fornecedor; 5. public Item(Produto produto, Fornecedor fornecedor, 6. Integer quantidade) { 7. this.quantidade = quantidade; 8. this.produto = produto; 9. this.fornecedor = fornecedor; 10. } 11. public Integer getQuantidade() { return this.quantidade;} 12. public Produto getProduto() { return this.produto; } 13. public Fornecedor getFornecedor(){ return this.fornecedor;} 14. }
A classe Cliente:
1. public class Cliente { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. private Integer id; private String nome; private String cgc; public Cliente(Integer id, String nome, String cgc) { this.id = id; this.nome = nome; this.cgc = cgc; } public Integer getId() { return this.id; } public String getNome() { return this.nome; } public String getCgc() { return this.cgc; }
A Classe Produto
1. public class Produto { 2. 3. private Integer id; 4. private String nome; 5. private Float preco; 6. 7. public Integer getId() { return this.id; } 8. public String getNome() { return this.nome; } 9. public Float getPreco() { return this.preco; } 10. 11. public Produto(Integer id, String nome, Float preco) { 12. this.id = id; 13. this.nome = nome; 14. this.preco = preco; 15. } 16. }
A classe BancoDados emula um banco de dados que fica transparente para o cliente.
1. public class BancoDados { 2. 3. public Cliente selectCliente(int id) { 4. 5. Object dados[][] = { 6. {new Integer("0"),"Grfica XPTO","444.555.666/77"}, 7. {new Integer("1"),"Papelaria Papelada","333.444.555/66"}, 8. {new Integer("2"),"Jambo","111.111.111/11"}, 9. }; 10. Cliente cliente = new Cliente((Integer) dados[id][0], 11. (String) dados[id][1], 12. (String) dados[id][2]); 13. return cliente; 14. } 15. public Produto selectProduto(int id) { 16. Object dados[][] = { 17. {new Integer("0"),"Caneta",new Float("1.50")}, 18. {new Integer("1"),"Lpis",new Float("0.25") }, 19. {new Integer("2"),"Caderno 100f",new Float("5.25") }, 20. {new Integer("3"),"Livro Java",new Float("85.00") }, 21. }; 22. Produto produto = new Produto((Integer)dados[id][0], 23. (String) dados[id][1], 24. (Float) dados[id][2]); 25. return produto; 26. } 27. public Fornecedor selectFornecedor(int id) { 28. Object dados[][] = { 29. {new Integer("0"), "Editora Abril", "666.737.888/99"}, 30. {new Integer("1"), "Editora Novatec", "222.333.744/55"}, 31. {new Integer("2"), "Bic", "699.848.672/36"}, 32. {new Integer("3"), "Faber Castell", "799.388.757/46"}, 33. {new Integer("4"), "Tilibra", "859.848.774/64"}, 34. }; 35. 36. Fornecedor fornecedor = new Fornecedor((Integer)dados[id][0], 37. (String) dados[id][1], 38. (String) dados[id][2]); 39. return fornecedor; 40. } 41. }
A Classe Facade
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. 32. 33. 34. 35. public class Facade { BancoDados banco = new BancoDados(); Fatura fatura; public Facade(Integer idCliente,String cgc) { this.fatura = new Fatura(idCliente,cgc); } public void insereItem(int idProduto, int idFornecedor, Integer quantidade) { Produto produto = this.banco.selectProduto(idProduto); Fornecedor fornecedor= this.banco.selectFornecedor(idFornecedor); Item item = new Item(produto,fornecedor,quantidade); this.fatura.addItem(item);
public void imprimeCabecalho() { System.out.printf("%-15s %-15s %10s %10s %10s\n\n", "Produto","Fornecedor","Quant","Preo","Total"); } public void imprimeDadosCliente() { Cliente cliente = this.banco.selectCliente(this.fatura.getIdCliente()); System.out.println(cliente.getNome()+" - CGC: "+ cliente.getCgc()+"\n"); } public void imprimeFatura() { for (Item item: this.fatura.getItens()) { Float totalPreco = item.getQuantidade() * item.getProduto().getPreco(); System.out.printf("%-15s %-15s %10d %10.2f %10.2f\n", item.getProduto().getNome(), item.getFornecedor().getNome(), item.getQuantidade(), item.getProduto().getPreco(), totalPreco); } }
36. public void imprimeTotal () { 37. float soma = 0; 38. for (Item item: this.fatura.getItens()) 39. soma += item.getQuantidade() * item.getProduto().getPreco(); 40. System.out.printf("\nTotal fatura: %10.2f\n" , soma); 41. } 42. }
A classe de teste:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. public static void main(final String args[]) { Facade facade = new Facade(2,"111222333"); facade.insereItem(1, facade.insereItem(1, facade.insereItem(0, facade.insereItem(3, facade.insereItem(2, 3, 10); 3, 5); 2, 15); 1, 1); 4, 2);
facade.imprimeDadosCliente(); facade.imprimeCabecalho(); facade.imprimeFatura(); facade.imprimeTotal();
Imprime: Jambo - CGC: 111.111.111/11 Produto Lpis Lpis Caneta Livro Java Caderno 100f Total fatura: Observer um padro de projeto desenvolvido para definir uma dependncia um-para-muitos entre objetos de tal forma que quando um objeto mudar seu estado, ou seja, mude o contedo de uma ou mais propriedades, todos os objetos a ele associados sejam notificados e atualizados automaticamente [GoF]. Segundo Helder Rocha, o padro de projeto Observer apresenta: Fornecedor Faber Castell Faber Castell Bic Editora Novatec Tilibra 121,75 Quant. 10 5 15 1 2 Preo 0,25 0,25 1,50 85,00 5,25 Total 2,50 1,25 22,50 85,00 10,50
Vantagens

Tanto observadores quando sujeitos observados podem ser reutilizados e ter sua interface e implementao alteradas sem afetar o sistema; O acoplamento forte implicado pelo relacionamento bidirecional reduzido com o uso de interfaces e classes abstratas.
Desvantagens

O abuso pode causar srio impacto na performance; Sistemas onde todos notificam todos a cada mudana ficam inundados de requisies ("tempestade de eventos").
A aplicao mais comum do Observer na atualizao em tempo real de telas que usam ou mostram dados que podem sofrer alguma alterao independente da ao do usurio. Seria o caso, por exemplo, de uma ou mais telas que informassem em tempo real o valor da cotao de moedas, aes da bolsa de valores etc. Use o padro Observer para: manter dois ou mais aspectos interdependentes de uma abstrao, ao mesmo tempo permitindo que sejam reutilizados independentemente; Mudar um objeto causando mudanas em outros objetos, sendo que no se sabe a priori quantos objetos precisam ser mudados; Fazer um objeto notificar outros objetos de que seu estado mudou, sem assumir nada sobre os outros objetos Buscando um exemplo de baixa complexidade, vamos imaginar uma escola com professores e alunos, todos ligados no sinal que marca o incio e final da aula. O evento sinal afeta todos os alunos e professores e todos devem observar o sinal que por sua vez ser observado por todos. Cada objeto aluno ou professor deve receber como argumento o sinal (comum a todos) para que possa ser observado. Cada aluno ou professor deve se cadastrar na lista de pessoas que devem ser notificadas quando o sinal tocar. Este exemplo foi inspirado no trabalho publicado no blog de Rafael Capucho sobre o padro Observer. Vamos ao exemplo: A interface PessoaLigadaNoSinal: Alunos, professores e qualquer outra pessoa interessada em ser comunicada (observadores) quando o sinal tocar devem implementar esta interface.
1. public interface PessoaLigadaNoSinal { 2. public void atualizarSinal(Sinal s); 3. }
A classe Aluno:
1. public class Aluno implements PessoaLigadaNoSinal { 2. 3. private SinalObservado sinal; 4. private String nome; 5. 6. public Aluno(SinalObservado sinal, String _nome){ 7. this.nome = _nome; 8. this.sinal = sinal; 9. // O aluno que acabou de ser instanciado passado para o 10. // objeto Sinal para que ele possa ser notificado quando o 11. // sinal tocar (true)ou calar (false). 12. this.sinal.adicionaPessoa(this); 13. } 14. public void atualizarSinal(Sinal _sinal) { 15. if(_sinal == this.sinal){ 16. System.out.println(this.nome + ", o intervalo est " + 17. (this.sinal.getEstadoCampainha()?"iniciando":"terminando")+"!"); 18. } 19. } 20. }
A classe Professor:
1. public class Professor implements PessoaLigadaNoSinal { 2. 3. private SinalObservado sinal; 4. private String nome; 5. private String disciplina; 6. 7. public Professor(SinalObservado _sinal, String _nome, 8. String _disciplina){ 9. this.nome = _nome; 10. this.disciplina = _disciplina; 11. this.sinal = _sinal; 12. this.sinal.adicionaPessoa(this); 13. } 14. 15. public void atualizarSinal(Sinal _sinal) { 16. if(_sinal == this.sinal){ 17. System.out.println("Professor " + this.nome + 18. " (" + this.disciplina + "), o intervalo est " + 19. (this.sinal.getEstadoCampainha() ? 20. "iniciando":"terminando" )); 21. } 22. } 23. }
A interface Sinal
1. public interface Sinal { 2. 3. public void adicionaPessoa (PessoaLigadaNoSinal observador); 4. public void removePessoa (PessoaLigadaNoSinal observador); 5. 6. }
A classe SinalObservado. Esta a nossa classe Observer. Ela coleciona os objetos observadores na lista de pessoas (alunos e professores que implementam PessoaLigadaNoSinal) e possui o mtodo responsvel pela notificao dos observadores quando solicitado e tambm mtodos para a incluso e excluso de pessoas da lista de observadores.
1. public class SinalObservado implements Sinal 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. } {
private boolean intervalo = false; private List<PessoaLigadaNoSinal> pessoas = new ArrayList<PessoaLigadaNoSinal>(); public void botaoTocaSinal() { this.intervalo = !this.intervalo; notificarObservadores(); } public boolean getEstadoCampainha(){ return this.intervalo; } public void adicionaPessoa(PessoaLigadaNoSinal pessoa) { this.pessoas.add(pessoa); } public void removePessoa(PessoaLigadaNoSinal pessoa) { this.pessoas.remove(pessoa); } // Este mtodo percorre a lista de objetos cadastrados como // observadores do sinal e chama o mtodo atualizarSinal() para // cada um deles. private void notificarObservadores(){ for (PessoaLigadaNoSinal pessoa: this.pessoas) pessoa.atualizarSinal(this); }
Por ltimo, a classe de teste do Observer:

1. public class TesteObserver { 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. } public static void main(String[] args) { // O Sinal da escola ser observado por alunos e professores SinalObservado sinal = new SinalObservado(); // Ao instanciar alunos e professores, passamos // o objeto sinal para que cada um fique de "olho" Aluno jose = new Aluno(sinal,"Jos"); Aluno pedro = new Aluno(sinal,"Pedro"); Aluno maria = new Aluno(sinal,"Maria"); Professor carlos = new Professor(sinal,"Carlos","Fsica"); sinal.botaoTocaSinal(); System.out.println( "\n*** O professor e o Jos sero retirados da lista. ***\n"); sinal.removePessoa(jose); sinal.removePessoa(carlos); sinal.botaoTocaSinal(); }
Imprime: Jos, o intervalo est iniciando! Pedro, o intervalo est iniciando! Maria, o intervalo est iniciando! Professor Carlos (Fsica), o intervalo est iniciando *** O professor e o Jos sero retirados da lista. *** Pedro, o intervalo est terminando! Maria, o intervalo est terminando!
Observe que as primeiras quatro sadas comprovam que os alunos Jos, Pedro, Maria e o professor Carlos foram alertados do sinal da campainha. Na linha 11, a chamada sinal.botaoTocaSinal() foi a ao de tocar a campainha que prontamente foi recebida pelos alunos e pelo professor que so os objetos observadores existentes na lista de objetos da classe SinalObservado. Nas linhas 14 e 15 retiramos da lista de objetos dois observadores: o aluno Jos e o professor Carlos. Em seguida, na linha 16, a campainha novamente acionada e os observadores ainda ativos (Pedro e Maria) recebem novamente o comunicado de que ocorreu novo toque no sinal e que o intervalo terminou. O padro Observer utilizando o pacote java.util.Observable O padro Observer foi incorporado ao pacote java.util a partir do Java 5. O programador pode usar a classe Observable e a interface Observer facilitando bastante o seu uso. A seguir examine o mesmo exemplo utilizando a classe Observable e a interface Observer: A Classe Aluno:
1. public class Aluno implements Observer { 2. private SinalObservado sinal; 3. private String nome; 4. public Aluno(SinalObservado sinal, String _nome){ 5. this.nome = _nome; 6. this.sinal = sinal; 7. // O aluno que acabou de ser instanciado passado para o objeto 8. // Sinal para que ele possa ser notificado quando o sinal tocar (true) 9. // ou calar (false). 10. this.sinal.addObserver(this); 11. } 12. public void update(Observable o, Object arg) { 13. if(o == this.sinal) { 14. System.out.println(this.nome + ", o intervalo est " + 15. (this.sinal.getEstadoCampainha()?"iniciando":"terminando")+"!"); 16. } 17. } 18. }
A Classe Professor:
1. public class Professor implements Observer { 2. 3. private SinalObservado sinal; 4. private String nome; 5. private String disciplina; 6. 7. public Professor(SinalObservado _sinal, String _nome, String _disciplina){ 8. this.nome = _nome; 9. this.disciplina = _disciplina; 10. this.sinal = _sinal; 11. this.sinal.addObserver(this); 12. } 13. public void update(Observable o, Object arg) { 14. if(o == this.sinal) { 15. System.out.println("Professor " + this.nome + " (" + 16. this.disciplina + "), o intervalo est " + 17. (this.sinal.getEstadoCampainha() ? "iniciando!":"terminando!")); 18. } 19. } 20. }
A classe SinalObservado
1. public class SinalObservado extends Observable { 2. 3. private boolean intervalo = false; 4. 5. public void botaoTocaSinal() { 6. this.intervalo = !this.intervalo; 7. this.setChanged(); 8. this.notifyObservers() ; 9. } 10. public boolean getEstadoCampainha(){ 11. return this.intervalo; 12. } 13. }
A classe TesteObserver e a sada do programa no sofre nenhuma alterao!

1. public class TesteObserver { 2. 3. public static void main(String[] args) { 4. 5. // O Sinal da escola ser observado por alunos e professores 6. SinalObservado sinal = new SinalObservado(); 7. 8. // Ao instanciar alunos e professores, passamos 9. // o objeto sinal para que cada um fique de "olho" 10. 11. Aluno jose = new Aluno(sinal,"Jos"); 12. Aluno pedro = new Aluno(sinal,"Pedro"); 13. Aluno maria = new Aluno(sinal,"Maria"); 14. 15. Professor carlos = new Professor(sinal,"Carlos","Fsica"); 16. sinal.botaoTocaSinal(); // Tocando o sinal... 17. 18. System.out.println( 19. "\n*** O professor e o Jos sero retirados da lista. ***\n"); 20. 21. sinal.removePessoa(jose); // Retira o aluno da lista 22. sinal.removePessoa(carlos); // Retira o professor da lista 23. sinal.botaoTocaSinal(); // Tocando o sinal novamente... 24. } 25. }
Imprime: Jos, o intervalo est iniciando! Pedro, o intervalo est iniciando! Maria, o intervalo est iniciando! Professor Carlos (Fsica), o intervalo est iniciando! *** O professor e o Jos sero retirados da lista. *** Pedro, o intervalo est terminando! Maria, o intervalo est terminando!
MVC - Model View Controller A arquitetura utilizada no desenvolvimento dos sistemas tem evoludo no sentido de garantir algumas caractersticas fundamentais. Com a experincia dos anos de desenvolvimento, percebemos que um produto de software est em constante evoluo e durante sua vida til sofre um significativo volume de manutenes tanto corretivas como evolutivas. A maior ou menor dificuldade (custo) da realizao dessas manutenes est intimamente relacionada com o estilo da arquitetura adotada para a construo do projeto. A idia bsica que quanto menor for o impacto causado pela interveno, tanto mais eficiente, segura, rpida e barata ela ser. Uma forma de diminuir o efeito do excessivo acoplamento e baixa coeso a separao do projeto em mdulos distintos e providenciar interfaces para que eles se comuniquem eficientemente entre si. O paro MVC procura separar claramente o projeto em trs grandes mdulos que analisamos a seguir:
Model (Modelo) Representa o domnio dos dados: Armazenamento, consulta, alterao, insero e alterao nos dados utilizando qualquer tecnologia de persistncia como SGBD's, XML, serializao, arquivos texto etc.
View (Viso) Interface com o usurio: Meio pelo qual os atores interagem com os sistemas. Podem ser mdulos HTML, CSS, JSP, ASP, PHP, consoles de sistemas e telas grficas. Sadas impressas tambm so consideradas como camada View.
Controller (Controle) Responsvel pelo tratamento das regras de negcio, validaes etc.
Vantagens do modelo MVC: mais fcil manter, testar e atualizar sistemas complexos; Facilidade para incluir novos clientes; Torna a aplicao mais escalvel; Facilita o desenvolvimento porque equipes diferentes podem trabalham em suas camadas de forma independente.
Desvantagens do modelo MVC: A anlise mais demorada e trabalhosa; A equipe de desenvolvimento deve receber treinamento especial; Para sistemas de pequeno porte encarece o desenvolvimento e pode no trazer benefcios na mesma proporo.
Nota: No vamos desenvolver um exemplo prtico porque, como vimos, no faz muito sentido utilizar arquitetura MVC em pequenos projetos e, um exemplo por definio um micro sistema.
Java Reflection API A tecnologia Java desdo incio (Verso 1.1), procurou oferecer recursos e funcionalidades nunca vistos em outras linguagens ou tecnologias de desenvolvimento e, uma das mais surpreendentes do Java, o que conhecemos por Reflection. A Reflection possibilita que um programa Java examine a si mesmo ou seja, permite que o programador tenha acesso a suas propriedades e estrutura. Usando Reflection podemos obter o nome de todos os membros de uma classe, bem como executar um mtodo qualquer utilizando a Introspection. desta forma que aplicativos como as IDE's de desenvolvimento, por exemplo, conseguem examinar e exibir a estrutura e contedo das classes. Nosso primeiro exemplo lista as propriedades e mtodo de uma classe que fizemos para exemplo do item: Classes e mtodos genricos
1. public class Reflection { 2. public static void main(String args[]) { 3. try { 4. Class c = Class.forName("fontes.Calcula"); 5. Method method[] = c.getDeclaredMethods(); 6. System.out.println("\nTodos os mtodos da classe:\n"); 7. for (Method m : method) System.out.println(m.toString()); 8. Method superMethod[] = c.getMethods(); 9. System.out.println 10. ("\nTodos os mtodos da hierarquia (pblicos e protegidos):\n"); 11. for (Method m : superMethod) System.out.println(m.toString()); 12. Field field[] = c.getDeclaredFields(); 13. System.out.println("\nAtributos:\n"); 14. for (Field f : field) System.out.println(f.toString()); 15. } 16. catch (Throwable e) { 17. System.err.println(e); 18. } 19. } 20. }
Imprime:
Todos os mtodos da classe: private double fontes.Calcula.soma(java.lang.Number) public double fontes.Calcula.multiplica(java.lang.Number) public double fontes.Calcula.divide(java.lang.Number) public double fontes.Calcula.subtrai(java.lang.Number) Todos os mtodos da hierarquia (apenas os pblicos e protegidos): public public public public public public public public public public public public double fontes.Calcula.multiplica(java.lang.Number) double fontes.Calcula.divide(java.lang.Number) double fontes.Calcula.subtrai(java.lang.Number) native int java.lang.Object.hashCode() final native java.lang.Class java.lang.Object.getClass() final void java.lang.Object.wait(long,int) throws ... final void java.lang.Object.wait() throws ... final native void java.lang.Object.wait(long) throws ... boolean java.lang.Object.equals(java.lang.Object) java.lang.String java.lang.Object.toString() final native void java.lang.Object.notify() final native void java.lang.Object.notifyAll()
Atributos: private java.lang.Number fontes.Calcula.parcela
Com este cdigo acessamos os metadados da classe Calcula, mostrando as listas das assinaturas dos seus mtodos e propriedades. Foi possvel acessar a classe por intermdio do mtodo esttico da classe Class, Class.forName() (linha 4) e ento, chamando os mtodos getDeclaredMethods() (linha 5) e getDeclaredFields() (linha 12) obtivemos as listas dos mtodos e propriedades da classe. Finalmente com o mtodo getMethods() (linha 8), extramos (novamente) a lista de todos os mtodos pblicos ou protegidos da classe Calcula e ainda os mtodos das superclasses (no caso a super classe Object que super classe de qualquer classe Java). Comparando tipos sem usar instanceof Usando Reflection possvel verificar se um objeto instncia de uma determinada classe de uma maneira diferente da tradicional, ou seja, sem usar instanceof. Exemplo:
1. public static void main(String args[]) { 2. try { 3. Class cls = Class.forName("fontes.Calcula"); 4. Integer a = new Integer("10"); 5. Calcula<Integer> b = new Calcula<Integer>(a); 6. boolean b1 = cls.isInstance(a); 7. System.out.println(b1); 8. boolean b2 = cls.isInstance(b); 9. System.out.println(b2); 10. } 11. catch (Throwable e) { 12. System.err.println(e); 13. } 14. }
Imprime: false true Destrinchando a classe O prximo exemplo destrincha a prpria classe exemplo.
1. public class QualquerClasse { 2. 3. public int qualquerMetodo(Object obj, String valor) throws 4. NullPointerException, NumberFormatException { 5. if (obj == null) throw new NullPointerException(); 6. System.out.println("Nome da classe:" + obj.getClass().getSimpleName()); 7. return Integer.parseInt(valor); 8. } 9. public static void main(String args[]) { 10. try { 11. Class cls = Class.forName("exe.QualquerClasse"); 12. Method listaMetodos[] = cls.getDeclaredMethods(); 13. System.out.println("Lista dos mtodos da classe:\n"); 14. for (Method m : listaMetodos) { 15. System.out.println("\tNome:\t\t\t" + m.getName()); 16. System.out.println("\tMembro da classe:\t" + 17. m.getDeclaringClass()); 18. System.out.println("\tModificador:\t\t" + 19. Modifier.toString(m.getModifiers())+"\n"); 20. 21. Class listaParametros[] = m.getParameterTypes(); 22. System.out.println("\tLista dos parmetros do mtodo:\n");
23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42.
} } catch (Throwable e) { System.err.println(e); }
for (int i = 0; i < listaParametros.length; i++) System.out.println("\t\tParmetro " + i + ": "+ listaParametros[i].getSimpleName()); System.out.println("\n\tLista das excees do mtodo:\n"); Class listaExcecoes[] = m.getExceptionTypes(); for (int i = 0; i < listaExcecoes.length; i++) System.out.println("\t\tExceo "+ i +": " + listaExcecoes[i].getSimpleName()); System.out.println("\n\tTipo de retorno do mtodo: " + m.getReturnType()); System.out.println("\n\t--- Fim do mtodo: '"+m.getName() + "' --\n");
Imprime: Lista dos mtodos da classe: Nome: Membro da classe: Modificador: main class exe.QualquerClasse public static
Lista dos parmetros do mtodo: Parmetro 0: String[] Lista das excees do mtodo: Tipo de retorno do mtodo: void --- Fim do mtodo: 'main' -Nome: Membro da classe: Modificador: qualquerMetodo class exe.QualquerClasse public
Lista dos parmetros do mtodo: Parmetro 0: Object Parmetro 1: String Lista das excees do mtodo: Exceo 0: NullPointerException Exceo 1: NumberFormatException Tipo de retorno do mtodo: int --- Fim do mtodo: 'qualquerMetodo' --
Explorando os Construtores O construtor no um mtodo comum e, por isso, merece um tratamento especial do Reflection. Obtendo informaes a respeito dos construtores da classe analisada: Exemplo:
1.
package exe;
2. public class ExplorandoConstrutores { 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. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. public ExplorandoConstrutores() throws NumberFormatException, NullPointerException {/**/} // Construtor vazio protected ExplorandoConstrutores(int i, double d) throws Exception {/**/} // Argumentos primitivos private ExplorandoConstrutores(Object o, Integer i) throws NumberFormatException, NullPointerException {/**/} // Argumentos referncia public static void main(String args[]) { try { Class classe = Class.forName("exe.ExplorandoConstrutores"); Constructor listaConstrutores[] = classe.getDeclaredConstructors(); System.out.println("Lista dos construtores da classe: " + classe.getSimpleName() + "\n"); for (Constructor ct : listaConstrutores) { System.out.println("\tNome construtor:\t" + ct.getName()); System.out.println("\tMembro da classe:\t"+ ct.getDeclaringClass()); System.out.println("\tModificador:\t\t" + Modifier.toString(ct.getModifiers())+"\n"); Class listaParametros[] = ct.getParameterTypes(); System.out.println("\n\tParmetros: " + listaParametros.length + "\n"); for (int i = 0; i < listaParametros.length; i++) System.out.println("\t\tParmetro " + (i+1) + ": " + listaParametros[i]); Class listaExcecoes[] = ct.getExceptionTypes(); System.out.println("\n\tExcees: " + listaExcecoes.length+ "\n"); for (int i = 0; i < listaExcecoes.length; i++) System.out.println("\t\tExceo "+(i+1)+": "+ listaExcecoes[i]); System.out.println("\n\tFim do construtor: " + ct.getName() + "\n");
} } catch (Throwable e) { System.err.println(e);
Imprime: Lista dos construtores da classe: ExplorandoConstrutores Nome construtor: Membro da classe: Modificador: Parmetros: 0 Excees: 2 Exceo 1: NumberFormatException Exceo 2: NullPointerException Fim do construtor: exe.ExplorandoConstrutores Nome construtor: Membro da classe: Modificador: Parmetros: 2 Parmetro 1: int Parmetro 2: double Excees: 1 Exceo 1: Exception Fim do construtor: exe.ExplorandoConstrutores Nome construtor: Membro da classe: Modificador: Parmetros: 2 Parmetro 1: Object Parmetro 2: Integer Excees: 2 Exceo 1: NumberFormatException Exceo 2: NullPointerException Fim do construtor: exe.ExplorandoConstrutores exe.ExplorandoConstrutores class exe.ExplorandoConstrutores private exe.ExplorandoConstrutores class exe.ExplorandoConstrutores protected exe.ExplorandoConstrutores class exe.ExplorandoConstrutores public
Explorando os atributos de uma classe Outra aplicao muito interessante de Reflection a possibilidade de obter os dados e informaes sobre os atributos membros da classe tais como: modificadores; tipo e o nome. Exemplo:
1. package exe; 2. 3. public class TesteAtributos { 4. 5. private double var; 6. 7. public static final int total = 37; 8. private String str = "testing"; 9. protected Integer num = new Integer(10); 10. 11. public static void main(String args[]) { 12. try { 13. Class cls = Class.forName("exe.TesteAtributos"); 14. for (Field fld : cls.getDeclaredFields()) { 15. System.out.println("\n\tNome atributo: "+fld.getName()); 16. System.out.println("\t\tMembro da classe: " 17. +fld.getDeclaringClass()); 18. System.out.println("\t\tTipo: " 19. +fld.getType().getSimpleName()); 20. int mod = fld.getModifiers(); 21. System.out.println("\t\tModificadores: " 22. +Modifier.toString(mod)); 23. } 24. } 25. catch (Throwable e) { 26. System.err.println(e); 27. } 28. } 29. }
Imprime: Nome atributo: var Membro da classe: class exe.TesteAtributos Tipo: double Modificadores: private Nome atributo: total Membro da classe: class exe.TesteAtributos Tipo: int Modificadores: public static final Nome atributo: str Membro da classe: class exe.TesteAtributos Tipo: String Modificadores: private Nome atributo: num Membro da classe: class exe.TesteAtributos Tipo: Integer Modificadores: protected
Invocando mtodos pelo nome Agora vamos um pouco mais fundo. Usando Reflection, vamos invocar um mtodo de uma classe pelo seu nome. Examine o exemplo:
1. package exe; 2. public class InvocaMetodo { 3. public double calcula(char operacao, double a, double b) 4. throws IllegalArgumentException { 5. switch (operacao) { 6. case '+': return a + b; 7. case '*': return a * b; 8. case '/': return a / b; 9. case '-': return a - b; 10. default: throw new IllegalArgumentException("Operao invlida!"); 11. } 12. } 13. public static void main(String args[]) { 14. try { 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. } Class<?> cls = Class.forName("exe.InvocaMetodo"); Class<?> tiposArgumentos[] = {Character.TYPE, Double.TYPE, Double.TYPE }; // Buscando o mtodo pelo nome Method metodoCalcula = cls.getMethod("calcula", tiposArgumentos); // Preparando 3 operaes para teste. Object listaArgumentosSoma[] = { '+', 15.51, 14.50 }; Object listaArgumentosProduto[]= { '*', 12.10, 50.34 }; Object listaArgumentosDivide[] = { '/', 1, 0 }; // Instancia um objeto da classe. InvocaMetodo instancia = new InvocaMetodo(); //Invoca o mtodo calcula passando a instncia e a lista de argumentos Double retorno = (Double) metodoCalcula.invoke(instancia, listaArgumentosSoma); System.out.printf("Adio: %10.2f\n", retorno.doubleValue()); retorno = (Double) metodoCalcula.invoke(instancia, listaArgumentosProduto); System.out.printf("Produto: %10.2f\n", retorno.doubleValue()); retorno = (Double) metodoCalcula.invoke(instancia, listaArgumentosDivide); System.out.printf("Relao: %10.2f\n", retorno.doubleValue()); } catch (Throwable e) { System.err.println(e); } }
Imprime: Adio: Produto: Relao: 30,01 609,11 Infinity
Instanciando novos objetos A partir de um dado um objeto da classe Class precisarmos de uma instncia dessa classe. Para conseguir isso, invocando os construtores de uma classe com os parmetros desejados. As possibilidades so imensas! Veja o exemplo:
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. 32. 33. package exe; import java.lang.reflect.*; public class InstanciandoObjetos { public InstanciandoObjetos() { // Construtor vazio; } public InstanciandoObjetos(int mostraDados(a,b); } public void mostraDados(int a, System.out.printf("Valor de } public static void main(String
a, int b) { int b) { A: %d, valor de B: %d\n",a,b); args[]) {
try { Class classe = Class.forName("exe.InstanciandoObjetos"); Class tiposParametros[] = { Integer.TYPE, Integer.TYPE }; // Construtor com parmetros Constructor ct1 = classe.getConstructor(tiposParametros); Object listaArgumentos [] = {new Integer(10), new Integer(20)}; InstanciandoObjetos obj1 = (InstanciandoObjetos) ct1.newInstance(listaArgumentos); obj1.mostraDados(30, 40); // Construtor sem parmetros Constructor ct2 = classe.getConstructor(); InstanciandoObjetos obj2 = (InstanciandoObjetos) ct2.newInstance(); obj2.mostraDados(50, 60);
} catch (Throwable e) { System.err.println(e); } } }
Imprime: Valor de A: 10, valor de B: 20 Valor de A: 30, valor de B: 40 Valor de A: 50, valor de B: 60 Na linha 15 capturamos a classe. Na linha 18 pegamos a referncia do construtor com argumentos. Nas linhas 20 e 21 instanciamos um objeto da classe InstanciandoObjetos. O construtor executado e a primeira sada impressa com os valores 10 e 20. A linha 22 chama o mtodo mostraDados() e a segunda sada impressa com os valores 30 e 40. As linhas 25 e 26 instanciam um novo objeto utilizando o construtor sem argumentos (linha 4) e na linha 27 a terceira sada impressa com os nmeros 50 e 60.
Alterando atributos de uma classe O exemplo a seguir mostra como possvel alterar o valor do atributo de uma classe utilizando Reflection.
1. 2. 3. 4. 5. 6. 7. 8. 9. package exe; import java.lang.reflect.*; public class AlteraAtributo { public double var = 100.; public static void main(String args[]) { try { Class cls = Class.forName("exe.AlteraAtributo"); Field fld = cls.getField("var"); AlteraAtributo obj = new AlteraAtributo();
10. System.out.println("Valor de var antes = " + obj.var); 11. fld.setDouble(obj, 200); // Alterando o atributo var 12. System.out.println("valor de var depois = " + obj.var); 13. } 14. catch (Throwable e) { 15. System.err.println(e); 16. } 17. } 18. }
Imprime: Valor de var antes = 100.0 Valor de var depois = 200.0 Uma outra verso da mesma classe usando um pouco mais de Reflection.
14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. package exe; import java.lang.reflect.*; public class AlteraAtributo { public double var = 100.; public static void main(String args[]) { try { Class<?> cls = Class.forName("exe.AlteraAtributo"); Field fld = cls.getField("var"); Constructor<?> ct = cls.getConstructor(); AlteraAtributo obj = (AlteraAtributo) ct.newInstance() ; System.out.println("var antes = " + obj.var); fld.setDouble(obj, 200); System.out.println("var depois = " + obj.var); } catch (Throwable e) { System.err.println(e); }
Testando uma aplicao usando o framework JUnit com Eclipse O desenvolvimento de um grande projeto um desafio de garantia de qualidade. O problema de testar e retestar uma aplicao inteira gigantesco e quem j vivenciou o problema sabe bem do que eu estou falando. Depois de exaustivos testes de uma determinada funcionalidade, temos vontade de congelar o mdulo e proibir qualquer maluco de fazer qualquer tipo de interveno. A idia parece boa de incio mas logo se mostra impraticvel e mais breve do que se imaginava temos que ir l e fazer alguma manuteno. L vamos ns novamente repetir todos os testes. Muitas vezes o receio de fazer alguma refatorao acaba engessando a aplicao de tal forma que isso pode causar o final da vida do sistema muito antes do que se previa. O captulo de testes na literatura de engenharia de software ganha cada dia mais importncia e os testes que antes eram feitos de forma emprica, hoje so motivo de estudo e desenvolvimento de ferramentas especficas. Voc deve estar se perguntando se vale a pena escrever um cdigo para testar outro? Na prtica, se voc j um programador com alguma experincia, vai concordar que costumamos escrever pequenos programinhas que fazem os testes iniciais das funcionalidades que consideramos crticas e assim que achamos que ele j cumpriu sua misso ns o descartamos sem muita cerimnia sem nos preocupar se este programinha poder ser til novamente algum dia. O uso de uma ferramenta de testes do estilo do JUnit permite que os programinhas sejam organizados, passados e repassados quantas vezes for necessrio. O JUnit um framework open-source, desenvolvido pela dupla Eric Gamma e Kent Bec com a finalidade de facilitar a vida de quem quer fazer testes automatizados com praticidade e comodidade. Nosso exemplo foi desenvolvido utilizando o Eclipse que possui algumas facilidades para se ajustar ao framework com o mnimo de esforo. Antes de iniciar o trabalho com o JUnit voc deve acrescentar no Java Build Path do seu projeto Eclipse a biblioteca do framework. Abaixe o jar do JUnit no endereo http://www.junit.org. O nome do arquivo que voc vai encontrar deve ser jjunit-4.8.1.jar (ou mais recente se estiver disponvel). Configurando o Eclipse Selecione Properties do seu projeto
Fonte: http://junit.wikidot.com/ Salve o jjunit-4.8.1.jar abaixado de preferncia no workspace do seu projeto. Depois use o boto Add External JARs (veja figura a seguir), carregue o aquivo e confirme.
Fonte: http://junit.wikidot.com/ Agora que o Eclipse est preparado para rodar com o JUnit, vamos escrever nossa classe de teste. A classe de testes deve estender a superclasse TestCase e implementar a interface Test. A superclasse TestCase nos disponibiliza os mtodos que vamos utilizar nos testes. Ao longo de nossos estudos escrevemos alumas classes Quadrado... e outras tantas Circulo. Nosso exemplo um sisteminha composto por uma superclasse abstrata Figuras e duas classes concretas estendidas Quadrado e Circulo desenvolvidos como exemplo no item Listas e Colees / Ordenando arrays. O programa de testes consiste para cada classe a ser testada, na construo de vrios mtodos que convencionamos iniciar com a palavra test e terminar pelo nome do mtodo que est sendo testado. Por exemplo, se a assinatura do mtodo original for: float calculaArea(float lado) a assinatura do mtodo de teste seria: void testCalculaArea( ). Como visto, sempre um mtodo sem argumentos e sem retorno. Estes mtodos so encontrados e executados pelo framework por intermdio do uso de Reflection (veja apndice sobre Reflection neste material). Como JUnit um framework, ele no precisa ser chamado diretamente via um mtodo main escrito pelo cliente. O Eclipse, se estiver preparado para operar com JUnit, possui alguns recursos para facilitar nossa vida. No assistente: Arquivo->New->Other, selecione a opo Junit TestCase e monte o esqueleto da classe de testes.
E, ao clicar em Next...
No mtodo setUp() que automaticamente chamado pelo framework no incio do teste, declare os objetos para serem testados. No mtodo tearDown(), tambm chamado automaticamente, neutralize as referncias para que a memria utilizada no teste sejam rapidamente liberadas. Na caixa de dilogo do Run...
Quando o teste for inicializado o framework ir inicialmente rodar o mtodo construtor, depois o setUp() e em seguida todos os mtodos escritos pelo cliente e por ltimo o mtodo tearDown(). O H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 215
resultado do teste um relatrio hierrquico mostrando as falhas encontradas. O Eclipse abre uma nova aba especialmente para as sadas do JUnit. Nossa classe de teste de JUnit
1. package 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.
testes;
public class Teste extends TestCase implements Test { Quadrado q1, q2, q3; Circulo c1, c2, c3; @Override @Before protected void setUp() { // Teste das casses estendidas de Figuras q1 = new Quadrado(1,"Q1"); q2 = new Quadrado(2,"Q2"); q3 = new Quadrado(1,"Q3");
12. c1 = new Circulo(1,"C1"); 13. c2 = new Circulo(2,"C2"); 14. c3 = new Circulo(1,"C3"); 15. } 16. @Override 17. @After 18. protected void tearDown() { 19. q1 = q2 = q3 = null; 20. c1 = c2 = c3 = null; 21. } 22. public void testeGetArea() { 23. assertTrue("reas quadrado devem ser iguais.",q1.getArea()==1); 24. assertTrue("reas circulo devem ser iguais.",c1.getArea()==Math.PI); 25. } 26. public void testeCompareTo() { 27. assertTrue("Os crculos devem ser iguais.",c1.compareTo(c3)==0); 28. assertTrue("Os quadrados devem ser iguais.",q1.compareTo(q3)==0); 29. 30. assertTrue("O segundo quadrado deve ser maior.",q2.compareTo(q1)==1); 31. assertTrue("O segundo crculo deve ser maior.",c2.compareTo(c1)==1); 32. 33. assertTrue("O primeiro quadrado deve ser maior.",q1.compareTo(q2)==-1); 34. assertTrue("O primeiro crculo deve ser maior.",c1.compareTo(c2)==-1); 35. } 36. }
Abaixo, a barra verde indica que todos os testes resultaram em sucesso.
Forando erros Para verificar se os testes esto funcionando, vamos provocar alguns erros nas chamadas assert e com isso checar o funcionamento do teste. -------22. public void testeGetArea() { 23. assertTrue("reas quadrado devem ser iguais.",q1.getArea()!=1); 24. assertTrue("reas circulo devem ser iguais.",c1.getArea()==Math.PI); 25. } 26. public void testeCompareTo() { 27. assertTrue("Os crculos devem ser iguais.",c1.compareTo(c3) < 0); 28. assertTrue("Os quadrados devem ser iguais.",q1.compareTo(q3)==0); 29. 30. assertTrue("O segundo quadrado deve ser maior.",q2.compareTo(q1)==1); 31. assertTrue("O segundo crculo deve ser maior.",c2.compareTo(c1)==1); 32. 33. assertTrue("O primeiro quadrado deve ser maior.",q1.compareTo(q2)==-1); 34. assertTrue("O primeiro crculo deve ser maior.",c1.compareTo(c2)== 1); 35. } 36. }
Alteraes feitas (Plantando erros):

Na linha 23 vamos alterar de ==1 para != 1 Na linha 27 de == 0 para < 0 Na linha 34 de == -1 para == 1
Resultado:
A barra marrom indica que alguma coisa no funcionou como esperado. O cliente confere a descrio do(s) erro(s) encontrado(s) em cada mtodo na janela a direita.
JNI Java Native Interface JNI uma interface padro que permite que o programador incorpore cdigo nativo a seus sistemas Java e a sua principal aplicao o aproveitamento de bibliotecas nativas desenvolvidas para rodar em plataformas especficas. Naturalmente, o uso de JNI, condena a aplicao a rodar apenas na plataforma para a qual o cdigo nativo foi desenvolvido e, claro, voc estar abrindo mo da portabilidade. JNI existe j faz tempo e faz parte da plataforma Java desde o release JDK 1.1 Algumas situaes onde o JNI se aplica:

A biblioteca padro Java no suporta algum recurso especfico da plataforma em uso. O sistema precisa aproveitar bibliotecas prontas e desenvolvidas em outras linguagens. Existe uma parte do cdigo crtica que precisa ser desenvolvida em linguagem de muito baixo nvel como Assembly por exemplo.
O uso de JNI no apenas uma chamada a um mtodo nativo no estilo do uso de DLL's prontas como comum no desenvolvimento de sistemas para plataforma Intel/Windows. Objetos, arrays e matrizes podem ser criados no cdigo nativo, assim como tambm podem utilizar objetos criados no Java. Nosso exemplo ser um programa java que recebe como argumento, pela linha de comando, o nome de um arquivo texto e um caracter. O programa abre o arquivo texto e conta quantos caracteres idnticos ao passado existem no arquivo e depois mostra este nmero na console. A funo que vai fazer a contagem de caracteres ser desenvolvida em C++; No vamos poder contar muito com a ajuda do Eclipse desta vez, vamos precisar utilizar o compilador javac e o utilitrio javah (fornecido pelo JDK) diretamente via console para compilar o programa e criar o arquivo de header que teremos que usar. Naturalmente, o programa C++ deve ser compilado por um compilador compatvel com o sistema operacional e o processador que estamos usando, no caso Windows/Intel. O primeiro passo escrever o programa java:
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. public class TesteJni { // Assinatura do mtodo que ser escrito em C++ public static native int contaCaracteres(String arquivoParaProcurar, String caracterParaProcurar); static { // Carga da DLL criada a partir do cdigo C++ que voc escreveu System.loadLibrary("contcara"); } public static void main(String[] args) { // Verifica se os dados da linha de comando so coerentes if (args.length != 2 || args[1].length() != 1) { System.out.println("Contador de caracter selecionado de arquivos\n"); System.out.println("Use na linha de comando:"); System.out.println("C:>\\Java TesteJni arquivo.txt #\n"); return; } // Chamada do mtodo C++ passando dois strings java como argumento. int c = TesteJni.contaCaracteres(args[0],args[1]); System.out.println("Quantidade de caracteres: " + c); } }
Note que na linha 3 escrevemos a assinatura do mtodo que ser escrito em C++. Neste nosso exemplo, escrevemos apenas uma funo, contaCaracteres(), mas poderamos criar uma verdadeira biblioteca desde que todas tenham suas assinaturas declaradas. Veja que usamos a palavra reservada native para indicar que seu cdigo fonte est em uma linguagem nativa (no java). A linha 7, dentro de um bloco static, realiza a carga a biblioteca, ou seja, seu cdigo fonte em C++ compilado para uma DLL.
Agora vamos compilar nosso fonte java para um .class utilizando o compilador javac. Seu fonte TesteJni.java, deve estar na pasta em que voc vai fazer os testes. Se compilar sem erros, rode em seguida o javah como ilustrado na figura abaixo, para obter o TesteJni.h que ser usado como um include no cdigo C++ que faremos a seguir. Observe que, para que o compilador seja encontrado, necessrio que o caminho do JDK esteja definido nas variveis de ambiente do Windows.
Muito bem, agora vamos abrir o arquivo criado pelo javah, TesteJni.h, para saber como a assinatura do mtodo contaCaracteres() ser implementada no programa em C++. Esta pode ser considerada a pegadinha do JNI. Para cada plataforma, existe um padro para chamadas de bibliotecas nativas. No caso do Windows fazemos isso por intermdio de DLL's em que suas funcionalidades possuem argumentos e retornos tipados de forma padronizada para que todas as aplicaes possam acess-las da mesma forma. O arquivo TesteJni.h na ntegra:
1. /* DO NOT EDIT THIS FILE - it is machine generated */ 2. #include <jni.h> 3. /* Header for class TesteJni */ 4. 5. #ifndef _Included_TesteJni 6. #define _Included_TesteJni 7. #ifdef __cplusplus 8. extern "C" { 9. #endif 10. /* 11. * Class: TesteJni 12. * Method: contaCaracteres 13. * Signature: (Ljava/lang/String;)I 14. */ 15. JNIEXPORT jint JNICALL Java_TesteJni_contaCaracteres 16. (JNIEnv *, jclass, jstring, jstring); 17. 18. #ifdef __cplusplus 19. } 20. #endif 21. #endif
As linha 15 e sua continuao na linha 16, exatamente a assinatura que deve ser utilizada no fonte C++ que vamos programar. Note que existem quatro argumentos: O primeiro e o segundo so argumentos padro e permitem a passagem do ambiente da aplicao. O terceiro e o quarto so os argumentos String que sero passados. Note que os tipos no so ponteiros do tipo char mas tipos jstring, ou seja, String de java.
Vamos escrever nosso contaCaracteres() em mtodo em C++ (Nome: CONTCARA.CPP):

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. 32. 33. } // headers para o JNI #include "testeJni.h" // Criado pelo utilitrio javah #include "jni.h" // Disponvel no pacote JDK (Pasta include) // headers para IO de console #include "stdio.h" #include "conio.h" #include "stdlib.h" #include "io.h" // headers de sistema #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> // Assinatura copiada do arquivo testeJni.h JNIEXPORT jint JNICALL Java_TesteJni_contaCaracteres (JNIEnv *env, jclass, jstring nome, jstring caracter) { // Convertendo para char* os jstring recebidos. const char *str = env->GetStringUTFChars(nome, 0); const char *car = env->GetStringUTFChars(caracter, 0); FILE *arq = NULL; // Abrindo o arquivo 'nome' para leitura fopen_s(&arq,str,"rb"); int cont = 0; int carac = fgetc(arq); // Lendo um por um os caracteres do arquivo aberto. while (!feof(arq)) { // Se o caracter lido for igual ao caracter passado como argumento. if (carac == *car) cont++; // L o prximo caracter.. carac = fgetc(arq); } fclose(arq); // Fechando o arquivo return cont; // Retornando a quantidade de caracteres contados.
Veja que, tirando a assinatura diferente (linha 14 e 15) e a extrao dos ponteiros char dos jstring recebidos (linhas 17 e 18), o restante um cdigo C++ comum, podendo utilizar qualquer recurso como: ponteiros; alocao dinmica; acesso a disco ou qualquer outra coisa vlida em C++. Claro que aqui no podemos contar com as validaes de segurana, Garbage Collector e outros confortos do java. O programador deve desdobrar os cuidados com o gerenciamento de memria, uso de arrays, ponteiros e tudo que possa provocar erros em tempo de execuo que sabemos no serem tratados pelo C++. No caso da plataforma Windows/Intel, a coisa fica ainda mais perigosa porque as DLL's podem acessar a memria diretamente contornando o controle de acesso a endereos protegidos. Para mais detalhes pesquise IDS (Import Data Section). Continuando, precisamos agora gerar nossa DLL. Para isso usaremos o utilitrio Microsoft criado exatamente para esta finalidade chamado cl.exe. Naturalmente, para que seja possvel seu uso, o caminho tambm deve ser encontrado na path do windows. A sintaxe da chamada deve passar o caminho dos headers do C++. veja abaixo a chamada completa que foi utilizada no exemplo. Repare que foram passados 3 caminhos de headers (-I ) e no final o comando para compilar o fonte CPP (-LD contcara.cpp):
CL -I "C:\Arquivos de programas\Microsoft Visual Studio 8\VC\include" -I "C:\Arquivos de programas\Java\jdk1.5.0_06\include" -I "C:\Arquivos de programas\Java\jdk1.5.0_06\include\win32" -LD contcara.cpp
No seu caso particular, ajuste os caminhos para a sua realidade. Se a sintaxe do seu programa C++ estiver correta, os caminhos dos arquivos de headers estiverem completos e os caminhos das H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 220
bibliotecas necessrias estiverem nos paths do Windows, o resultado deve se aproximar do obtido na figura a seguir:
Confira se o arquivo contcara.dll foi criado realmente:
Agora s nos resta verificar se a nossa classe TesteJni.class est funcionando corretamente. Na sequencia, vamos contar quantos '#' existem no prprio fonte C++: CONTCARA.CPP
Verificando o desempenho do JNI com IO Uma da razes alegadas para o uso do JNI tentar melhorar o desempenho da aplicao. Mas isso nem sempre se aplica. O principal motivo que o esforo computacional para que uma funo externa seja invocada grande e quase sempre anula alguma vantagem que poderia ser conseguida com uso de uma linguagem considerada mais rpida. Para verificar se existe ou no vantagem em usar C++ no lugar de Java, vamos executar o mesmo servio utilizando a API java de manipulao de arquivos texto usando um arquivo bastante grande, com mais que 70MB, e comparar os tempos na contagem de caracteres em Java e em C++.
O mesmo fonte java modificado para executar o servio de contagem em Java, C++ e medir os tempos gastos: Nosso TesteJni.java modificado:
1. public class TesteJni { 2. 3. public static native int contaCaracteres(String arquivoParaProcurar, 4. String caracterParaProcurar); 5. static { 6. System.loadLibrary("contcara"); 7. } 8. public static void main(String[] args) { 9. if (args.length != 2 || args[1].length() != 1) { 10. System.out.println("Contador de caracter selecionado\n"); 11. System.out.println("Use na linha de comando:"); 12. System.out.println("C:>\\Java TesteJni arquivo.txt #\n"); 13. return; 14. } 15. long inicioCPP = new Date().getTime(); 16. int c = TesteJni.contaCaracteres(args[0],args[1]); 17. long fimCPP = new Date().getTime(); 18. System.out.println("Quantidade de caracteres CPP: " + c + 19. " Em: " + (fimCPP - inicioCPP) + "ms"); 20. long inicioJava = new Date().getTime(); 21. try { 22. FileReader reader = new FileReader(args[0]); 23. int car, cont = 0; 24. int carac = args[1].toCharArray()[0]; 25. while ((car = reader.read()) != -1) { 26. if (car == carac) cont ++; 27. } 28. reader.close(); 29. long fimJava = new Date().getTime(); 30. System.out.println("Quantidade de caracteres Java: " + cont + 31. " Em: " + (fimJava - inicioJava) + "ms"); 32. } 33. catch (FileNotFoundException e) { 34. e.printStackTrace(); 35. } 36. catch (IOException e) { 37. e.printStackTrace(); 38. } 39. } 40. }
O resultado pode ser visto abaixo. O tempo para executar o mesmo algortimo em java foi at menor que em C++. Apesar do tempo em java ter sido mais de um segundo menor que o tempo em C++, este resultado pode ser considerado um empate tcnico j que os otimizadores de cada um dos compiladores atuaram para melhorar o desempenho o que pode mudar de compilador para compilador. Outro fator que deve ser ressaltado em favor do Java que as JVM's modernas, sempre que possvel, geram e executam cdigos nativos a partir do bytecode carregado e, dessa forma, passam a conseguir desempenho muito prximo das aplicaes feitas em cdigo nativo.
Verificando o desempenho do JNI usando ponteiros Agora vamos analisar a situao onde no existe entradas e sadas na funo em C++, apenas um grande volume processamento. Novamente vamos escrever duas verses do mesmo algoritmo uma em Java outra em C++. Em cada uma das verses, preenchido um array de bytes (em Java) e caracteres (em C++) com um valor idntico e ainda para aumentar mais um pouco a carga de processamento, calculamos ainda o somatrio dos seus valores. Usamos o tipo byte em Java porque o tipo equivalente ao char de C++. O programa em Java:
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. } public class TesteJniArray { public static native long preencheArray(); static { System.loadLibrary("fill"); // fill.cpp o fonte C++ } public static void main(String[] args) { long inicioJava = new Date().getTime(); byte vet[] = new byte[0x7FFFFF]; long soma1 = 0; for (int i=0;i<0x7FFFFF;i++) { vet[i] = (byte) ((i%0x100) * 0.99); soma1 += vet[i]; } vet = null; System.gc(); // fora o Garbage Collector (simular o free do C++) long fimJava = new Date().getTime(); System.out.println("Tempo gasto em Java: " + (fimJava - inicioJava) + "ms, soma: " + soma1); long inicioCPP = new Date().getTime(); long soma2 = TesteJni.preencheArray(); long fimCPP = new Date().getTime(); System.out.println("Tempo gasto em C++: " + (fimCPP - inicioCPP) + "ms, soma: " + soma2); }
Veja que na linha 12, criamos um array com 0x7FFFFF bytes. O lao da linha 16 preenche o array com o resto de diviso do valor de i por 0x100 e multiplica por 0.99 para consumir um pouco mais de tempo. Este procedimento foi repetido em ambas as verses. O programa em C++ (FILL.CPP):
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. #include "testeJni.h" #include "jni.h" #include "stdlib.h" JNIEXPORT jlong JNICALL Java_TesteJni_preencheArray(JNIEnv *env, jclass){ char *vet = new char[0x7FFFFF], *buf = vet; long soma = 0L; for (int i=0;i<0x7FFFFF;i++) { *buf = (char) ((i%0x100)* 0.99); soma += *(buf++); } delete(vet); // Liberando a memria alocada. return soma; }
Observe na linha 4 a assinatura de nossa nova funo preenceArray extraida do arquivo de header: TesteJniArray.h. H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 223
O programa em C++ cria na linha 5 um ponteiro vet e instancia uma rea de memria com tamanho de 0x7FFFFF ( 8388607) bytes, da mesma forma que a verso em Java e na sequencia salva o valor inicial do ponteiro alocado para ser usado no final quando for desalocar a memria (linha11). Na linha 7 temos o lao que inicializa as posies de memria. Na linha 9 acumulamos em soma o valor do contedo do ponteiro incrementado-o em seguida.
Podemos ver que neste caso, onde temos uma razovel quantidade de processamento, podemos conseguir alguma vantagem no que concerne a desempenho no uso de JNI. O tempo em gasto pelo programa Java foi mais que o dobro do tempo gasto pelo programa em C++. Provavelmente o tempo a adicional se explica pela necessidade de verificao do ndice do array a cada interao do lao. Usando mtodos e propriedades de objetos do programa Java em um JNI At aqui nossas funes JNI no utilizaram os objetos da classe chamadora e, quando foi necessrio, passamos alguma informao como argumento e retornamos algum resultado. Mas possvel que a funo externa acesse mtodos e propriedades de objetos ativos existentes na classe chamadora. Existe uma rica coleo de funes para acesso a objetos e listas de objetos, converso de tipos java para C/C++ e vice e versa. Para exemplificar, vamos utilizar nossas velhas conhecidas classes Quadrado e Circulo ambas estendidas de Figuras (veja: Ordenando arrays ). O programa java vai criar um array de figuras e solicitar que uma funo externa (somaAreas()) some as reas para que o programa mostre o resultado na console. Neste exemplo, vamos utilizar mais um utilitrio da JDK para nos ajudar a descobrir as assinaturas dos mtodos que sero usadas remotamente: javap.
O programa java:
1.
public class TesteFigurasJNI {
2. public static native double somaAreas(Figuras[] lista); 3. public int valor; 4. 5. static { 6. System.loadLibrary("figuras"); 7. } 8. 9. public static void main(String[] args) { 10. Circulo c1 = new Circulo ( 1, "Crculo 1"); 11. Circulo c2 = new Circulo ( 2, "Crculo 2"); 12. Quadrado q1 = new Quadrado(10, "Quadrado 1"); 13. Quadrado q2 = new Quadrado( 5, "Quadrado 2"); 14. Figuras lista[] = { c1, q1, c2, q2 }; 15. double soma = somaAreas(lista); 16. System.out.printf("Soma das areas das figuras: %8.2f", soma); 17. } 18. }
Na linha 13 chamamos o mtodo externo somaAreas passando como argumento a lista de figuras. O programa C++ (FIGURAS.CPP)
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. #include "TesteFigurasJNI.h" // Criado pelo utilitrio javah #include "jni.h" // Disponvel no pacote JDK (Pasta include) // headers para IO de console #include "stdlib.h" // headers de sistema #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> JNIEXPORT jdouble JNICALL Java_TesteFigurasJNI_somaAreas (JNIEnv *env , jclass cla , jobjectArray lista) { int numElementos = env->GetArrayLength( lista ); printf ("Elementos encontrados: %d \n",numElementos); // Buscando a superclasse Figuras (onde est o mtodo getArea) jclass cls = env->FindClass("Figuras"); jdouble soma = 0; // Obtendo o id do mtodo getArea() // Observe que a assinatura "()D", foi obtida usando o javap // aplicado sobre a classe Figuras.class jmethodID id = env->GetMethodID(cls, "getArea", "()D" ); if (numElementos > 0) { for (int i=0;i<numElementos;i++) { // Extraindo os objetos da lista (Um por um) jobject obj = env->GetObjectArrayElement(lista, i); // Chamando o mtodo getArea() passando o objeto extrado (obj) // e o id do mtodo soma += env->CallDoubleMethod(obj, id); } } return soma; }
Obtendo as assinaturas usando o utilitrio javap
Testando a nossa DLL figuras.
Usar ou no usar JNI? Os projetistas da aplicao devem medir os prs e contras da utilizao ou no de uma funo externa. Em nome de uma eventual melhora de desempenho, abrimos mo da verificao em tempo de execuo da validade dos endereos de memria e da portabilidade do Java. Repare tambm que no podemos utilizar cdigo C e C++ diretamente sem nenhum tipo de adaptao. Sabemos que a assinatura da funo que ser chamada pelo programa Java deve ser idntica a fornecida pelo arquivo header gerado pelo utilitrio javah e, portanto, no pode ser arbitrada livremente pelo programador. Desta forma, para que um cdigo nativo qualquer possa ser aproveitado, ser sempre necessrio realizar algumas alteraes nos fontes para que estes, depois de compilados, possam ser transformados em uma funo externa utilizvel via JNI. Outro ponto muito importante no uso da tecnologia JNI a necessidade de documentao de qualidade para que a biblioteca possa ser bem utilizada. No existe como documentar funes externas no estilo JavaDoc e, por este motivo, o autor deve preparar e disponibilizar farta documentao das funcionalidades oferecidas aos seus clientes. Nos exemplos, utilizamos apenas a plataforma Windows. Para outras plataformas o javah vai gerar outros tipos de assinaturas e o processo de gerao de funes externas ser diferente. Em Solaris/Unix criamos um biblioteca da seguinte forma:
# cc -G -I usr/local/java/jdk1.5.0_06/include \figuras.cpp -o figuras.so
Java e Qualidade de Software

Otimizaes um fato de que existe fortemente arraigado na alma do programador a idia de que deve escrever cdigos otimizados. A otimizao, na idia comum, pode ser de trs tipos: tamanho, velocidade e consumo de memria. Esta preocupao se explica pelo histrico das tcnicas de desenvolvimento utilizadas atravs dos tempos. Lembro de quando os programadores disputavam entre si quem fazia um cdigo consumindo menos linhas, do tempo em que um computador gastava dias para importar uma tabela. Nossos mestres certamente se formaram nesta realidade e nos incutiram esta necessidade de criar cdigos otimizados. Existem regras elementares que nenhum programador deve ignorar: Evitar declarao de variveis internamente a laos, escrever cdigo intil, criar instncias desnecessrias ou repetitivas, concatenar strings em grande quantidade entre outras regras muito conhecidas, so otimizaes que no consomem tempo de projeto nem diminuem a legibilidade do cdigo, muito pelo contrrio. Mas a otimizao que esconde a lgica do cdigo, dificulta o entendimento e a manuteno e , quase que 100% das vezes, injustificada e, o que pior, so responsveis pela maioria dos bugs encontrados no cdigo das aplicaes. Se for realmente necessrio, faa otimizaes no final, nunca nas fases inicias de desenvolvimento. Documente claramente o que foi feito e o motivo. Voc deve priorizar a legibilidade, qualidade da documentao e boas prticas na construo de seu cdigo e: se existir um bom motivo que justifique; voc um especialista; Ai sim, utilizar seu precioso tempo para realizar as otimizaes. Conhea a Biblioteca Java A cada nova verso publicada do Java, mais API's so disponibilizadas. Essas API's so desenvolvidas da melhor forma possvel incorporando boas prticas, desempenho e tudo que se considera o estado da arte em termos de desenvolvimento. Mesmo que o programador seja muito experiente, muito improvvel que consiga escrever um cdigo melhor do que o disponibilizado pela biblioteca e, mesmo que consiga, isso vai diminuir a legibilidade do cdigo e dificultar futuras manutenes pois o programador ter que se inteirar de tudo que foi feito antes de realizar qualquer tipo de manuteno. Respeite as convenes de nomeao Uma das caractersticas interessantes da tecnologia Java a preocupao com as convenes adotadas para nomeao de classes, mtodos, pacotes, objetos etc. Como o nome indica, convenes no so obrigatrias mas nem por isso devem deixar de ser seguidas rigorosamente. A experincia est sempre confirmando a importncia de obedecer as convenes. Linguagens como C++ e C# so bem mais flexveis com relao as normas e, os programadores mais experientes, certamente j cometeram ou viram cometer erros causados pela inexistncia ou desobedincia dessas normas. Utilize Excees criteriosamente As excees no devem ser utilizadas para nenhuma finalidade que no a que elas foram projetadas. Muitos programadores acham que podem conseguir melhor desempenho ou reduzir o tamanho do cdigo ( olha a otimizao danosa aparecendo aqui! ) utilizando excees. Procure sempre utilizar uma exceo j existente ao invs de criar uma nova.
Exemplo de mau uso de excees:

1. public class SomaParametrosConsole { 2. 3. public static void main(String args[]) { 4. try { 5. int i = 0; 6. int soma = 0; 7. while (true) { 8. soma += Integer.parseInt(args[i++]); 9. } 10. } 11. catch (Exception e) { 12. // Saindo do lao 13. } 14. System.out.println("Soma dos nmeros digitados: " + soma); 15. } 16. }
Este cdigo parece ser uma boa idia, parece mais enxuto e mais rpido do que a verso correta mas, certamente, no . O teste da exceo sempre mais demorado do que o realizado explicitamente. Mas o pior que este bloco try/catch vazio, pode mascarar uma exceo real que passar despercebida. Note que, no exemplo, se na lista de argumentos da console algum no for numrico inteiro, a exceo NumberFormatException ser irremediavelmente perdida. Cuidados com Concatenao de Strings A JVM mantm uma lista com todos os strings declarados e utilizados durante o tempo em que uma aplicao est no ar. Esta lista existe para otimizar o uso de memria. Se o programador usar um string como SANTOS vrias vezes no corpo do programa, a JVM vai criar apenas uma entrada na tabela contendo SANTOS e apontar todas as outras ocorrncias para o mesmo lugar evitando assim a duplicao desnecessria de strings. O problema aparece quando o programa precisa concatenar muitos strings como o caso tpico de montagem de queries por exemplo. Para cada novo string obtido com a concatenao, a JVM cria uma nova entrada na tabela e com isso, as infinitas possibilidades de criao de novos strings vai empanturrando a tabela de strings da JVM consumindo muita memria e aumentando de forma dramtica o tempo para consulta e manuteno da lista gigantesca. Para demostrar como o crescimento da tabela de strings pode arruinar o seu desempenho, fizemos um programa que monta um calendrio com ano, ms, dia e dia da semana para cada dia. O calendrio vai sendo concatenado dia a dia, ms a ms, ano a ano para que possamos medir o tempo gasto para montar o calendrio completo.
1. public static void main(String args[]) { 2. String semana [] = {"Sex","Sb","Dom","Seg","Ter","Qua","Qui"}; 3. 4. String meses [] = {"Jan","Fev","Mar","Abr","Mai","Jun", 5. "Jul","Ago","Set","Out","Nov","Dez"}; 6. 7. int dias[] = {31, 28, 1, 30, 31, 30, 31, 31, 30, 31, 30, 31}; 8. 9. String calendario = ""; 10. int diasCorridos = 0; 11. long inicioTotal = new Date().getTime(); 12. for (int ano=2010; ano < 2020; ano ++) { 13. int bissexto = (ano%4 == 0) ? 1 : 0; 14. // Acerto de fevereiro 15. dias[1] = ano%4 == 0 ? 29 : 28; 16. long inicio = new Date().getTime(); 17. for (int mes = 0; mes < 12; mes++) 18. for (int dia=1; dia <= dias[mes] ; dia++, diasCorridos++) {
19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38.
} long fim = new Date().getTime();
calendario calendario calendario calendario calendario calendario calendario calendario calendario
+= += += += += += += += +=
"Ano: "; ano; ", "; meses[mes]; ", "; dia; " ("; semana[diasCorridos%7]; ")\n";
System.out.println( "Gastei " + (fim - inicio) + "ms para montar calendrio do ano " + ano); } long fimTotal = new Date().getTime(); System.out.println("\nGastei " + (fimTotal-inicioTotal)+"ms para montar o calendrio inteiro.\n"); System.out.println(calendario); }
Imprime: Gastei Gastei Gastei Gastei Gastei Gastei Gastei Gastei Gastei Gastei 94ms para montar calendrio do ano 2010 219ms para montar calendrio do ano 2011 453ms para montar calendrio do ano 2012 672ms para montar calendrio do ano 2013 953ms para montar calendrio do ano 2014 1297ms para montar calendrio do ano 2015 1625ms para montar calendrio do ano 2016 2359ms para montar calendrio do ano 2017 2703ms para montar calendrio do ano 2018 3032ms para montar calendrio do ano 2019
Gastei 13453ms para montar o calendrio inteiro Ano: 2010, Jan, 1 (Sex) Ano: 2010, Jan, 2 (Sb) Ano: 2010, Jan, 3 (Dom) . . . . . . . Muita coisa aqui... . . . . . . . Ano: 2019, Dez, 29 (Dom) Ano: 2019, Dez, 30 (Seg) Ano: 2019, Dez, 31 (Ter) Veja que para cada ano acrescentado no calendrio o tempo gasto foi maior. Os tempos gastos no so acumulativos. Enquanto a montagem do primeiro ano consome 94ms, apenas o ano de 2019 consumiu mais que trs segundos para ser concatenado. O tempo total gasto foi de 13.453ms. Vamos agora reescrever este programa substituindo o String por um objeto da classe StringBuilder:
1. public static void main(String args[]) { 2. 3. String semana[] = { "Sex", "Sb", "Dom", "Seg", "Ter", "Qua", "Qui" }; 4. 5. String meses[] = { "Jan", "Fev", "Mar", "Abr", "Mai", "Jun", 6. "Jul", "Ago", "Set", "Out", "Nov", "Dez" }; 7. 8. int dias[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; 9. 10. StringBuilder calendario = new StringBuilder(10 ); 11. int diasCorridos = 0; 12. long inicioTotal = new Date().getTime();
13. for (int ano = 2010; ano < 2020; ano++) { 14. // Acerto de fevereiro 15. dias[1] = ano % 4 == 0 ? 29 : 28; 16. long inicio = new Date().getTime(); 17. for (int mes = 0; mes < 12; mes++) 18. 19. for (int dia = 1; dia <= dias[mes]; dia++, diasCorridos++) { 20. calendario.append("Ano: "); 21. calendario.append(ano); 22. calendario.append(", "); 23. calendario.append(meses[mes]); 24. calendario.append(", "); 25. calendario.append(dia); 26. calendario.append(" ("); 27. calendario.append(semana[diasCorridos % 7]); 28. calendario.append(")"); 29. calendario.append("\n"); 30. } 31. long fim = new Date().getTime(); 32. System.out.println("Gastei " + (fim - inicio) + 33. "ms para montar calendrio do ano " + ano); 34. } 35. long fimTotal = new Date().getTime(); 36. System.out.println("\nGastei " + 37. (fimTotal-inicioTotal)+"ms para montar o calendrio inteiro.\n"); 38. System.out.println(calendario); 39. }
Imprime: Gastei Gastei Gastei Gastei Gastei Gastei Gastei Gastei Gastei Gastei 0ms 0ms 0ms 0ms 0ms 0ms 0ms 0ms 0ms 0ms para para para para para para para para para para montar montar montar montar montar montar montar montar montar montar calendrio calendrio calendrio calendrio calendrio calendrio calendrio calendrio calendrio calendrio do do do do do do do do do do ano ano ano ano ano ano ano ano ano ano 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
Gastei 0ms para montar o calendrio inteiro Ano: 2010, Jan, 1 (Sex) Ano: 2010, Jan, 2 (Sb) Ano: 2010, Jan, 3 (Dom) . . . . . . . Muita coisa aqui . . . . . . . Ano: 2019, Dez, 29 (Dom) Ano: 2019, Dez, 30 (Seg) Ano: 2019, Dez, 31 (Ter) No d nem para comparar... usando Strings: 13.453 ms; Usando StringBuilder: o tempo total menor que um milissegundo!!! , mas o resultado que voc est vendo no est absolutamente correto. Na realidade o tempo foi menor que 16ms... que o timer do PC no incrementa de um em um mais de 16 em 16ms aproximadamente. Java conseguiu realizar todo o servio antes que o clock fosse atualizado... no incrvel? Nem d para medir com preciso. Agora imagine uma aplicao web, rodando em um servidor semanas a fio, fazendo consultas e mais consultas... se a aplicao realiza muitas concatenaes a tabela de strings chega a travar a aplicao em menos de uma hora de sistema no ar. Pode acreditar!
Exerccios
A classe Calculadora
Calculadora
private float resultado public float soma(float arg1, gloat arg2) public float subtrai(float arg1, float arg2) public float divide(float arg1, gloat arg2) public float multiplica(float arg1, gloat arg2) public float getResultado() public byte soma(byte arg1, byte arg2) public int resto(int arg1, int arg2)
Nosso objetivo no nem de longe fazermos um modelo de calculadora. Vamos utilizar este exemplo apenas para praticar o uso de alguns tipos de variveis, operadores, aspectos de operaes com inteiros, escopo e cast. A varivel membro resultado, tem como nica finalidade exemplificar modificadores de acesso. Implemente os seguintes passos:

No mtodo getResultado() retorne a varivel resultado. No primeiro mtodo soma, imprima a frase "Somando float O mtodo ser sobrecarregado, crie uma varivel local do tipo byte tambm de nome resultado e atribua a ela a soma dos parmetros arg1 e arg2. Ainda no segundo mtodo soma, imprima a frase Somando byte Crie o mtodo resto, utilizando o operador % e faa-o funcionar corretamente. Os demais mtodos so simples e devem ser codificados conforme o nome. Inicialmente, atribua a operao a varivel membro resultado e retorne-a. Crie comentrios para todos os mtodos utilizando o formato de comentrios para documentao Java.
Nota: Nos tens do exerccio, em alguns casos ser necessrio a utilizao de operadores cast. Testando a Calculadora 1. Codifique uma classe de nome TestaCalculadora.
TestaCalculadora
public static void main (String args[])
No mtodo main declare e 'instancie' um objeto da classe Calculadora e utilize todos os mtodos, imprimindo sempre o valor retornado. Tente imprimir a varivel resultado sem utilizar o mtodo getResultado(). Trate o erro no caso de uso errado do programa TestaCalculadora (Erro de passagem de parmetros via linha de comando. Usar o try/catch como visto em classe) Force a utilizao dos dois mtodos soma. Declare um novo objeto da classe Calculadora e atribua a ele o objeto criado anteriormente. Imprima o retorno do mtodo getResultado() dos dois objetos. Faa uma operao qualquer com o segundo objeto. Imprima novamente o retorno de getResultado() dos dois objetos. Atribua ao segundo objeto uma nova instncia da classe Calculadora. Faa uma nova operao com o segundo objeto e imprima novamente o mtodo getResultado() dos dois objetos criados. Faa os clculos com parmetros recebidos via comando do MS-DOS. No mtodo main, crie duas variveis locais do tipo float e atribua a elas a converso de args[0] e args[1], utilizando o mtodo parseFloat do objeto Float.
A classe Cliente Esta a primeira de um srie de classes que faro parte de um pequeno projeto de uma aplicao bancria. Este projeto servir como treinamento e, principalmente, entendimento do conceito de Programao Orientada a Objetos (POO).
Cliente
public static int PESSOA_FISICA = 1 public static int PESSOA_JURIDICA = 2 private String nome private String sobrenome private char sexo private byte idade private String cpf_cnpj private byte categoria
Cliente
public Cliente (String nome, String sobrenome, int idade, char sexo, String cpf_cnpj, int categoria) public String getCpfCnpj() public String getNomeCompleto() public byte getIdade() public char getSexo() public char getCategoria public void setCpfCnpj (String cpf_cnpj) public void setNome (String nome) public void setSobrenome (String sobrenome) public void setIdade( int idade) public void setSexo( char sexo) public void setCategoria( int categoria) public void imprimeCliente()
Vamos dar incio a construo de nossa pequena aplicao bancria. Para tanto, crie a classe Cliente, conforme o diagrama ao lado.

No construtor da classe atribua os parmetros s respectivas variveis membro fazendo a validao do sexo ('M' ou 'F') e da categoria (1 ou 2); No mtodo getCpfCnpj(), retorne a varivel membro cpf_cnpj; No mtodo getNomeCompleto() concatene o nome e o sobrenome do cliente e retorne-os. Nos demais mtodos get retorne as variveis conforme o nome sugere. No mtodo setCpfCnpj atribua o parmetro a varivel membro cpf_cnpj. Nos demais mtodos set, faa a atribuio conforme o nome do mtodo sugere. Utilize cast quando necessrio e trate a entrada dos parmetros sexo e categoria. No mtodo imprimeCliente(), imprima todos os dados do cliente.
Documente todos os mtodos no formato Javadoc. Utilize as anotations @return para os mtodos get, @param para os mtodos set e @author para a Classe Cliente.
Testando o Cliente
TestaCliente
static public void main (String [] args)

Codifique uma classe de nome TestaCliente. No mtodo main declare e instancie um array da classe Cliente com cinco posies. Aproveite o construtor para setar as variveis membro da instncia. Imprima os dados dos cinco clientes includos no vetor de objetos.
Notas de UML H. Rangel & F. Barbosa Lima - Programao Orientada a Objetos Java Set. 2010 Pg. 234
Para representar que um atributo que s leitura, usamos uma barra normal (/) antes do seu nome no diagrama. Atributos privados mas que no sero modificados pelo mundo exterior (No tero um mtodo set para modific-lo) recebem a marca de barra. (/). No exemplo da calculadora que vimos anteriormente, a propriedade resultado s pode ser modificada por intermdio de um clculo. O usurio pode verificar seu contedo mas no pode modific-lo diretamente. Este seria o caso de usar uma barra (/) antes de seu nome.
Para representar um atributo ou mtodo private usamos o sinal menos (-). Para representar um atributo ou mtodo public usamos o sinal de mais (+). Para representar um atributo ou mtodo protected usamos o caracter sustenido (#). Atributos (propriedades) e operaes (mtodos) que manipulam objetos de outras classes devem ser representados sublinhados. Uma notao alternativa (usada nas primeiras verses UML) colocar um $ na frente do nome do mtodo. Quando temos mtodos abstratos, eles so representamos em itlico... Tambm podemos usar a palavra abstrato entre chaves: {abstrato}
Veja exemplos nos diagramas de classes a seguir. A classe Banco
Banco
- String nomeBanco - int numeroBanco - Agencia[] agencias - int qtAgenciasAbertas = 0 - static int numeroAgenciaAtual = 1 /+ static final double taxaPF = 0.03 /+ static final double taxaPJ = 0.04 + Banco (String nomeBanco, int numeroBanco, int qtMaxAgencias) static - double calculaPrestacaoEmprestimo(double valorEmprestimo, int qtMeses, int categoria) + String getNome() + int getNumero() + void setNome(String nome) + void setNumeroBanco (int numeroBanco) + void imprimeDados() + void abrirAgencia() - void adicionaArrayAgencias(Agencia ag) + void imprimeAgencias()
Dando sequncia a nossa aplicao bancria, crie as classes conforme os diagramas. A princpio teremos um nmero mximo de agncias setado .
No construtor da Banco atribua os parmetros s respectivas variveis membro e instancie o array agencias com o valor do parmetro qtMaxAgencias;
Implemente os mtodos get e set necessrios; No mtodo imprimeDados(), imprima o nome e o nmero do Banco; No mtodo abrirAgencia() declare e instancie um objeto Agencia passando ao construtor o numeroAgenciaAtual() como String e a referncia do objeto Banco (this); Por ltimo, chame o mtodo adicionaArrayAgencias passando o objeto criado como parmetro; No mtodo adicionaArrayAgencias() verifique se o tamanho do array agencias igual a quantidade de agncias abertas, se for, imprima uma mensagem de erro comentando que o limite de agncias estourou, se no, adicione o parmetro recebido ultima posio do array agencias e finalmente incremente o nmero de agncias abertas; No mtodo imprimeAgencias(), imprima um cabealho com o nome e o nmero do Banco e faa um lao no array agencias chamando o mtodo imprimeDadosAgencia() de cada posio do array. No mtodo calculaPrestacaoEmprestimo(), verifique se a categoria Pessoa Jurdica, se sim, calcule: juros = a taxa de PJ X quantidade de meses; total = parmetro Valor do Emprstimo X (juros + 1) e retorne o total dividido pela quantidade de meses. Se no, faa os mesmos clculos com a taxa de Pessoa Fsica e retorne como descrito acima; No esquecer de verificar a validade dos argumentos: (Quantidade de meses e categoria). No usar try/catch. Mostrar mensagem conforme o caso e retorne zero.
A Classe Agencia
Agencia
- String numeroAgencia - Banco banco Agencia(String numero, Banco banco) Banco getBanco() String getNumero() void setBanco (Banco banco) void imprimeDadosAgencia() void setNumero (String sNumeroAgencia)
Codifique a classe conforme o Diagrama; Faa as devidas atribuies no construtor e implemente todos os mtodos get e set; No mtodo imprimeDadosAgencia() imprima o nmero da agncia; Compilando e testando as Classes Banco e Agencia Crie uma classe TestaAppBancaria e utilize os objetos das classes Banco e Agencia; Trabalhando com interface <<inteface>> ContaDefault
+ void saque (double valor) {abstrata} + void deposito(double valor) {abstrata} + void imprimeDadosConta( ) {abstrata} + double getSaldo( ) {abstrata} + Agencia getAgencia( ) {abstrata} + String getNumero( ) {abstrata} + Cliente getTitular( ) {abstrata} + void setTitular(Cliente titular ) {abstrata}
/\ || Conta
- /double saldo - int numero - Agencia agencia - Cliente titular
Conta
+ Conta (double saldoInicial, int num, Agencia Ag, Cliente titular) + Conta (int num, Agencia ag, Cliente tit) + void saque(double valor) + void deposito (double valor) + void imprimeDadosConta() + double getSaldo() + Agencia getAgencia() + int getNumero() + Cliente getTitular() + void setTitular (Cliente titular)
A interface ContaDefault Dando sequncia a nossa aplicao bancria, abra o projeto AppBancaria Crie a interface conforme o diagrama;
Repita os passos acima para adicionar um Ficheiro e codifique a classe Conta implementando a interface ContaDefault; Codifique os mtodos get e set conforme explicado em sala de aula; Nos construtores da classe Conta atribua os parmetros s respectivas variveis membro; No mtodo saque verifique se o parmetro valor positivo, se for, verifique se o saldo maior que o valor a sacar, caso seja, subtraia o valor a sacar do saldo, caso no, imprima uma mensagem de erro. Faa o mesmo caso o parmetro valor seja negativo; No mtodo depsito, verifique se o parmetro positivo, se sim, some ao saldo, caso no seja positivo, imprima uma mensagem de erro. No mtodo imprimeDadosConta() chame os mtodos de impresso das instncias agencia e titular e imprima o numero da conta e o saldo;
Modificando a Classe Agencia
Agora, precisamos alterar a classe Agencia do exerccio anterior inclua os atributos do diagrama;
Agencia
- String numeroAgencia - Banco banco - Conta [] contas - /int qtContasAbertas = 0 - static int numeroContaAtual = 1
Agencia
Agencia (String numero, Banco banco, int numMaxContas) abrirConta (double saldo) : Conta adicionaArrayContas ( ) getBanco ( ) : Banco String getNumero ( ) setBanco (Banco banco) imprimeDadosAgencia ( ) setNumero (String sNumeroAgencia)

No construtor, instancie a varivel membro contas utilizando o parmetro numMaxContas; Adicione os mtodos abrirConta e adicionaArrayContas, deixe-os para serem codificados no prximo exerccio. Escreva uma classe para testar as Classes Banco, Agencia, Conta e Cliente. A classe Banco apresentar um erro de compilao, procure corrigir.
Notas de UML
Normalmente o sinal + (que significa public) omitido no desenho de projetos OO, a menos que o projetista queira dar uma nfase especial ao fato do atributo ser pblico. Na definio da classe Agencia acima utilizamos duas novas notaes em nossos diagramas: Note que os mtodos no diagrama no possuem a palavra reservada public nem o sinal de +. Em UML o default que a visibilidade publica. Usamos pela primeira vez a notao para indicar que o mtodo retorna o tipo declarado. Exemplo: +getBanco () : Banco equivale a public Banco getBanco();
Mais modificaes na classe Agencia Dando sequncia a nossa aplicao bancria, abra o projeto AppBancaria e altere os mtodos de Agencia digitados no exerccio anterior, conforme o diagrama abaixo:
Agencia
- String numeroAgencia - Banco banco - Conta [] contas - int qtContasAbertas = 0 - static int numeroContaAtual = 1
Agencia
+Agencia (String numero, Banco banco, int numMaxContas) +abrirConta(double saldo, Cliente cliente) : Conta - adicionaArrayContas(Conta conta) +getBanco( ) : Banco +getNumero( ) : String +setBanco(Banco banco) +imprimeDadosAgencia() +setNumero (String sNumeroAgencia)
No construtor da classe, verifique se foram atribudos os parmetros s respectivas variveis membros; Verifique tambm se o objeto contas foi instanciado com o parmetro numMaxContas; Codifique os mtodos get e set. No mtodo abrirConta declare e instancie um objeto da classe Conta passando os parmetros: saldo, numeroContaAtual incrementado, cliente e a referncia de agncia. Retorne o objeto que voc instanciou. Dica: incremente numeroContaAtual somente aps utiliza-lo e use o this para referenciar a classe Agencia.
No mtodo adicionaArrayContas verifique se o tamanho do array contas menor ou igual a qtContasAbertas, se for, imprima uma mensagem de erro informando que o limite de agncias a serem abertas se esgotou, se no for, posicione o array contas utilizando como ndice a varivel membro qtContasAbertas e atribua o parmetro conta (objeto). Em seguida incremente qtContasAbertas; No mtodo imprimeDadosAgencia, imprima a varivel membro numeroAgencia e o nome e nmero do Banco, para tanto, utilize os mtodos getNome e getNumero do objeto banco.
Notas de UML:
Veja que nos mtodos da classe Agencia no foi indicado o tipo de retorno nos mtodos. UML convenciona que se no for declarado nenhum tipo de argumento out, isso significar no existir retorno algum. Ou seja, no caso de Java, o retorno ser void (Exceto naturalmente no caso do(s) construtor(es)).
Testando a aplicao Bancria

Adicione uma nova classe ao projeto AppBancaria; Nomeie esta classe como TestaBanco; Digite o cdigo fonte abaixo;
public static void main(String args[]) { Banco oBanco = new Banco("SantaBanco", 1234, 10); Agencia oAgencia = oBanco.abrirAgencia(); try{ Cliente oCli1 = new Cliente("Maria", "Terezinha", 64, 'F', "1111111", Cliente.PESSOA_FISICA);
1. 2. 3. 4. 5. 6. 7. 8. 9.
10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23.
Cliente oCli2 = new Cliente("Jos", " Silva ", 54, 'M', "222222", Cliente.PESSOA_JURIDICA); oAgencia.abrirConta(4000, oCli1); oAgencia.abrirConta(5000, oCli2); oAgencia.imprimeDadosAgencia(); } catch(Exception e){ System.out.println(e.getMessage()); }
Execute a classe TestaBanco;
Tela de Cadastro de Bancos
Usando uma interface grfica Neste exerccio faremos uma implementao de layout em J2SE. Para tanto, utilizaremos os pacotes awt e swing. Copie o cdigo fonte, cole em um arquivo de nome TelaBanco.Java e inclua o mesmo em nosso projeto AppBancaria.jde. Vamos seguir as atividades descritas nos comentrios do cdigo que segue: A classe TelaBanco
1. // import eventos AWT 2. import java.awt.event.ActionEvent; 3. import java.awt.event.ActionListener; 4. import java.awt.event.FocusEvent; 5. import java.awt.event.FocusListener; 6. import java.awt.event.WindowEvent; 7. import java.awt.event.WindowListener; 8. 9. //import UIManager 10.import javax.swing.*; 11.import com.sun.java.swing.plaf.windows.WindowsLookAndFeel; 12.//import javax.swing.plaf.metal.MetalLookAndFeel; 13. 14./** 15.* @author Fernando Lima 16.* Esta classe implementa as aes de ActionListener (Aes dos 17.* Botes), FocusListener (Ganho e Perda de Foco) e 18.* WindowsListener (Eventos da Janela)
19.* Classe primeira em Swing que gera um Frame com campos para 20.* utilizao da classe Banco 21.*/ 22. public class TelaBanco extends JFrame implements 23. ActionListener, 24. FocusListener, 25. WindowListener { 26. JLabel lblBanco = new JLabel("Nome do Banco:"); 27. //Crie o label lblBanco conforme layout 28. //Crie o label lblQtd conforme layout 29. 30. JTextField txtNome = new JTextField(); 31. //Crie o TextField txtNumero 32. //Crie o TextQtd txtNumero 33. 34. JButton btnOk = new JButton("Salvar"); 35. //Crie o btnLimpar conforme layout 36. 37. public static void main(String[] args) { 38. TelaBanco tela = new TelaBanco(); // Instancia a Classe 39. } 40. // static inicializador que seta o look & feel 41. static { 42. try { 43. UIManager.setLookAndFeel(new WindowsLookAndFeel()); 44. // Descomente e Teste no final do exerccio 45. // UIManager.setLookAndFeel(new MetalLookAndFeel()); 46. } 47. catch (Exception e) {// Imprima o Erro aqui } 48. } 49. /** 50. * Construtor da Tela de Cadastro de Banco 51. */ 52. 53. public TelaBanco () { 54. super("Cadastro de Bancos"); 55. setBounds(0,0,500,350); //Acerte o tamanho conforme o layout acima 56. this.addWindowListener(this); 57. 58. getContentPane().setLayout(null); 59. lblBanco.setBounds(20,10,80,20); 60. getContentPane().add(lblBanco); 61. txtNome.setBounds(150,10,80,20); 62. txtNome.addFocusListener(this); 63. getContentPane().add(txtNome); 64. 65. //Formate as caractersticas do objeto lblNumero 66. getContentPane().add(lblNumero); 67. 68. txtNumero.setBounds(150,35,80,20); 69. 70. // Adicione o focus listener para que receba o evento de foco 71. // do objeto txtNumero Adicione o componente txtNumero ao 72. // Container Jframe TelaBanco 73. lblQtd.setBounds(20,60,130,20); 74. getContentPane().add(lblQtd); 75. 76. txtQtd.setBounds(150,60,80,20); 77. getContentPane().add(txtQtd); 78. btnOk.setBounds(20,100,95,20); 79. btnOk.addActionListener(this); 80. btnOk.setToolTipText("Salvar"); 81. getContentPane().add(btnOk); 82. btnLimpar.setBounds(135,100,95,20);
83. 84. // Adicione um Action Listener ao boto Limpar 85. // Formate o texto de display do boto Limpar 86. // Adicione o componente btnLimpar ao Container Jframe TelaBanco 87. 88. setVisible(true); 89. } 90. 91. /** 92. * Implementa as Aes dos clicks dos botes e valida os 93. * dados dos campos obrigatrios 94. */ 95. public void actionPerformed(ActionEvent ae) { 96. if(ae.getSource()==btnOk) { 97. System.out.println("btnOK - Action Performed"); 98. if(validaCampos()) { 99. try { 100. insereBanco(); 101. limpaCampos(); 102. } 103. catch(Exception e) { 104. JOptionPane.showMessageDialog(null,"Houve Problema"); 105. System.out.println("Erro: " + e.toString()); 106. } 107. } 108. } 109. // Verifique se foi clicado o boto Limpar, 110. // imprima "btnLimpar - Action Performed" 111. // e chame o mtodo que limpa os campos 112.} 113. /** 114. * Implementa o evento de foco ganho para os objetos da tela 115. */ 116. public void focusGained(FocusEvent fe) { 117. if(fe.getSource() == txtNome) { 118. System.out.println("txtBanco Ganhou Foco"); 119. } 120. // Faa o mesmo tratamento para os demais JtextFields da Tela 121. } 122.} 123. /** 124. * Implementa o evento de perda de foco para os objetos 125. * da tela 126. */ 127. public void focusLost(FocusEvent fe) { 128. if(fe.getSource() == txtNumero) { 129. System.out.println("txtNumero Perdeu Foco"); 130. } 131. // Faa o mesmo tratamento para os demais JtextFields da Tela 132. } 133. 134. // Faa o comentrio do mtodo no formato JavaDoc 135. public void windowOpened(WindowEvent e) { 136. System.out.println("Janela Aberta"); 137. } 138. 139. // Faa o comentrio do mtodo no formato JavaDoc 140. public void windowClosing(WindowEvent e) { 141. System.exit(0); 142. } 143. 144. // Faa o comentrio do mtodo no formato JavaDoc 145. public void windowClosed(WindowEvent e) { 146. System.out.println("Janela Fechada"); 147. } 148.
149. 150. // Faa o comentrio do mtodo no formato JavaDoc 151. public void windowActivated(WindowEvent e) { 152. System.out.println("Janela Ativa"); 153. } 154. 155. // Faa o comentrio do mtodo no formato JavaDoc 156. public void windowDeactivated(WindowEvent e) { 157. System.out.println("Janela Desativada"); 158. } 159. 160. // Faa o comentrio do mtodo no formato JavaDoc 161. public void windowIconified(WindowEvent e) { 162. System.out.println("Janela Minimizada"); 163. } 164. 165. // Implemente o mtodo que trata a troca da tela de minimizada 166. para estado normal 167. // "windowDeiconified" 168. // Ateno: Ao implementarmos a classe WindowEvent 169. // precisamos ter os mtodos nela definidos 170. /** 171. * Valida os campos obrigatrios da tela 172. * @return boolean 173. */ 174. public boolean validaCampos() { 175. if (txtNome.getText().trim().equals("")) { 176. JoptionPane.showMessageDialog 177. (null,"Preencha o Nome do Banco"); 178. return false; 179. } 180. // Faa o mesmo tratamento para os objetos txtNumero e txtQtd 181. 182. return true; 183. } 184. public void insereBanco(){ 185. try{ 186. /* Declare e instancie um objeto da classe Banco 187. * 188. * Passe os parmetros sem espaos para o construtor da 189. * classe Banco. 190. * 191. * Faa a converso para inteiro quando necessrio 192. * (Integer.parseInt) 193. 194. * Chame o mtodo imprimeDados do objeto Banco */ 195. 196. }catch(Exception e){ 197. JOptionPane.showMessageDialog(null,e.toString()); 198. } 199.} 200. public void limpaCampos() { 201. txtNome.setText(""); 202. // Faa o mesmo tratamento para os demais objetos da tela 203. } 204.}
Gabaritos Gabarito da classe Cliente

public class Cliente { public static int PESSOA_FISICA = 1; public static int PESSOA_JURIDICA = 2; private String nome; private String sobrenome; private char sexo; private byte idade; private String cpf_cnpj; private byte categoria; /** * @param nome do cliente * @param cpf_cnpj do cliente */ public Cliente(String nome, String sobrenome, int idade, char sexo, String cpf_cnpj, int categoria) throws Exception { this.cpf_cnpj = cpf_cnpj; this.nome = nome; this.sobrenome = sobrenome; if (categoria != 1 && categoria != 2) throw new Exception("Categoria invlida!"); this.categoria = (byte) categoria; if (sexo != 'F' && sexo != 'f' && sexo != 'm' && sexo != 'M') throw new Exception("Sexo invlido!"); this.sexo = sexo; this.idade = (byte )idade; } /** * @return cpf do cliente */ public String getCpfCnpj() { return this.cpf_cnpj; } /** * @return nome do cliente */ public String getNomeCompleto() { return this.nome + " " + this.sobrenome; } /** * @return a idade do cliente */ public byte getIdade() { return this.idade; } /** * @return o sexo do cliente */ public char getSexo() { return this.sexo; } /** * @return a categoria do cliente */ public byte getCategoria() { return this.categoria; }
/** * @param string cpf */ public void setCpfCnpj(String cpf_cnpj) { this.cpf_cnpj = cpf_cnpj; } /** * @param string nome */ public void setNome(String nome) { this.nome = nome; } /** * @param string sobrenome */ public void setSobrenome(String sobrenome) { this.sobrenome = sobrenome; } /** * @param string idade */ public void setIdade(int idade) { this.idade = (byte) idade; } /** * @param string sexo */ public void setSexo(char sexo) { this.sexo = sexo; } /** * @param int categoria */ public void setCategoria(int categoria) { this.categoria = (byte) categoria; } /** * Mtodo para impresso de todos os dados da classe Cliente */ public void imprimeCliente() { String cat = "Pessoa Fsica"; String doc = "CPF"; if (categoria == PESSOA_JURIDICA){ cat = "Pessoa jurdica"; doc = "CNPJ"; } System.out.println("** Nome do cliente :" + this.nome + " " + sobrenome); System.out.println("** Sexo :" + this.sexo); System.out.println("** Idade :" + this.idade); System.out.println("** "+ doc +" :" + this.cpf_cnpj); System.out.println("** Categoria = " + cat);
Gabarito da classe Banco

public class Banco { private String nomeBanco; private int numeroBanco; private Agencia[] agencias;
private int qtAgenciasAbertas = 0; private static int numeroAgenciaAtual = 1; public static final double taxaPF = 0.03; public static final double taxaPJ = 0.04; /** * @param nomeBanco nomeBanco do banco * @param numeroBanco Nmero do banco */ public Banco(String nomeBanco, int numeroBanco, int qtMaxAgencias) { this.nomeBanco = nomeBanco; this.numeroBanco = numeroBanco; this.agencias = new Agencia[qtMaxAgencias]; } public static double calculaPrestacaoEmprestimo(double valorEmprestimo, int qtMeses, int categoria) { if (categoria == Cliente.PESSOA_JURIDICA) { double juros = taxaPJ * qtMeses; double total = valorEmprestimo * (juros + 1); return total / qtMeses; } else { if (categoria == Cliente.PESSOA_FISICA) { double juros = taxaPF * qtMeses; double total = valorEmprestimo * (juros + 1); return total / qtMeses; } else { System.out.println("Categoria de cliente invalida"); return 0; } }
/** * @return nomeBanco do banco */ public String getNome() { return nomeBanco; } /** * @return numeroBanco do banco */ public int getNumero() { return numeroBanco; } /** * @param nomeBanco do banco */ public void setNome(String nomeBanco) { this.nomeBanco = nomeBanco; } /** * @param numeroBanco do banco */ public void setNumeroBanco(int numBanco) { numeroBanco = numBanco; } /** * Mtodo para impresso de todos os dados da classe Banco
*/ public void imprimeDados() { System.out.println("Banco: " + nomeBanco + "\tNumero do banco " + numeroBanco); } public Agencia abrirAgencia() { Agencia ag = new Agencia("" + numeroAgenciaAtual++, this, 10); adicionaArrayAgencias(ag); return ag; } private void adicionaArrayAgencias(Agencia ag) { if (this.agencias.length <= qtAgenciasAbertas) { System.out.println("Banco ERRO: O Limite de Agencias foi ultrapassado"); } else { System.out.println("Banco Log: Agencia adicionada ao array " + qtAgenciasAbertas); this.agencias[qtAgenciasAbertas] = ag; qtAgenciasAbertas++; } } public void imprimeAgencias() { System.out.println("\n\n====== RELATORIO DE AGENCIAS DO BANCO ====\n"); System.out.println("numeroBanco de agencias abertas: " + qtAgenciasAbertas); for (int i = 0; i < qtAgenciasAbertas; i++) { agencias[i].imprimeDadosAgencia(); } System.out.println("===============================================");
} }
A Interface ContaDefault public interface ContaDefault{

public void saque(double valor); public void deposito(double valor); public void imprimeDadosConta(); public double getSaldo(); public Agencia getAgencia(); public int getNumero(); public Cliente getTitular(); public void setTitular(Cliente titular); }
Gabarito da classe Agencia

public class Agencia { private String numeroAgencia; private Banco banco; private Conta contas[]; private int qtContasAbertas = 0; private static int numeroContaAtual = 1; /** * @param num numeroAgencia da agencia * @param bc oBanco ao qual a agncia pertence */ public Agencia(String numero, Banco banco, int numMaxContas) { numeroAgencia = numero; this.banco = banco; contas = new Conta[numMaxContas]; } public Conta abrirConta(double saldo, Cliente cliente) {
} public ContaPoupanca abrirConta(double saldoInicial, Cliente tit, String dataAniversario) { ContaPoupanca c = new ContaPoupanca(saldoInicial, numeroContaAtual++, tit, this, dataAniversario); adicionaArrayContas(c); return c; } public ContaEspecial abrirConta(double saldoInicial, Cliente tit, double limite ) { ContaEspecial c = new ContaEspecial(saldoInicial, numeroContaAtual++, tit, this,limite); adicionaArrayContas(c); return c; } private void adicionaArrayContas(Conta conta) { if (this.contas.length <= qtContasAbertas) { System.out.println("Conta ERRO: No foi possvel criar uma nova conta."); } else { System.out.println("Conta DEBUG: Conta adicionada ao array " + qtContasAbertas); this.contas[qtContasAbertas] = conta; qtContasAbertas++; } } /** * @return nmero do oBanco */ public Banco getBanco() { return banco; } /** * @return nmero da agncia */ public String getNumero() { return numeroAgencia; } /** * @param banco oBanco */ public void setBanco(Banco banco) { this.banco = banco; } /** * Mtodo para impresso de todos os dados da classe */ public void imprimeDadosAgencia() { System.out.println("Agncia nmero: " + numeroAgencia); System.out.println("Banco nmero: " + banco.getNumero()); System.out.println("Banco nome: " + banco.getNome()); } /** * @param string nmero da agncia */ public void setNumero(String sNumeroAgencia) { numeroAgencia = sNumeroAgencia; }
Conta c = new Conta(saldo, numeroContaAtual++, cliente, this); adicionaArrayContas(c); return c;
Gabarito do exerccio interface grfica

// import eventos AWT import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.FocusEvent; import java.awt.event.FocusListener; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; import java.io.FileWriter; import java.io.IOException; //import UIManager import javax.swing.*; import com.sun.java.swing.plaf.windows.WindowsLookAndFeel; //import javax.swing.plaf.metal.MetalLookAndFeel; /** * @author Fernando Lima * Esta classe implementa as aes de ActionListener (Ao nos Botes), * FocusListener (Ganha foco e perde foco) e WindowsListener (Enventos na Janela) * Classe teste para Swing esta classe gera um Frame com campos para utilizao da classe Banco */ public class TelaBanco extends JFrame implements ActionListener, FocusListener, WindowListener { /** * Criando e instanciando os objetos da tela: Trs labels, trs caixas de texto e dois botes. */ JLabel lblBanco = new JLabel("Nome do Banco:"); JLabel lblNumero = new JLabel("Nmero do Banco:"); JLabel lblQtd = new JLabel("Quantidade de Agencias:"); JTextField txtNome = new JTextField(); JTextField txtNumero = new JTextField(); JTextField txtQtd = new JTextField(); JButton btnOk = new JButton("Salvar"); JButton btnLimpar = new Jbutton("Limpar"); /** * Definindo uma classe interna para fazer um log em arquivo texto */ public class Log { // Classe interna String path = "C://log.txt"; public void grava(String texto){ try{ FileWriter f = new FileWriter(path, true); // Abrindo um arquivo texto para escrita f.write(texto); // Salvando o texto recebido. f.close(); // Fechando o arquivo }catch(IOException e){ System.out.println("Erro ao gravar o log"); } }
/** * Definio do mtodo executvel main */ public static void main(String[] args) { TelaBanco tela = new TelaBanco(); } // bloco static inicializador para setar o look & feel static { try { UIManager.setLookAndFeel(new WindowsLookAndFeel()); // UIManager.setLookAndFeel(new MetalLookAndFeel()); } catch (Exception e) { /*no faz nada*/ } } /** * Construtor da Tela */ public TelaBanco () { super("Cadastro de Bancos"); // Titulo do form setBounds(0,0,280,180); // Coordenadas dos cantos superior esquerdo e inferior direito this.addWindowListener(this); // Liga o Listener do windows getContentPane().setLayout(null); lblBanco.setBounds(20,10,80,20); getContentPane().add(lblBanco); txtNome.setBounds(150,10,80,20); txtNome.addFocusListener(this); getContentPane().add(txtNome); lblNumero.setBounds(20,35,110,20); getContentPane().add(lblNumero); txtNumero.setBounds(150,35,80,20); txtNumero.addFocusListener(this); getContentPane().add(txtNumero); lblQtd.setBounds(20,60,130,20); getContentPane().add(lblQtd); txtQtd.setBounds(150,60,80,20); getContentPane().add(txtQtd); btnOk.setBounds(20,100,95,20); btnOk.addActionListener(this); btnOk.setToolTipText("Salvar"); getContentPane().add(btnOk); btnLimpar.setBounds(135,100,95,20); btnLimpar.addActionListener(this); btnLimpar.setToolTipText("Limpar"); getContentPane().add(btnLimpar); } setVisible(true);
/** * Implementa a Ao do click no boto e valida os dados dos campos obrigatrios */ public void actionPerformed(ActionEvent ae) { Log l = new Log(); if(ae.getSource()==btnOk) { System.out.println("btnOK - Action Performed"); l.grava("btnOK - Action Performed"); if(validaCampos()) { try { insereBanco(); limpaCampos();
} } if(ae.getSource()==btnLimpar) { System.out.println("btnLimpar - Action Performed"); l.grava("btnLimpar - Action Performed"); limpaCampos(); }
} catch(Exception e) { JOptionPane.showMessageDialog(null,"Houve Problema"); System.out.println("Erro: " + e.toString()); l.grava(e.toString()); }
/** * Implementa o evento para quando o objeto ganha foco na tela */ public void focusGained(FocusEvent fe) { if(fe.getSource()==txtNome) { System.out.println("txtBanco Ganhou Foco"); } } /** * Implementa o evento para quando o objeto perde foco na tela */ public void focusLost(FocusEvent fe) { if(fe.getSource()==txtNumero) { System.out.println("txtNumero Perdeu Foco"); } } public void windowOpened(WindowEvent e) { System.out.println("Janela Aberta"); } public void windowClosing(WindowEvent e) { System.exit(0); } public void windowClosed(WindowEvent e) { System.out.println("Janela Fechada"); } public void windowActivated(WindowEvent e) { System.out.println("Janela Ativada"); } public void windowDeactivated(WindowEvent e) { System.out.println("Janela Desativada"); } public void windowIconified(WindowEvent e) { / / Vazio } public void windowDeiconified(WindowEvent e) { // Vazio }
/** * Valida os campos obrigatrios da tela * @return boolean */ public boolean validaCampos ( ) { if (txtNome.getText().trim().equals("")) { JOptionPane.showMessageDialog(null,"Preencha o Nome do Banco"); return false; } if (txtNumero.getText().trim().equals("")) { JOptionPane.showMessageDialog(null,"Preencha o Nmero do Banco"); return false; } if (txtQtd.getText().trim().equals("")) { JOptionPane.showMessageDialog(null,"Preencha a Quantidade de Agncias"); return false; } return true; } public void insereBanco(){ try{ Banco oBanco = new Banco(txtNome.getText().trim(), Integer.parseInt(txtNumero.getText().trim()), Integer.parseInt(txtQtd.getText().trim()) ); oBanco.imprimeDados(); Agencia Ag = new Agencia("666", oBanco, 40); }catch(Exception e){ JOptionPane.showMessageDialog(null,e.toString()); } } public void limpaCampos() { txtNome.setText(""); txtNumero.setText(""); txtQtd.setText(""); }
Bibliografia
Java Como Programar H.M. Deitel & P.J. Deitel Editora Bookman (4a, 5a e 6a edio) Aprenda em 21 dias Java 2 Professional Reference Laura Lemay & Rogers Cadenhead Editora Campus Java 2 & Banco de Dados Marco Aurlio Thompson Editora rica (2a edio) Revista JavaMagazine, edio 18, Aplicaes Web no Tomcat 5, Fernando Lozano Fundamentos do Desenho Orientado a Objetos Meilir Page-Jones Makron Books Modelagem de Objetos atravs da UML Jos Davi Furlan Makron Books JavaTM Efetivo Joshua Bloch ALTA BOOKS http://br.sun.com/aboutsun/historia.jsp (jan/2010) Argo Navis J930 - Padres de Design, Helder da Rocha. Steven John Metsker, Design Patterns Java Workbook. Addison-Wesley, 2002 Erich Gamma et al. Design Patterns: Elements of Reusable Object-oriented Software. AddisonWesley, 1995. http://blog.rafaelcapucho.com/java/padroes-de-projeto-observer-modelagem-uml.html (jan/2010) Artigo: Java e Reflection. Daniel Destro. http://www.guj.com.br/article.show.logic?id=10 (jan/2010) Artigo Junit - Alexandre Menezes Silva e Eduardo Manuel de Freitas Jorge. http://junit.wdfiles.com/local--files/start/JUnit.pdf e http://www.junit.org/ Fred Swartz - Homepage
http://leepoint.net/notes-java/GUI-lowlevel/graphics/40drawingpanel/30drawingpanel.html
(jan/2010) Paulino Shigueo Yoshida, Cludio Franco - Universidade Java Digerati Books

Programacao Orientada AObjetos 2010

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Programacao Orientada AObjetos 2010

Caricato da

Copyright:

Formati disponibili

ndice

Programao Orientada a Objetos (POO)

Descrio do Lpis Propriedades:

Resumindo a classe dos mamferos: Algumas propriedades:

Java trouxe solues para todas estes dilemas:

Definindo a tecnologia Java Segundo a Sun, a Tecnologia Java :

Uma linguagem de Programao Um ambiente de Desenvolvimento Um ambiente de Aplicao Um ambiente de Deployment

<applet code="DataHora.class" width=480 height=32>

De maneira macro, podemos dizer que a Tecnologia Java composta por:

Uma Linguagem de Programao; Ambientes de Desenvolvimento; Ambientes de Aplicao; Ambientes de Instalao/Configurao;

E est organizada nas seguintes reas:

Byte Code Verifier

Interpreter Runtime Hardware

Fonte: Gerncia de Memria em Java Parte I Hlder da Rocha (argonavis)

3. public class SantosFC { public static void main(String args[]){ } System.out.println("Santos

Campeo Paulista 2010 !")

4. Compile no Prompt do MS-DOS com o comando:

As seguintes declaraes tambm so vlidas:

Essa atribuio executada da direita para a esquerda, do z chegando ao x.

As variveis x e x2 possuem o mesmo valor com endereos de memria diferentes. d d2

// Estaremos alterando d2.dia para 2 tambm.

Operadores lgicos de conexo

(3 < 5) && (5 < 4) && (a == 5)

(4 < 3) || (5 > 2) || (7 < a) || (b != a)

Operador de Inverso de Bits: O operador

~ (Not bit a bit)

inverte os bits de tipos integrais, ou seja, converte 0 para 1 e 1 para 0.

//Imprime 10 //Imprime -11

//Imprime false //Imprime true

Imprime: 1.0 1 Finished executing

Imprime: 30 Santos F. C. Santos Campeo em 2010 Finished executing

1110 1110 110 1110 110 1110 110

<< >> >> >>>

=> => => =>

01110000 11110101 00000101 00010101

< <= > >=

menor que menor ou igual a maior que maior ou igual a

Vamos a alguns exemplos:

Os operadores de igualdade Comparando nmeros, booleanos ou variveis de referncia objetos.

Exemplo de uso de equals() e hashCode():

Imprime: a) b) c) d) e) f) r1 r1 r1 r1 r1 r1 diferente de igual a r2 igual a r2 diferente de diferente de diferente de r2 r2 r2 r2

Procure entender e explique cada uma das 6 sadas do programa.

ou exclusivo (XOR - or exclusive) ou lgico (OR lgico)

Usando as classes wrappers

A partir do Java 5 (autoboxing e unboxing)

Imprime: Tempo: 11,55 segundos O mesmo algoritmo usando apenas primitivos:

Imprime: Tempo: 0,92 segundos

Instrues de Programao Java

} else mensagem = "Voc um adolescente.";

Imprime: Opo selecionada = 's' ou 'S' Notas:

Imprime: Soma de inteiros entre 1 e 99: 4950 Finished executing

Imprime: Valor do contador: 100 Finished executing Notas:

" + i ); " + j ); + i ); + j ); // No compila

Imprime: Valor Valor Valor Valor Valor Notas:

interno interno interno interno externo

Instruo while Sintaxe: while ( <Exp> ) { <comandos> }

Imprime: Soma de inteiros entre 1 e 99: 4950 Finished executing

Imprime: Soma de inteiros entre 1 e 99: 4950 Finished executing

Instruo do/while Sintaxe: do { <comandos> } while ( <Exp> );

Imprime: Valor de i no final: 100 Finished executing

Imprime: Interaes: 2101 Finished executing

-Seg -Ter -Qui -Sex -Dom

Note que os dias Qua e Qui no foram impressos!