Escolar Documentos
Profissional Documentos
Cultura Documentos
Prefcio
Este livro foi originado a partir de nossas experincias com o ensino da linguagem Java em laboratrio nos Cursos de Extenso no Departamento de Informtica e Estatstica, Centro Tecnolgico, Universidade Federal de Santa Catarina. Desde sua primeira verso no primeiro semestre de 2000, algumas revises foram realizadas e aplicadas nos cursos dos anos subseqentes. A partir de 1996, o intercmbio de conhecimento utilizando a linguagem Java veio se consolidando no meio acadmico e empresarial. A introduo da linguagem Java no Departamento de Informtica e Estatstica, mais especificamente no Curso de PsGraduao em Cincia da Computao, ocorreu no ano de 1999. A partir desta poca, a linguagem Java foi sendo consolidada nos cursos de computao da UFSC, tanto graduao quanto ps-graduao, sendo utilizada em conjunto com outros paradigmas do meio computacional. Atualmente, a linguagem vem sendo bastante utilizada em implementaes nos trabalhos de concluso de curso de graduao, nas dissertaes de mestrado e teses de doutorado deste Departamento. No meio empresarial e corporativo, a cultura do Java vem se expandindo de uma forma gradual e constante, permitindo que diversas empresas desenvolvam aplicaes utilizando esta linguagem. Na literatura, j existem muitos livros explicando e utilizando a programao em Java, nos aspectos gerais, tanto em livros especficos, abordando APIs mais avanadas. Atualmente, em mbito nacional, existem publicaes peridicas referenciando detalhes da programao em Java. Este livro aborda a linguagem Java de uma forma mais objetiva, considerando o histrico da linguagem, as caractersticas principais, os seus fundamentos, a orientao a objetos em Java, programao de interfaces grficas, manipulao de programas para Web(Applets), simulao de processamento concorrente(Threads), programao em redes com Sockets e acesso a banco de dados utilizando o JDBC.
Pag.: 2
Agradecimentos
Gostariamos tambm de agradecer aos autores de livros da rea de Informtica, especialmente aos da Linguagem Java que passaram o seu tempo tentando escrever nas mais diversas linhas os conceitos e definies para que ns, simples aprendizes, pudssemos compreender e enfim utilizar a linguagem. Pontualmente, eu gostaria de agradecer aos autores do Livro Core Java 2 - Fundamentals, Sr. Horstmann e Sr. Cornell, pois considero este livro um dos melhores e mais bem explicados em relao a linguagem Java, assim tambm o recomendo a todos os interessados em se aprofundar nos conceitos da linguagem, e aproveito para mencionar que muitos dos exemplos e conceitos aqui escritos foram apreendidos do conteudo do citado livro. Ns gostaramos de agradecer aos alunos de graduao em computao da UFSC que ministraram a primeira experincia, a Daniela Vanassi de Oliveira (PPGCC-UFSC) pela contribuio inicial neste material e a Euclides de Moraes Barros Junior (PPGCC-UFSC), pelas participaes nos cursos de extenso, quando continuamos nossas experincias de ensino com a linguagem Java. Tambm agradecemos ao Departamento de Informtica e Estatstica de UFSC pela oportunidade de realizar os cursos de extenso. FEESC (Fundao de Ensino de Engenharia em Santa Catarina) pelo apoio na parte financeira e certificados. E queles que sempre nos apoiaram em todos os momentos, em especial, Olga Amparo Garcia de Barreiro (in memorium), Olga Maria Barreiro Claro e Antonio Carlos Claro Fernandez. Tambm agradecemos aos Grupos de Usurios Java que hoje so numerosos em todo o pas e que permitem uma troca de informaes entre a comunidade Java.
Pag.: 3
2008, Daniela Barreiro Claro e Joo Bosco Mangueira Sobral. Este livro, eventualmente utilizado por terceiros, participantes ou no da comunidade Copyleft Pearson Education, no pode ser alterado ou adaptado sem a devida autorizao dos respectivos autores, respeitando-se, sempre, o que prescreve a legislao autoral vigente, sendo intangveis os direitos morais dos autores, nos termos do que prescrevem os artigos 24 e seguintes da lei 9 610/98. Fica autorizada a utilizao deste material para qualquer fim que no o comercial desde que os seus autores sejam devidamente citados.
Pag.: 4
ndice
PREFCIO ........................................................................................................................... 2 AGRADECIMENTOS ......................................................................................................... 3 NDICE.................................................................................................................................. 4 1. ORIENTAO A OBJETOS ......................................................................................... 8 2. INTRODUO AO JAVA............................................................................................ 12 2.1 HISTRICO ................................................................................................................... 12 2.2 WEB X APLICATIVOS ...................................................................................................... 13 2.3 JAVA DEVELOPEMENT KIT - JDK .................................................................................. 13 2.4 MANIPULAO DO JDK(JAVA DEVELOPEMENT KIT) .................................................. 14 2.5 CARACTERSTICAS DA LINGUAGEM................................................................................. 15 2.6 COMPILAO DOS PROGRAMAS .................................................................................... 17 2.6.1 COMPILAO JAVA .................................................................................................... 17 2.6.2 COMPILAO DE OUTRAS LINGUAGENS ...................................................................... 17 2.7 AMBIENTES INTEGRADOS DE DESENVOLVIMENTO ........................................................... 17 2.7 AMBIENTES INTEGRADOS DE DESENVOLVIMENTO ........................................................... 18 2.8 INSTALAO DO COMPILADOR/INTERPRETADOR ( JDK ) ................................................ 18 2.9 ESTRUTURA DAS APLICAES JAVA................................................................................ 19 2.9.1 Elementos da Aplicao ...................................................................................... 20 Passagem de Parmetros da Linha de Comando......................................................... 21 3. FUNDAMENTOS DA LINGUAGEM ......................................................................... 22 3.1 COMENTRIOS ............................................................................................................. 22 3.2 PALAVRAS CHAVES ..................................................................................................... 22 3.3 TIPOS DE DADOS .......................................................................................................... 23 3.4 VARIAVEIS OU ATRIBUTOS ........................................................................................... 23 3.5 CONSTANTES ............................................................................................................... 24 3.6 OPERADORES ............................................................................................................... 24 3.6.1 Operadores Aritmticos....................................................................................... 24 3.6.2 Operadores Relacionais ...................................................................................... 24 3.6.3 Operadores Lgicos ............................................................................................ 25 3.6.4 Atribuio Composta........................................................................................... 25 3.6.5 Operadores Incremental e Decremental ............................................................. 25 3.6.6 Operador Ternrio .............................................................................................. 26 O VALOR DE A SERA MENOR , VISTO QUE 1 E MENOR QUE 2. .......................................... 26 3.7 CONVERSES COM TIPOS PRIMITIVOS.......................................................................... 26 3.8 CONTROLE DE FLUXO .................................................................................................. 28 3.8.1 Sentenas Condicionais....................................................................................... 28 3.8.2 Loops Indeterminados ......................................................................................... 29 3.8.3 Loops Determinados............................................................................................ 29 3.8.4 Mltiplas Selees ............................................................................................... 30 3.8.5 Manipulaes diversas ........................................................................................ 30
Pag.: 5
3.9 ARRAYS ....................................................................................................................... 31 3.10 STRINGS ..................................................................................................................... 32 4. ORIENTAO A OBJETOS EM JAVA .................................................................... 33 4.1 VANTAGENS DA OO EM JAVA ...................................................................................... 33 4.2 COMPONENTES DA ORIENTAO A OBJETOS ............................................................... 33 4.2.1 Atributos (Variveis) ........................................................................................... 34 4.2.2. Escopo de variveis ............................................................................................ 35 4.2.3 Mtodos ............................................................................................................... 35 #Modificadores de Acesso ............................................................................................ 37 4.2.4 Classes................................................................................................................. 37 4.2.5 Pacote .................................................................................................................. 38 4.2.6 Objetos................................................................................................................. 39 4.3 ATRIBUTOS DE INSTANCIA ........................................................................................... 40 4.4 METODOS DE INSTANCIA ............................................................................................. 40 4.5 ATRIBUTOS E MTODOS ESTTICOS (STATIC FIELDS / STATIC METHODS) .................. 41 4.5.1 Atributos Estticos............................................................................................... 41 4.5.2 Mtodos Estticos ou Mtodos de Classe ........................................................... 41 4.6 PASSAGEM DE PARAMETROS: POR VALOR E POR REFERENCIA ...................................... 43 4.7 HERANA .................................................................................................................... 44 4.8 CLASSES E MTODOS FINAL ........................................................................................ 48 4.9 CLASSES E MTODOS ABSTRATOS ............................................................................... 48 4.10 CONVERSES EXPLICITAS E IMPLICITAS .................................................................... 49 4.11 INTERFACES ............................................................................................................... 51 5. TRATAMENTO DE EXCEES ............................................................................... 52 5.1 CRIANDO UMA EXCEO ............................................................................................. 53 5.2 CLAUSULA THROWS .................................................................................................... 54 6. ABSTRACT WINDOW TOOLKIT - AWT ................................................................ 56 6.1 ELEMENTOS DA INTERFACE AWT ............................................................................... 58 6.2 TRATAMENTO DE EVENTOS ......................................................................................... 60 6.2.1 Classes de Eventos .............................................................................................. 61 6.2.2 Tratadores de Eventos ou Listeners .................................................................... 61 6.2.3 Classe Adapter..................................................................................................... 62 6.3 COMPONENTES E EVENTOS SUPORTADOS .................................................................... 63 7. INTERFACE GRFICA - SWING.............................................................................. 64 7.1 FRAMES ....................................................................................................................... 65 8. APPLETS ........................................................................................................................ 67 8.1 HIERARQUIA ................................................................................................................ 67 8.2 ESTRUTURA ................................................................................................................. 67 8.3 ARQUIVOS HTML ....................................................................................................... 68 8.4 EXECUTANDO UM APPLET ........................................................................................... 68 8.4.1 Passagem de Parmetros .................................................................................... 68 8.6 RESTRIES DE SEGURANA ....................................................................................... 69
Pag.: 6
8.7 PRINCIPAIS MTODOS .................................................................................................. 69 8.8 OBJETO GRFICO CLASSE JAVA.AWT.GRAPHICS........................................................ 70 8.9 FONTES ........................................................................................................................ 70 8.10 CORES........................................................................................................................ 70 9. PROCESSAMENTO CONCORRENTE - THREADS .............................................. 72 9.1 SINCRONIZAO .......................................................................................................... 75 10. SOCKETS ..................................................................................................................... 77 10.1 CLASSE SERVERSOCKET ............................................................................................ 78 10.2 CLASSE SOCKET ........................................................................................................ 78 11. ACESSO A BANCO DE DADOS - JDBC ................................................................. 80 11.1 VERSES DO JDBC.................................................................................................... 81 11.1.1 JDBC 1.0 ........................................................................................................... 81 11.1.2 JDBC 2.0 ........................................................................................................... 81 11.1.3 JDBC 3.0 ........................................................................................................... 81 11.2 TIPOS DE DRIVERS ..................................................................................................... 81 11.2.1 Driver JDBC Tipo 1 .......................................................................................... 81 11.2.2 Driver JDBC Tipo 2 .......................................................................................... 82 11.2.3 Driver JDBC Tipo 3 .......................................................................................... 82 11.2.4 Driver JDBC Tipo 4 .......................................................................................... 83 11.3 CLASSES DO JDBC CONEXO COM O BD ............................................................... 83 11.3.1 Driver ................................................................................................................ 83 11.3.2 DriverManager.................................................................................................. 83 11.3.3 java.sql.Connection ........................................................................................... 84 11.4 CLASSES JDBC ACESSO AO BD.............................................................................. 84 11.4.1 java.sql.Statement.............................................................................................. 84 11.4.2 java.sql.ResultSet............................................................................................... 85 11.4.3 java.sql.PreparedStatement............................................................................... 85 11.5 JDBC 2.0................................................................................................................... 86 11.5.1 Scrollable ResultSet........................................................................................... 86 11.5.2 Atualizaes de Dados via Programao ......................................................... 87 11.5.3 Consultas com o SQL 3 ..................................................................................... 87 12. REFERNCIAS BIBLIOGRFICAS ....................................................................... 88 LINKS ................................................................................................................................ 88 LIVROS .............................................................................................................................. 88 13. BIBLIOGRAFIA DOS AUTORES............................................................................. 89
Pag.: 7
Orientao a Objetos
1. Orientao a Objetos
Inovaes tecnolgicas surgidas na rea de Informtica tm criado uma necessidade de utilizao e manipulao de informaes que antigamente no eram utilizadas. Os tipos de dados complexos, como os objetos, passaram a ser manipulados atravs das linguagens de programao, que passaram a receber a conotao de Linguagem de Programao Orientada a Objetos. A programao estruturada, em se tratando, principalmente, de manuteno de sistemas, possui taxas de reutilizao muito baixas, dificultando a manuteno dos programas anteriormente desenvolvidos. A orientao a objetos tem como objetivo principal modelar o mundo real, e garantir que as taxas de manutenibilidade (manuteno) sero maiores diante deste contexto. Isso possvel, pois utilizando uma linguagem de programao orientada a objetos consegue-se obter um desenvolvimento mais rpido, visto que este desenvolvimento ocorre em mdulos, em blocos de cdigos correspondentes aos objetos e seus acoplamentos. Atravs da orientao a objetos pode-se obter uma maior qualidade e agilidade no desenvolvimento, pois o fator reusabilidade (reutilizao) permite que se re-utilize outros objetos que foram anteriormente desenvolvidos e podem ser facilmente incorporados na aplicao. A reusabilidade tambm garante uma manuseabilidade melhor do programa, pois os testes referentes aos componentes, j foram previamente executados, garantindo assim a utilizao coesa dos objetos. A orientao a objetos surgiu na dcada de 60, baseada na Teoria dos Tipos da lgebra, mas somente na dcada de 90 comeou a ser amplamente utilizada computacionalmente. Ela tem como principio fundamental representar o mundo real e a forma de se interagir com os objetos. Mas, o que um objeto? Atualmente, h milhares de milhares de objetos que se pode tocar e perceber. Agora mesmo, voc est tocando em um objeto denominado livro e posso garantir que deste livro que voc est nas mos, somente h um exemplar. H um modelo deste livro, que responsvel pela criao do mesmo em srie, mas este livro, que est nas suas mos, idntico, que possui um grifo de lpis (caso voc j tenha dado um) somente h um, este nas suas mos. esta a caracterstica principal dos objetos, eles so nicos e somente h um nico objeto no mundo. Vamos pensar no mundo dos automveis. Pensemos em uma montadora de veculo, onde h uma fbrica de automveis. Cada automvel que sai desta fbrica nico, identificado por um nmero de chassi. O meu carro nico, o nico que possui um arranho na parte traseira esquerda ... Por mais que tenha diversos carros iguais ao meu, com a mesma cor, da mesma marca, mesma categoria, o meu carro nico, por ter caractersticas que somente pertencem a ele. E assim so os objetos. E as classes ? As classes so como se fossem as montadoras, quem detm a receita de como montar, quem contm o molde dos carros, uma abstrao do carro. Na verdade a classe contm os moldes do carro, e no o carro propriamente dito. No caso de oreintao a objetos, as classes so as monytadoras dos objetos. As classes so vistas como agrupamento de objetos que contm as mesmas caractersticas e os mesmos comportamentos.
Pag.: 8
Orientao a Objetos
Os objetos ou as classes possuem caractersticas que determinam quem eles realmente so, pensemos em um bolo de chocolate, onde a receita possui caractersticas que determinam a receita como os ingredientes. Abstramos um pouco este bolo, e imaginemos a receita como sendo a Classe, e o bolo pronto como sendo o objeto. Os ingredientes so parte da receita, assim so caractersticas de uma receita e poderemos denominar eles de atributos da Classe Receita. E o modo de preparo do bolo? O modo de preparo do bolo mtodo que vamos utilizar para elaborar o bolo. Assim, o modo de preparo o mtodo. E o bolo pronto, assado, cheirando, como j dissemos anteriormente ele o objeto, e nico, pois se voc for fazer este mesmo bolo e seguir a mesma receita, provavelmente o seu bolo ser melhor que o meu, pois ficar mais solto na assadeira, tem uma cor melhor, mais amarela, gosto saboroso. E estas caractersticas do bolo pertencem somente ao meu ou ao seu bolo, assim so atributos do objeto, tambm denominado de atributos de instncia (CAMERA, 2002). Assim, atravs destes exemplos podemos observar os fundamentos da Orientao a Objetos. Cada objeto tambm pode se comunicar entre si, atravs da troca de mensagem. A troca de mensagens entre objetos pode ser abstrada como a aplicao de mtodos em determinados objetos. Por exemplo, quando um objeto A deseja que o objeto B execute um dos seus mtodos, o objeto A envia uma mensagem ao objeto B, como segue na Figura 1.
Mensagem
Objeto B
Objeto A
Figura 1. Troca de mensagens entre os objetos. Mensagens e mtodos[operaes] so os dois lados da mesma moeda. Mtodos so os procedimentos que so invocados quando um objeto recebe uma mensagem Greg Voss Outro conceito muito importante da Orientao a Objetos o encapsulamento das informaes. Atravs do encapsulamento se pode ocultar informaes irrelevantes para os outros objetos que interagem com estes objetos. O encapsulamento permite que os atributos de uma determinada classe somente sejam modificados utilizando mtodos que interajam com o mesmo. Assim, as modificaes atravs dos mtodos garantem que no h manipulaes indevidas aos atributos. Sempre que for possvel garantir que os atributos sejam encapsulados e a manipulao deles ocorra atravs de mtodos, o faa. A herana mais uma caracterstica do mundo real incorporado no mundo orientado a objetos. um mecanismo que define variveis e mtodos comuns a todos os objetos de um certo tipo. No mundo real h os nossos pais, nossos avs e nossos filhos e netos. Onde alguma pessoa sempre lhe diz que voc se parece mais com o seu pai ou com a sua me, e seus filhos e netos sempre herdam algum comportamento do pai ou da me ou ainda dos avs paternos ou maternos...enfim, a herana uma transmisso dos caracteres fsicos ou morais aos descendentes (FERREIRA, 1993) Assim, a partir de uma determinada classe, pode-se ter subclasses e superclasses. As subclasses no so limitadas aos estados e comportamentos definidos pela superclasse,
Pag.: 9
Orientao a Objetos
elas podem adicionar variveis e mtodos ao seu escopo. Entre estas caractersticas da herana, a manipulao das classes que herdam mtodos e atributos permite que se modularize o cdigo de tal forma que cada objeto tem uma funcionalidade prpria e garante assim uma coeso das informaes. Outro conceito adicional da orientao a objetos utilizado em Java o polimorfismo, onde pode-se definir duas abordagens como: sobreposio(override) e sobrecarga(overload). A sobreposio ocorre quando duas ou mais classes derivadas de uma mesma superclasse podem invocar mtodos que possuem a mesma identificao(assinatura), mas comportamentos distintos. Enquanto que a sobrecarga dos mtodos ocorre quando em uma mesma classe, mtodos possuem os mesmos nomes, mas assinaturas diferentes, um exemplo disso so os mtodos construtores do Java, que sero abordados mais adiante neste livro. As interfaces, outro conceito importante e bastante utilizado nas implementaes das Interfaces Grficas no Java, so invlucros que promovem a interao de contatos externos, com ou sem passagem de dados, com um processamento interno. (CAMARA, 2002) Um usurio somente precisa saber o que o objeto capaz de fazer, mas no interessa como ele dever ser feito. Assim, a interface permite que se utilize o conceito do encapsulamento, onde somente as assinaturas dos mtodos esto disponveis para exibio aos usurios. Podemos criar uma estrutura mais prxima da manipulao de classes e objetos dentro da linguagem Java, como podemos ter uma classe PESSOA que possui atributos (caractersticas) tais como: cor_de_olho, cor_de_cabelo, idade. Esta classe PESSOA tambm possui mtodos (aes, comportamentos) tais como: faz_aniversario, pinta_cor_de_cabelo.
Instanciando esta classe PESSOA, obtemos o que chamamos de objeto, ou seja: daniela = new PESSOA ( ); bosco = new PESSOA ( ); Cada objeto tem suas caractersticas (atributos) particulares, por exemplo: daniela.cor_de_olho = verde; daniela.cor_de_cabelo= castanho escuro; daniela.idade = 27; Enquanto que o objeto antonio possui outros valores para seus atributos. bosco.cor_de_olho = castanho;
Pag.: 10
Orientao a Objetos
bosco.cor_de_cabelo bosco.idade = preto; = 55;
Em relao aos mtodos, estes so utilizados para modificar/manipular os valores dos atributos, segue um exemplo: daniela.faz_aniversario ( ); O mtodo faz_aniversario implementa um procedimento onde ir somar mais um no atributo idade de daniela. Exemplo: faz_aniversario( ) { daniela.idade = daniela.idade+1; } daniela.pinta_cor_cabelo(preto); Este segundo mtodo age sobre o objeto daniela e realiza a ao de pintar a cor do cabelo passando como parmetro a cor desejada. Assim, atravs de classes, objetos, atributos, mtodos, dentre outras caractersticas da orientao a objetos, consegue-se modelar o mundo real e abstrair informaes incorporando-as linguagem Java.
Pag.: 11
Introduo ao Java
2. Introduo ao JAVA
Java a linguagem de programao orientada a objetos, desenvolvida pela Sun Microsystems, capaz de criar tanto aplicativos para desktop, aplicaes comerciais, softwares robustos, completos e independentes, aplicativos para a Web. Alem disso, caracteriza-se por ser muito parecida com C++, eliminando as caractersticas consideradas complexas, dentre as quais ponteiros e herana mltipla.
2.1 Histrico
Em 1991, um pequeno grupo de funcionrios da Sun incluindo James Gosling mudou-se para a San Hill Road, uma empresa filial. O grupo estava iniciando um projeto denominado Projeto Green, que consistia na criao de tecnologias modernas de software para empresas eletrnicas de consumo, como dispositivos de controle remoto das TV a cabo. Logo o grupo percebeu que no poderia ficar preso as plataformas, pois os clientes no estavam interessados no tipo de processador que estavam utilizando e fazer uma verso do projeto para cada tipo de sistema seria invivel. Desenvolveram ento o sistema operacional GreenOS, com a linguagem de programao Oak. Eles se basearam no inventor do Pascal, atravs da linguagem USCD Pascal, que foi o pioneiro da linguagem intermediria ou mquina virtual. Em 1993, surgiu uma oportunidade para o grupo Green, agora incorporado como FirstPerson a Time-Warner, uma empresa que estava solicitando propostas de sistemas operacionais de decodificadores e tecnologias de vdeo sob demanda. Isso foi na mesma poca em que o NCSA lanou o MOSAIC 1.0, o primeiro navegador grfico para Web. A FirstPerson apostou nos testes de TV da Time-Warner, mas esta empresa preferiu optar pela tecnologia oferecida pela Silicon Graphics. Depois de mais um fracasso, a FirstPerson dissolveu-se e metade do pessoal foi trabalhar para a Sun Interactive com servidores digitais de vdeo. Entretanto, a equipe restante continuou os trabalhos do projeto na Sun. Apostando na Web, visto que os projetos estavam sendo todos voltados para a WWW, surgiu a idia de criar um browser com independncia de plataforma, que foi o HotJava. Como a equipe de desenvolvimento ingeria muito caf enquanto estavam trabalhando, vrias xcaras de caf foram inseridas at que o projeto estivesse pronto. Finalmente em maio de 1995, a Sun anunciou um ambiente denominado Java (homenagem s xcaras de caf) que obteve sucesso graas a incorporao deste ambiente aos navegadores (browsers) populares como o Netscape Navigator e padres tridimensionais como o VRML (Virtual Reality Modeling Language Linguagem de Modelagem para Realidade VIrtual). A Sun considera o sucesso do Java na Internet como sendo o primeiro passo para utilizlo em decodificadores da televiso interativa em dispositivos portteis e outros produtos eletrnicos de consumo exatamente como o Java tinha comeado em 1991. Sua natureza porttil e o projeto robusto permitem o desenvolvimento para mltiplas plataformas, em ambientes to exigentes como os da eletrnica de consumo. A primeira verso da linguagem Java foi lanada em 1996.
Pag.: 12
A utilizao do JDK feita da seguinte forma: primeiro escreve-se o programa fonte em Java, utilizando qualquer editor de texto ou IDE para Java como Eclipse, JCreator, JBuilder, JDeveloper, Bloco de Notas, TextPad(com pluggins), dentre outros. A seguir, o programa deve ser compilado utilizando o compilador javac: javac <nomedoarquivo.java>
A compilao gera o arquivo em cdigo binrio (bytecode ), com extenso .class. Uma vez compilado, basta executar o programa. Se for uma aplicao, utilizar o interpretador java: java <nomedaclasse> Exemplo: java Teste
Pag.: 13
Introduo ao Java
As IDEs para Java j tem o compilador (javac) e o interpretador (java) embutido no aplicativo, o que basta clicar em botes ou usar teclas de atalho para compilar e interpretar os programas desenvolvidos.
Sendo um Applet, deve-se construir uma pgina HTML para abrigar o applet e carreg-la atravs de um browser ou do appletviewer (visualidador de applets Java): appletviewer <nomedoarquivo.html> Exemplo: appletviewer Teste.html Cdigo fonte Java AppletTeste.java Criao da pgina HTML para o Applet AppletTeste.html
Bytecode AppletTeste.class
Pag.: 14
Pag.: 15
Introduo ao Java
Coletor de Lixo Garbage Colector Se no houver nenhuma referncia a um objeto que tenha sido criado na memria, o coletor de lixo destri o objeto e libera a memria ocupada por ele. O coletor de lixo executado de tempos em tempos. Quando a JVM percebe que o sistema diminuiu a utilizao do processador, ela-JVM- faz com que o coletor de lixo execute e este vasculha a memria em busca de algum objeto criado e no referenciado. Em Java nunca se pode explicitamente liberar a memria de objetos que se tenha alocado anteriormente. O mtodo abaixo PROPOE/SUGERE que a JVM vai utilizar recursos para reciclar objetos que no so mais utilizados. Mas no garante que daqui a 1 milisegundo ou 100 milisegundos o Garbage Collection vai coletar todos os objetos em desuso. Runtime.gc(); System.gc(); O Garbage Collector uma grande vantagem para desalocao de memria, que um grande inconveniente para programadores que trabalham com ponteiros e necessitam liberar o espao alocado, visto que o proprio sistema que se encarrega desta limpeza, evitando erros de desalocao de objetos ainda em uso. Segura O Java fornece uma srie de mecanismos para garantir a segurana dos aplicativos. Um programa em Java no tem contato com o computador real; ele conhece apenas a mquina virtual (JVM). A mquina virtual decide o que pode ou no ser feito. Um programa Java nunca acessa dispositivos de entrada e sada, sistema de arquivos, memria, ao invs disso ele pede a JVM que acesse.
Pag.: 16
Introduo ao Java
Pag.: 17
Apesar das facilidades, a utilizao destes ambientes pode trazer alguns inconvenientes como: a criao visual de componentes como botes, caixas de texto, barras de rolagem e outros, especificamente de um ambiente. Alguns ambientes incorporam grande quantidade de cdigo na aplicao e uma hierarquia interna de organizao dos pacotes, que obriga a aplicao final a carreg-los consigo. Particularidades dos produtos tambm criam uma dependncia que contraria os princpios de Java. Outro ponto a ser observado a grande abstrao provocada sobre o domnio da aplicao, ou seja, o programador acaba inserindo na aplicao possveis bugs (erros de programao) dos ambientes e no tem controle para corrig-los, e muitas vezes nem detect-los. Assim, mais razovel sempre ter domnio direto do cdigo que se est desenvolvendo. Dessa forma, a utilizao do JDK diretamente, gera aplicaes mais robustas e enxutas.
Pag.: 18
Introduo ao Java
set classpath=%classpath%;.; O .; significa justamente que voc esta setando o diretorio corrente, ou seja o diretorio onde voc esta localizado. Por exemplo, se voc esta localizado no diretorio c:\daniela\arquivos, e voc seta o classpath com o .; como se voce estivesse setando o proprio diretorio, como segue: set classpath=%classpath%; c:\daniela\arquivos; A variavel de ambiente CLASSPATH serve justamente para identificar o caminho das classes.
class NomeDaClasse { // Atributos // Mtodos public static void main( String[] args ) { //corpo principal do programa } }
Claro que uma classe Java tera somente a classe, os mtodos contendo a parte do mtodo main.
e seus atributos, no
Uma aplicao em Java caracterizada por possuir um mtodo main(). O mtodo main o mtodo chamado pelo interpretador Java quando executado. A declarao do mtodo deve ser rigorosamente: public static void main( String[] args), onde define um mtodo de classe de acesso pblico, sem retorno, que recebe como parmetro um array de Strings de tamanho indefinido, representado pela varivel args. O args a declarao do objeto do Array de String, por isso pode ser atribudo a ele qualquer nome. A disposio dos atributos e mtodos feita de forma aleatria, ou seja, no importa a ordem, apenas necessitam respeitar regras de validade de escopo das variveis, assunto abordado posteriormente. Abaixo demonstrada uma primeira aplicao que somente imprime na tela uma mensagem qualquer. Seguem os passos para construo da aplicao: 1. Abrir um editor de textos ou um IDE Java e escrever o programa class OlaMundo { public static void main( String[] args ) { //corpo do programa //Escreve na tela: Ola Mundo. System.out.println(Ola Mundo); } }
Pag.: 19
Introduo ao Java
2. Salvar o arquivo dando a ele o mesmo nome da classe e com a extenso .java. Salvar arquivo com nome OlaMundo.java. 3. Compilar o arquivo javac OlaMundo.java
A compilao gerou um arquivo OlaMundo.class, que o bytecode, o arquivo a ser executado. 4. Execute o programa utilizando o interpretador Java, e deve imprimir na tela Ola Mundo java PrimeiraApp
2.9.1 Elementos da Aplicao public um quantificador do mtodo que indica que este acessvel externamente a esta classe (por outras classes que eventualmente seriam criadas). Este tpico ser abordado posteriormente. static um qualificador que indica que este mtodo um mtodo de classe, ou seja, h uma cpia somente por classe. Os mtodos static podem ser invocados, mesmo quando no for criado nenhum objeto para a classe, para tal deve-se seguir a sintaxe: <NomeCasse>.<NomeMetodoStatic>(argumentos) void Semelhante ao void do C/C++, corresponde ao valor de retorno da funo. Quando a funo no retorna nenhum valor ela possui a palavra reservada void no local de retorno, uma espcie de valor vazio que tem que ser especificado.
main um nome particular do mtodo que indica para o compilador o incio do programa, dentro deste mtodo e atravs de interaes entre os atributos e argumentos visveis nele que o programa se desenvolve. String[] args o argumento do mtodo main e por conseqncia, do programa todo, um array de Strings que formado quando so passados ou no argumentos atravs da invocao do nome do programa na linha de comando do sistema operacional. { .... }
Pag.: 20
Introduo ao Java
Abre chaves e fecha chaves: delimitam um bloco de cdigo (semelhante a BEGIN e END em Pascal). System.out.println Chamada do mtodo println para o atributo out da classe System. O argumento uma constante do tipo String. println assim como o writeln de Pascal, imprime na saida padro a String e posiciona o cursor na linha abaixo, analogamente print no avana a linha.
Passagem de Parmetros da Linha de Comando Aplicaes em Java permitem que se passem parmetros atravs da linha de comando. Os parmetros so separados por espao em branco. Para passar um parmetro com espaos em branco deve coloc-lo entre aspas duplas. Os parmetros so passados para as aplicaes atravs do array de Strings do mtodo main. Atravs do mtodo length pode-se verificar o nmero de parmetros passados. O acesso feito indicando-se a posio no array, sempre iniciando em 0. O mtodo length() do parmetro args[x], permite que se obtenha o tamanho da String passada para este parmetro. Segue um exemplo: class AppParametro { public static void main (String[] args){ System.out.println("Parametros:"+args[0]+""+args[1]+""+ args[2]); System.out.println("Tamanho terceiro parametro:"+ args[2].length()); System.out.println("Quantidade Parametros:"+args.length); } } Caso o programa acima fosse executado com os seguintes parmetros: java AppParametro Daniela Claro Menina bonita Os valores que seriam impressos na tela do DOS seriam : Parametros:Daniela Claro Menina Bonita Tamanho terceiro parametro:13 Quantidade Parametros:3
Pag.: 21
Fundamentos da Linguagem
3. Fundamentos da Linguagem
3.1 Comentrios
O Java suporta comentrios como C. Qualquer informao especificada entre os caracteres de comentrio ser ignorada pelo compilador. Os tipos de comentrios so os seguintes: Comentrio de bloco /* texto */ Todo o texto ignorado. Este tipo de comentrio pode ocupar vrias linhas. Comentrio de Linha // texto Todo o texto depois de // at o final da linha ser ignorado. Comentrio do JavaDoc /** Comentrio para documentao */ Este ultimo um tipo especial de comentrio que vai armazenar as diretivas para a gerao automtica da documentao das classes, utilizando o JAVADOC. A regras que tratam dos comentrios so: Comentrios no podem ser aninhados No podem ocorrer dentro de Strings ou literais As notaes /* e */ no tem significado especial dentro dos comentrios //. A notao // no tem significado especial dentro dos comentrios /* e /**.
Pag.: 22
4 Tipos Inteiros
2 ponto flutuante
1 Tipo Caracter
1 Tipo Booleano
float
double
char
boolean
Estes tipos primitivos possuem tamanhos distintos e so caracterizados como segue na Tabela 1. Tipo Tamanho byte 8 bits short 16 bits int 32 bits long 64 bits float 32 bits double 64 bits char 16 bits boolean Tabela 1. Tipos primitivos de dados Exemplos -128, 127, 0 32768, -110, 49, 50 2145848556, 23, 29 987654367765, -1L 0.2329, -654.213, 78.9 35423.4589, 9999999 i, *, !, d true, false
Pag.: 23
Fundamentos da Linguagem
A atribuio feita atravs do operador =: <identificador> = <valor>; Exemplos: int diasFerias, outroInteiro; double salario; float umFloat = 0.5; char letra = i; boolean achou = false; diasFerias = 30; ....
Os tipos de dados juntamente com as variveis podem ser declarados e somente depois inicializados com valores determinados, como segue o exemplo da varivel diasFerias. Na primeira linha: int diasFerias; //Somente a declarao da varivel ou atributo diasFerias = 30; //Inicializao da varivel com o valor 30
3.5 Constantes
As constantes em Java so definidas atravs da palavra reservada FINAL. Esta palavra reservada tem por caractersticas atribuir somente uma vez o valor varivel. Para determinar que uma varivel uma constante, basta inserir a palavra reservada no inicio da definio da mesma. As constantes em Java tm por caracterstica e estilo serem escritas em caixa alta e inicializadas com um determinado valor, como segue: final double AUMENTO = 5,25;
3.6 Operadores
3.6.1 Operadores Aritmticos Os operadores aritmticos so como outros operadores de outras linguagens tradicionalmente conhecidas. Exemplos deles so mostrados na tabela 2. Operador Nome + Adio Subtrao * Multiplicao / Diviso % Mdulo Tabela 2. Operadores Aritmticos Exemplo 23+29 29-23 0.5 * salrio 100/42 57/5
3.6.2 Operadores Relacionais Os operadores relacionais permitem que se realizem comparaes entre os operadores.
Pag.: 24
Fundamentos da Linguagem
Operador Nome == Igual != Diferente < Menor > Maior >= Maior ou igual <= Menor ou igual Tabela 3. Operadores Lgicos 3.6.3 Operadores Lgicos Operador && || ! ^ ?: & | Nome AND OR NOT XOR Condicional AND binrio OR Binrio Exemplo (0 < 2) && ( 10 > 5) ( 10 >11 ) || (10 < 12 ) !( 1= = 4 ) ( 1!= 0) ^ ( 3< 2 ) 3>2? (comandoSe):(comandoSeno) 3(00000011) & 2(00000010)= 2(00000010) 3(00000011) | 2(00000010)= 3(00000011) Exemplo 10 == 10 3 != 2 4 < 10 10 > 6 3 >= 3 5 <= 6
A diviso retorna um inteiro se os argumentos forem inteiros, mas se forem de outro tipo retorna um ponto flutuante. Segue abaixo um exemplo: 15/2 = 7 15.0 / 2 = 7,5
3.6.4 Atribuio Composta Para facilitar a programao, Java oferece um tipo de atribuio chamada atribuio composta. Esse tipo de atribuio pode ser utilizado quando se deseja atribuir a uma varivel X, o valor de X adicionado a 10, por exemplo. Exemplos: x += 10; x += y; a -= b; a *= 3;
// // // //
x x a a
= = = =
x x a a
+ + *
10; y; b; 3;
3.6.5 Operadores Incremental e Decremental Os operadores incremental e decremental tambm foram desenvolvidos para facilitar a programao. O Java oferece uma maneira simples para fazer o incremento ou decremento em variveis. O incremento dado pelo operador ++ e o decremento pelo operador --. Este decremento ou incremento pode ser feito antes ou depois da utilizao da varivel, dependendo da necessidade do programador em relao a atribuio do dado. Colocando os operadores antes das variveis ser realizado primeiro a operao para depois o valor da varivel ser utilizado. Ao contrrio, caso o operador esteja localizado
Pag.: 25
Fundamentos da Linguagem
aps a varivel, ser realizado primeiramente a varivel para depois ser realizado o incremento ou o decremento da varivel. Exemplos: i++; //Equivalente i--; //Equivalente ++i; //Equivalente --i; //Equivalente
a: a: a: a:
i i i i
= = = =
i i i i
Estes operadores quando utilizados isoladamente no oferecem problemas aos programadores. Mas quando utilizados dentro de expresses, eles podem causar confuses e mau entendimentos quanto aos resultados da apresentao. Abaixo segue um exemplo deste problema(CORNELL, 2002): int int int int a b x y = = = = 7; 7; 2 * ++a; 2 * b++;
Qual o valor dos resultados? a=8, b=8, x=16 e y=14 3.6.6 Operador Ternrio O operador ternrio permite que se realize operaes simplificadas de condies. Uma condio trabalhada no Java como IF-THEN-ELSE, pode ser manipulada atravs do operador ternrio. O operador ternrio formado por uma condio, e em caso positivo, executada uma ao e em caso negativo, outra ao pode ser executada. x<y ? e1:e2 onde, x<y a condio, e em caso positivo ser executado e1 e em caso negativo ser executado e2. Segue abaixo um exemplo com valores: String a = 1<2 ? Menor : Menor O valor de
Pag.: 26
Fundamentos da Linguagem
char
byte
short
int
long
float double Converso sem perda de informao(implcita) Converso com provvel perda de informao (explcita) Por exemplo, caso existam duas variveis, uma do tipo short e outra do tipo int. Existem duas possibilidades para esta converso: Exemplo: short varshort; int varInt; varInt = varShort; varShort = varInt; menor que int
Durante a compilao do cdigo acima, um erro de tipos incompatvel ser gerado pelo compilador por tentar atribuir uma varivel maior (varInt) para uma menor (varShort). Como esse tipo de operao faz perder valores ou informaes de preciso, o Java faz voc declarar explicitamente que voc est consciente da converso que deseja fazer. Neste caso, necessrio realizar uma converso explcita, visto que para o compilador no ser possvel realizar a converso de um int para short. O cdigo acima pode funcionar com o acrscimo do cast de tipo. O cdigo correto seria: short varshort; int varInt; varInt = varShort; varShort = (short) varInt;
Neste caso, varInt que tem 32 bits perder 16 bits na converso. Converses de Tipos Primitivos(CORNELL, 2002) Tipo Destino Tipo Original byte short int long byte short C, P int C, P C, P long C, P C, P C, P float C, P C, P C, P C, P double C, P C, P C, P C, P char C, P C C C boolean X X X X C Utilizar cast explcito P perda de magnitude ou preciso X Java no permite converso
float
double
C, P C, P C X
char C C C, P C, P C, P C, P X
C X
boolean X X X X X X X
Pag.: 27
3.8.1 Sentenas Condicionais # Declarao IF As sentenas condicionais so determinadas pela estrutura IF-ELSE, onde no Java podese observar atravs do comando IF, como exemplificado abaixo: Sintaxe: if ( boolean ) declarao1; else declarao2; Exemplo: if (fim == true) System.out.println(Trmino!); else System.out.println(Continuando...); Para mais de um comando ser executado depois da declarao, utiliza-se o conceito de blocos, delimitados por chaves { }. A declarao IF pode ser tambm utilizada quando a condio no satisfeita como o ELSE, exemplificado abaixo: Exemplo: if (fim == true){ cont = 0; System.out.println(Trmino); } else { cont = cont +1; System.out.println(Continuando...); }
A condio ELSE, sempre trabalha com o IF mais prximo delimitado por um bloco de cdigo. if (x>0) if (y>=0) sinal=0; else sinal=1;
Pag.: 28
Fundamentos da Linguagem
3.8.2 Loops Indeterminados Os loops indeterminados so representados por laos de repetio que contm uma condio de sada. # Declarao WHILE Utilizada quando no se quer que o corpo do lao seja necessariamente executado. A expresso de comparao avaliada antes que o lao seja executado. Sintaxe: while (booleano) declarao; Exemplo: while ( i != 0 ){ salario = salario * 0.5; i--; }
Declarao DO - WHILE Utilizada quando se quer que o corpo do lao seja necessariamente executado, pelo menos uma vez. A expresso de comparao avaliada depois que o lao for executado. Sintaxe: do declarao while (booleano); Exemplo: do { salario = salario * 0.5; i--; } while ( i != 0 );
3.8.3 Loops Determinados Os loops determinados so responsveis por executar um trecho de cdigo por uma quantidade de vezes pr-determinada. Declarao For Fornece uma expresso para inicializar as variveis, seguida por uma expresso de comparao e depois um lugar para incrementar ou decrementar as variveis de lao. A declarao pode ser um comando simples ou um bloco de comandos. Sintaxe: for
Exemplo:
Pag.: 29
Fundamentos da Linguagem
for (i = 0; i < 20; i ++) salario = salario * 0.5; As variveis que so definidas dentro da sentena FOR, no podem usar os seus valores fora do loop. Isso ocorre, pois a varivel perde o escopo, visto que est sendo definida para ser utilizada dentro do lao FOR.
3.8.4 Mltiplas Selees Declarao Switch Aceita inteiro na expresso de comparao. Mas, como pode haver as converses implicitas (cast implcitos) pelo compilador, ele passa a aceitar tambm os tipos char, byte, short ou int. Esse valor procurado nas declaraes case que vem depois da declarao switch e o cdigo adequado executado. Sintaxe: switch ( expresso ) { case valor: declarao; ... default: declarao; } Exemplo: switch ( cmd ){ case 1: System.out.println(Item do menu 1); break; case 2: System.out.println(Item do menu 2); break; case 3: System.out.println(Item do menu 3); break; default: System.out.println(Comando invalido!); } O comando break deve ser colocado ao final de cada clusula case, pois seno todas as condies que forem satisfeitas, sero executadas. Ou seja, caso a condio do switch tenha uma condio que satisfeita por mais de um case, todos que satisfizerem esta condio sero executados. Por isso, o break importante para garantir que quando um case for satisfeito, mais nenhum deles sero executados tambm.
3.8.5 Manipulaes diversas # Declarao Return Declarao utilizada para transferir controle. Retorna informaes de mtodos, encerrando a execuo e retornando para o local de onde o mtodo foi chamado. Sintaxe: return expresso; Exemplo: class Teste{ public int Potencia ( int base, int n){ int result = base; for ( int i = 0; i < n-1; i ++ )
Pag.: 30
Fundamentos da Linguagem
result = result * base; return result; } } # Declarao break e continue Declaraes de desvio usada para sair de um lao ou mtodo antes do normal. O tipo determina para onde transferido o controle. O break utilizado para transferir o controle para o final de uma construo de lao (for, do, while ou switch). O lao vai encerrar independentemente de seu valor de comparao e a declarao aps o lao ser executada. Exemplo: int i = 0; while (true) { System.out.println(i); i++; if ( i > 10 ) break; } A declarao continue faz com que a execuo do programa continue voltando imediatamente para o incio do lao, porm para a prxima interao. Exemplo: for (int i = -10; i<10; i++){ if ( i == 0 ) continue; System.out.println(1/i); }
3.9 Arrays
Um array normalmente usado para armazenar um grupo de informaes semelhantes. Todos os itens de um array devem ser do mesmo tipo em tempo de compilao. Se o array for formado por tipos primitivos, eles devem ser todos do mesmo tipo. Arrays so inicializados com o uso do operador new. Pense em cada elemento do array como um objeto distinto. O tipo mais simples de array um array de dimenso de um tipo primitivo por exemplo, um int. O cdigo para criar e inicializar esse array segue abaixo: int[] nums = new int [5]; Os colchetes depois do tipo de dado int, dizem ao compilador que um array de inteiros. O operador new instancia o array e chama o construtor para cada elemento. O construtor do tipo int e pode conter cinco elementos. Arrays podem ser multimensionais. Durante a instanciao, um array multidimensional deve ter pelo menos uma de suas dimenses especificadas. A seguir, exemplos de como criar um array bidimensional. Exemplo: int [][] numlist = new int [2][]; int[][] lista = new int[5][5];
Pag.: 31
Fundamentos da Linguagem
Arrays podem ser inicializados na hora da criao, colocando-se os valores inicias desejados entre chaves {}. No necessrio especificar o tamanho Java ir inicializar o array com o nmero de elementos especificados.
Exemplo: int[] nums = {1, 2, 3, 4, 5}; int[][] nums = {(1,1), (2,2), (3,3), (4,4), (5,5)}; Os arrays podem ser indexados por um valor byte, short, int ou char. No se pode indexar arrays com um valor long, ponto flutuante ou booleano. Se precisar usar um desses tipos deve-se fazer uma converso explcita. Os arrays so indexados de zero at o comprimento do array menos um. long sum( int [] lista ){ long result = 0; for ( int i = 0; i < lista.length; i++ ){ result = result + lista[i]; } return result; }
3.10 Strings
Uma String um tipo definido pela classe String e contm mtodos e variveis. Uma String a unica classe que pode ser instanciado sem usar o operador new. A seguir exemplos da utilizao de strings. Exemplo: //criao do String String str = Hello; int inteiro = 4; String novo = str + valor do inteiro: + inteiro; //Concatenao de strings //extrao dos cinco primeiros caracteres do string novo String substr = novo.substring(5);
Pag.: 32
Pag.: 33
Pag.: 34
4.2.2. Escopo de variveis O escopo de uma varivel/atributo o bloco de cdigo dentro do qual ela/ele acessvel e determina quando foi criada e destruda. Basicamente, o que define o escopo de uma varivel o bloco onde ela se encontra. O bloco determinado por chaves { }. A figura abaixo ilustra o escopo de variveis no Java: Escopo de
{
...... declarao de atributos class MinhaClasse ...... public void Metodo(parametros) {
......
declarao de variveis locais
4.2.3 Mtodos Um mtodo em Java uma sub-rotina como as funes de C e Pascal. Os mtodos tm um tipo de retorno e podem receber parmetros. O modificador esttico declara que o mtodo ter um determinado tipo de comportamento dentro do programa orientado a objetos. Na declarao de um mtodo os modificadores precedem o tipo de retorno, que precede o nome do mtodo e a lista de parmetros. O corpo do mtodo colocado entre chaves. <modificadores do mtodo> tipo_retorno nome_mtodo (<parmetros>) { corpo do mtodo } O corpo do mtodo pode conter declaraes de variveis e de comandos. As variveis no ficam restritas a declarao somente antes dos comandos, como acontece em C, ao contrrio, podem ser declaradas em qualquer lugar. O tipo de retorno de um mtodo pode
Pag.: 35
class Parametro { public int adicionaDois(int i){ i = i+ 2; System.out.println("Valor de i " + i ); return i; } public static void main (String[] args ){ int i = 11; System.out.println("Valor inicial de i " + i ); //cria objeto da classe Parametro oParam = new Parametro(); //mtodo AdicionaDois, resultado colocado em j int j = oParam.adicionaDois(i); //Mostra os valores de i e de j System.out.println("Valor de j " + j ); System.out.println("Valor final de i " + i ); } } Caractersticas Especiais # THIS Os mtodos possuem caractersticas especiais e tem a principal funcionalidade de acessar os atributos privados do objeto. Segue um exemplo de um mtodo abaixo: public void aumentarSalario(double percentual){ double aumento = salrio*percentual/100; salrio += aumento; } Implcito: o prprio objeto O mtodo acima possui dois parmetros: Explcito: percentual O prprio objeto sempre passado pelo mtodo mas de uma maneira no visvel ao usurio. Este mesmo mtodo acima pode ser visto como sendo : meuObjeto.aumentoSalario(double percentual) Onde o meuObjeto se refere ao objeto ao qual est chamando este mtodo e dentro do mtodo pode ser referenciado por uma palavra reservada denominada this. O mesmo mtodo pode ser reescrito utilizando o this como segue abaixo, evidenciando assim manipulao do atributo corretamente. public void aumentarSalario(double percentual){ double aumento = this.salrio*percentual/100; this.salrio += aumento; }
Pag.: 36
#Modificadores de Acesso Modificadores de acesso ou regras de acesso so utilizadas na declarao de classes, mtodos e atributos. So classificados como modificadores de acesso e de cunho geral. private a forma de proteo mais restritiva. Permite acesso apenas a mesma classe, ou seja, visvel somente na classe. Utilizado pelos atributos da classe, permitindo que outros objetos ou classes somente acessem estas caracteristicas atraves da manipulao de mtodos.
public Permite acesso por todas as classes, sejam elas do pacote corrente ou no. Normalmente utilizados pelos mtodos dentro de uma classe. Permite que todos faam manipulaes dos atributos atravs dos metodos publicos. Garantindo assim o encapsulamento das informaes. protected Permite acesso por todas as classes que esto no mesmo pacote e s subclasses de fora do pacote. Sem modificador Permite acesso por todas as classes do mesmo pacote.
4.2.4 Classes As classes contm os atributos e os mtodos e ainda so responsveis pela estrutura dos objetos. Os objetos, por sua vez, so as instncias das classes.
Pag.: 37
4.2.5 Pacote Pacotes contm classes e duas outras entidades de Java que veremos posteriormente: excees e interfaces. Uma funo inicial de um pacote como a de um container. Eles tm o papel de fornecer ao compilador um mtodo para encontrar classes que se precisa para compilar o cdigo. No mtodo System.out.println, System uma classe contida no pacote java.lang, junto com String. Se a declarao import no for utilizada e desejarmos utilizar alguma classe externa, ser necessrio colocar o caminho da classe a cada acesso. Exemplo: import java.lang.*; O asterisco no final diz ao compilador para importar todas as classes do pacote java.lang Esse um dos vrios pacotes includos na API. O compilador Java define implicitamente um pacote para as classes no diretrio atual e o importa implicitamente. Esse o motivo pelo qual no precisamos colocar explicitamente as classes que escrevemos em um pacote. Para colocarmos determinada classe em um pacote, devemos inserir a diretiva package com o nome do pacote no incio da classe. Exemplo: package Teste; class Simples { public void Metodo( ) { } } No nosso exemplo acima, o pacote java.lang.* o unico pacote no Java que no precisamos fazer a importao dele. Ou seja, se quisermos utilizar por exemplo a classe
Pag.: 38
4.2.6 Objetos Os objetos so as instancias das classes e atravs deles podemos manipular os mtodos e atributos de um objeto. A declarao de uma varivel ocorre da seguinte maneira: Modelo: <Classe> <identificador>; Exemplo: Date data; Esta declarao no um objeto, mas simplesmente uma definio do tipo da varivel data. Como a varivel data no se trata de um objeto, a mesma no pode se referenciar aos mtodos e atributos do objeto. Neste caso NO se pode realizar o seguinte cdigo: Date data; data.toString(); Isso no pode ocorrer visto que data ainda no um objeto. Para se obter um objeto, necessrio inicializar a varivel e para inicializar esta varivel necessrio utilizar o operador new().
Modelo: <identificador> = new <Classe> ( [param1], [param2] ); Exemplo: Data data = new Data(); O new cria uma referncia para um objeto, e esta referencia armazenada na varivel do objeto. As variveis de objetos locais no so automaticamente inicializadas para null, por isso devem ser inicializadas explicitamente com o operador new() ou com o valor null. Claro que podemos declarar e instanciar um objeto simultaneamente: <Classe > < identificador> = new <Classe> ( [param1], [param2] ); Exemplos: ... Empresa emp; emp = new Empresa( nome, end ); .... ou ... Empresa emp = new Empresa( nome, end ); ....
O acesso a mtodos e atributos igualmente simples e realizado atravs do operador ponto ".".
Pag.: 39
Pag.: 40
4.5.2 Mtodos Estticos ou Mtodos de Classe A declarao de mtodos de classe idntica a declarao de mtodos de instncia, exceto pela incluso da palavra reservada static precedendo cada um.
1 Este exemplo, como muitos outros presentes neste livro, foi adaptado do livro Core Java 2 (CORNELL, 2002), por ser considerado, por mim(Daniela), um dos melhores livros de Java que ja utilizei. Inclusive adotado nas Universidades onde lecionei, por ser didatico e muito explicativo.
Pag.: 41
[modificadores] static <tipoRetorno> <nomeMetodo> ( [<tipoParamN> <ident.ParamN>, .... ] ) [throws <ClasseThrowableN>,....]; Exemplo: class Exemplo{ static void ImprimeMsg( ){ System.out.println("Requisio invlida!"); } }
Os mtodos estticos operam com as classes, no trabalham no nvel de objetos. Assim, no se pode trabalhar com o THIS, visto que este contm o valor da referncia do objeto. Ainda assim no se pode acessar atributos de instancia dentro de mtodos estticos, somente se pode manipular atributos estticos. public static int getNextId(){ nextId++; } Os mtodos de classe ou mtodos estticos so usados em duas situaes: Quando um mtodo no necessita acessar o estado dos seus objetos, pois todos os parmetros necessrios so parmetros explcitos. Quando um mtodo somente precisa acessar atributos de classe.
4.5.3 Mtodos Destrutores Cada classe pode ter um destrutor. O destrutor chamado quando o objeto jogado para a coleta de lixo, portanto no se sabe quando o destrutor ser chamado. Esse um bom local para fechar arquivos, liberar recursos da rede enfim encerrar algumas tarefas. O destrutor em Java chamado finalize. Ele no possui tipo de retorno e no assume nenhum parmetro. class Teste{ finalize ( ){ //tarefas a serem encerradas } }
4.5.4 Mtodos Construtores So mtodos especiais, executados automaticamente toda vez que uma nova instncia da classe criada. So utilizados para realizar toda a inicializao necessria a nova instncia da classe. A declarao semelhante a qualquer outro mtodo, a no ser pelo nome dos mtodos construtores ser o mesmo da classe e eles no possurem um tipo de retorno. class Empresa{ String nome; String endereo,
Pag.: 42
Pag.: 43
4.7 Herana
O conceito de herana vem do mundo real, onde todos ns herdamos caractersticas dos nossos pais e parentes. Sempre anexado herana o conceito de -UM. Gerente UM Empregado onde, Gerente -um Empregado. Em Java, ns simbolizamos o um atravs da palavra reservada extends. class Gerente extends Empregado As subclasses em Java possuem mais funcionalidades que suas superclasses, pois as subclasses possuem as caractersticas herdadas e as suas prprias caractersticas. class Gerente extends Empregado{ private double bnus; public void setBonus(double d){
Pag.: 44
No FUNCIONA!!!
Os atributos privados definidos na classe Empregado, somente podem ser acessados pela classe Empregado. O Gerente, poder acessar o mtodo getSalario(). Isso garante o encapsulamento das informaes. Para acessar o mtodo getSalario() da superclasse, necessrio usar uma palavra reservada denominada SUPER. SUPER uma palavra chave utilizada para acessar mtodos da superclasse. O super direciona o compilador para invocar um mtodo da superclasse. Normalmente ele utilizado no caso de herana, e que se deseja que a classe filha utilize os recursos da classe Pai. public class Carro{ public void LavaCarro( ){ //comandos para lavar o carro } } public class Gol extends Carro{ public void LavaCarro( ){ super.LavaCarro( );//Acessa mtodo da classe Carro } }
Pag.: 45
Tambm se pode utilizar o super com o construtor, porm ele deve sempre ser a primeira sentena do construtor, como no exemplo a seguir: public class Carro{ String carro, sabao, local; public Carro( String nome){ //Mtodo construtor carro = nome; sabao = "marca"; local = "lavajato"; } } public class Gol extends Carro{ public Gol ( ){ super ( "gol" ); //Acessa construtor da classe Carro } } Quando nenhuma superclasse declarada explicitamente, Java assume automaticamente que a Superclasse a classe Object, ou seja, toda classe Java filha, no minimo, da classe Object.
Classe Object
Classe Pai
Classe Outra
Classe Filho
Classe Filha
Classe Neta
Figura 7. Demonstrao da Hierarquia de Classes
Segue abaixo a descrio em codigo Java do esquema mostrado acima na Figura 7. class Pai { ....... } class Filho extends Pai { ....... } class Filha extends Pai { ....... } class Neta extends Filha {
Pag.: 46
Para cada indice deste array nos vamos colocar uma instancia de empegado., como segue: emp[0] emp[1] emp[3] = chefe; = new Empregado(Pedro,5000); = new Empregado(Joo,3000);
Neste caso, o primeiro indice nos populamos com um empregado especial que foi chefe, pois devido herana nos vimos que Chefe um Empregado. Nos podemos fazer estas associaes pois Empregado uma super classe de Gerente, ento como se nos tivssemos uma caixa grande Empregado, e conseguimos colocar uma caixa menor chamada Gerente dentro, como segue abaixo:
Empregado
Gerente
Figura 8: Representao das superclasses e subclasses Assim, se nos mandarmos executar o metodo getSalario que contem nas duas classes sobrescrito, onde na classe Gerente ele alterado para somar mais o bonus, quais seriam os nossos resultados?[CORNELL, 2002] for(int i..){ Empregado e = emp[i]; System.out.println(e.getNome + e.getSalario()); }
Pag.: 47
Pag.: 48
Universidade
Escola Superior
Porm no exemplo da Figura 9, instituio uma entidade ficticia que existe no papel e no fisicamente. Instituio uma abstrao de Universidades e Escolas Superiores. Assim, em relao aos atributos, sabemos que uma instituio tem nome e endereo, mas como ela abstrata nao poderemos implementar ou seja, efetivamente dar o valor estes atributos. Neste caso, nos utilizamos a nomenclatura abstract para designar que estes metodos no sero implementados na classe Instituio, mas sim nas classes filhas, como Universidades e Escola Superior. Neste caso, na classe Instituio nos declararemos a assinatura do mtodos, como segue: public abstract String getNome(); public abstract String getEndereco(); E nas classes filhas poderemos implementar o mtodo. Se um mtodo dentro de uma classe abstrato, necessariamente a classe deve ser abstrata. Mas se uma classe ela abstrata, ela no precisa ter metodos abstratos, podem ter todos os mtodos concretos. Quando se herda de uma classe abstrata, nos podemos seguir dois caminhos: 1 No utilizar nenhum mtodo abstrato, assim a subclasse deve ser tambem uma classe abstrata 2- Pode-se implementar todos os mtodos, dai a subclasse no precisa ser abstrata. Porm, uma classe abstrata ela no podera ser instanciada, ou seja, nenhum objeto pode ser criado como instancia desta classe. Os objetos somente podem ser criados baseado em classes concretas, mas eles podem ser definidos. Vamos considerar o nosso exemplo da Figura 9, onde definiremos que instituio uma classe abstrata, e as duas filhas, Universidade e EscolaSuperior so classes concretas. Assim nos poderemos ter:
Classe abstrata
Classe concreta
Pag.: 49
Empregado
Gerente
O cast em relao aos objetos necessario quando ocorre o processo inverso, ou seja, nos desejamos converter de uma subclasse para uma superclasse. Como se no nosso exmplo quisessemos colocar a classe Empregado(retangulo) dentro da classe Gerente(elipse). Neste caso o compilador nos mostrara uma mensagem onde informara que isso nao permitido. Mas se voce desejar fazer isso de qualquer jeito, voc devera ento utilizar o CAST, ou seja, a converso explicita. O cast so pode ser utilizado com s classes que possuem uma relao de hierarquia. Gerente chefe = (Gerente) empregado[1]; Uma boa pratica de programao utilizar o mtodo instanceOf para garantir se um objeto uma instancia de determinada classe e se positivo dai faz o cast, a converso explicita. if(emp[1] instanceOf Gerente){ chefe = (Gerente)emp[1]; ... } Atravs desta boa maneira de programao, citada por Cornell(2002), evitamos erros de querer fazer um CAST de uma classe Instituio, por exemplo, para uma classe Gerente, o que no possivel, visto que no existe uma relao de hierarquia entre elas. Segue um exemplo que NO possivel: Instituio c = (Instituio)emp[1]; Isso no possivel !
Pag.: 50
4.11 Interfaces
As interfaces em Java so responsaveis por descrever as assinaturas dos mtodos e no como eles sero implementados. Alm disso, a utilizao das interfaces permite que simulemos a herana multipla, pois uma classe pode implementar uma ou mais interfaces. Assim, uma interface a reunio das assinaturas dos mtodos, sem definies reais. Isto indica que uma classe tem um conjunto de comportamentos (vindo da interface), alm dos que recebe de sua superclasse. Uma interface no uma classe, mas pode ser considerada um conjunto de requisitos que uma classe deve estar em conformidade. Segue um exemplo de criao de uma interface: public interface Festa{ void fazBolo(int tamanho); } Neste caso, toda classe que implementar a interface Festa, deve implementar o mtodo fazBolo(). Alm disso, todos os mtodos da interface so automaticamente publicos, no sendo necessario colocar a palavra reservada PUBLIC neles. Em uma classe, a interface sera definida depois da palavra reservada implements. Uma classe pode implementar diversas interfaces, como dito acima, simulando assim a herana multipla. Porm, a classe deve implementar todos os mtodos de cada interface, pois eles nunca so implementados na propria Interface, mas sempre nas classes que herdam delas. Outrossim, as interfaces no possuem atributos de instancia ou tambm chamados de atributos de objetos, e essa uma das diferenas ja encontradas para as classes abstratas, onde os mtodos tambm no so implementados na classe abstrata, mas nas classes que as herdam. Alm disso, uma diferena muito importante entre as interfaces e as classes abstratas que nas interfaces somos obrigados a implementar todos os mtodos, mesmo que so utilizemos um deles. E nas classes abstratas, podemos implementar somente o mtodo necessario a nossa utilizaao. Segue um exemplo desta diferena: public interface Festa { void fazBolo(int tamanho); boolean encherBolas(int quantidade); int convidarPessoa(String nome); } class Aniversario implements Festa { ... } Assim, a classe Aniversario obrigatoriamente tera que implementar todos os trs mtodos propostos pela interface Festa, mesmo que para este Aniversario voc so deseje fazer o bolo.
Pag.: 51
Tratamento de Exceo
5. Tratamento de Excees
A elaborao de programas utilizando a linguagem Java, envolvendo assim o desenvolvimento das classes e interfaces com seus mtodos e objetos retratam a maneira normal de desenvolvimento e no inclui qualquer caso especial ou excepcional. Na verdade, o compilador nada pode fazer para tratar condies excepcionais alm de enviar avisos e mensagens de erro, caso um mtodo seja utilizado incorretamente. A utilizao de excees permite manipular as condies excepcionais do programa, tornando mais fcil o tratamento e a captura de erros. Assim, o tratamento de uma exceo uma indicao de um erro ou uma exceo. Os erros so tratados nos lugares que eles podem ocorrer, dentro do proprio codigo. O tratamento de exceo projetado para lidar com erros sincronos, que vm de dentro do programa. No tratam de erros assincronos, como o trmino de uma operao E/S em um disco. O bloco elementar do tratamento de exceo o TRY CATCH, como segue o exemplo abaixo: try{ ... }catch(Tipo da Exceo) { ... } O bloco TRY pode ter um ou mais CATCH. Se nenhuma exceo for disparada, todos os CATCH so pulados e o processamento volta para a primeira linha de excuo depois do tratamento, ou seja, depois do bloco TRY-CATCH. A instruo try diz basicamente "Tente executar o cdigo dentro destas chaves e se excees forem lanadas, vou captura-las de acordo com os tipos definidos. Cada um permite manipular qualquer e todas as excees que so instncias das classes listadas entre parnteses. Segue um exemplo de um tratamento de exceo basico:
class ExcecaoBasico{ public static void main(String[] args){ try { int a = 2/0; }catch (Exception e ){ System.err.println("Aconteceu um problema:"+e); } } }
Quando uma exceo capturada, o bloco CATCH executado. E a classe EXCEPTION, como a superclasse das excees, deve ficar por ultimo, em se tratando da captura de multiplas excees. O bloco TRY-CATCH pode ainda conter outro elemento e se transformar no bloco TRYCATCH-FINALLY. A clusula FINALLY utilizada quando h uma alguma ao que no importa o que ocorra, a mesma ter que ser executada. Geralmente isso se refere a liberar algum recurso externo aps sua aquisio, com a finalidade de fechar um arquivo, uma conexo com o banco de dados, assim por diante. E ela tambm pode ser usada juntamente com a clusula CATCH, se referindo ao fato de uma no conformidade tenha ocorrido A diferena do FINALLY que ele SEMPRE sera executado, caso HAJA uma exceo ou caso NO HAJA uma exceo. Porm, o FINALLY opcional, ou seja, o TRY-
Pag.: 52
Tratamento de Exceo
CATCH obrigatorio, e podera ter ou no a clausula FINALLY. Segue abaixo um exemplo com o FINALLY:
try{ System.out.println("Tentando executar o codigo."); }catch (Exception e){ System.err.println("Excecao capturada:"+e); }finally{ System.err.println("Finally executado!"); }
Pag.: 53
Tratamento de Exceo
numero2 = new TextField(); numero2.setBounds(60,100,80,30); add(numero2); btnOk = new Button("Execute!!"); btnOk.setBounds(160,100,70,30); add(btnOk); btnOk.addActionListener(this); } public void teste(){ try { a = Integer.valueOf(numero1.getText()).intValue(); b = Integer.valueOf(numero2.getText()).intValue(); resultado = a / b; if (b < 0) throw new Exception(); Message.texto("Este o resultado:"+ resultado); Message.setVisible(true); } catch (ArithmeticException e){ Message.texto("Gerou uma exceo Aritmetica - Diviso por zero"); Message.setVisible(true); }catch (NumberFormatException e){ Message.texto("Gerou uma exceo no Numero da diviso"); Message.setVisible(true); }catch (Exception e){ Message.texto("Gerou uma exceo Geral:"+ e); Message.setVisible(true); } } public void actionPerformed(ActionEvent e){ if (e.getSource() == btnOk){ teste(); } } public static void main (String args[]){ GeraExcecao form = new GeraExcecao(); form.setVisible(true); } }//Fechamento da classe
A classe Throwable a classe responsavel pelos erros e excees gerados no Java. Ela possui como subclasses ERROR e EXCEPTION. Os erros gerados da classe ERROR no so capturados, somente os erros da classe EXCEPTION deve ser capturados dentro da execuo do programa.
Pag.: 54
Tratamento de Exceo
super("Foi gerada uma excecao devido a Divisao por zero"); } DivisaoPorZero(String msg){ super(msg); } } public class Excecao2{ public static void main(String[] args) throws DivisaoPorZero { try { int a=0, b = 0; if (b!=0){ a = a/b; }else{ throw new DivisaoPorZero(); } }catch (DivisaoPorZero e ){ System.err.println("Aconteceu um problema:"+e); System.err.println("PrintMessage:"+e.getMessage()); e.printStackTrace(); }catch (Exception f ){ System.err.println("Capturou excecao normal:"+f); } } }
A programao Java foi desenvolvida para trabalhar com excees, com a classe Exception. As excees herdadas da classe Runtime Exception so excees geradas normalmente pela programao mal feito do programador. O importante capturar as excees para que elas no sejam lanadas fora dos mtodos. Segue a estrutura hierarquica das excees(Cornell,2002):
Throwable
Error
Exception
I/O Exception
RuntimeException
Em relao s classes e mtodos herdados, caso um mtodo de uma superclasse seja sobrescrito em uma subclasse, as excees lanadas pelo mtodo da superclasse so herdadas pela subclasse. O mtodo na subclasse somente pode lanar as excees da superclasse ou menos, mas no podera lanar mais exceoes que existem na superclasse.
Pag.: 55
Pag.: 56
Normalmente preciso agrupar os objetos visuais antes de coloc-los na tela. Para agrupar componentes so utilizados Containers. Containers so componentes que podem abrigar outros componentes, inclusive outros Containers. Exemplos: Panel, Applet, Frame, Dialog. Os Containers herdam da classe Component, mas so usados como objeto para conter outros elementos visuais. O mtodo add() adiciona componentes ao Container (diferentes opes de utilizao esto disponveis na API).
Pag.: 57
Button setLabel(String l) Define o texto do boto String getLabel() Retorna o texto do boto
Pag.: 58
TextArea setText(String t) Define o texto da rea String getText() Retorna o texto da rea setEditable(boolean b) Define se a rea pode ser editada ou no appendText(String s) Adiciona a string ao final do texto Checkbox setLabel(String l) Adiciona a string ao final do texto String getLabel() Retorna o texto do checkbox setState(boolena b) Define o estado do checkbox true = on, false = off boolean getState() Retorna o estado do checkbox
Choice addItem(String i) Adiciona um item ao choice String getItem(int pos) Retorna o item da posio pos int getItemCount() Retorna o nmero de itens no choice int getSelectedIndex() Retorna a posio do item selecionado String getSelectedIntem() Retorna o item selecionado como um String removeAll() Remove todos os itens
List addItem(String i) Adiciona um item a lista String getItem(int pos) Retorna o item da posio pos
Pag.: 59
int getItemCount() Retorna o nmero de itens na lista int getSelectedIndex() Retorna a posio do item selecionado String getSelectedIntem() Retorna o item selecionado removeAll() Remove todos os itens da lista Frame setTitle(String t) Define o titulo do frame setResizable(boolean b) Define se o frame pode ser redimensionado ou no setIconImage(Image img) Define o icone para o frame setMenubar(Menubar mb) Define a barra de menu para o frame
Dialog setTitle(String t) Define o titulo do dialogo setResizable(boolean b) Define se o dilogo pode ser redimensionado ou no setModal(boolean b) Define se a janela modal ou no
Pag.: 60
6.2.2 Tratadores de Eventos ou Listeners Tratadores de Eventos ou Listeners so objetos de qualquer classe que implementem uma interface especfica para o tipo de evento que deseja tratar. Essa interface definida para cada classe de eventos. Ento para a classe de eventos java.awt.event.FocusEvent existe a interface java.awt.event.FocusListener. Para a classe de eventos java.awt.event.WindowEvent existe a interface java.awt.event.WindowListener e assim sucessivamente. As interfaces para tratamento de evento da AWT (pacote java.awt.event) so apresentadas a seguir com seus respectivos mtodos (chamados conforme o tipo de evento).
Mtodos actionPerformed(ActionEvent) adjustmentValueChanged(AdjustmentEvent) EventDispatched(AWTEvent) componentHidden(ComponentEvent) componentMoved(ComponentEvent) componentResized(ComponentEvent) componentShow(ComponentEvent) componentAdded(ContainerEvent) componentRemoved(ContainerEvent) focusGained(FocusEvent) focusLost(FocusEvent) caretPositionChanged(InputMthodEvent) inputMethodTextChanged(InputMethodEvent) itemStateChanged(ItemEvent)
Pag.: 61
MouseListener
Um componente que deseja que um evento seja tratado, deve especificar quem so os tratadores para o evento, atravs do mtodo add<tipo>Listener( ).Quando um evento ocorrer, a Mquina Virtual Java identificar o tipo de evento e, se houver algum listener para o evento, repassar o evento para ele. Por exemplo, o tratamento para o pressionamento de um boto que um evento de ao. Deve-se escolher quem vai tratar o evento e implementar a interface java.awt.event.ActionListener nesta classe. Ainda, deve-se adicionar o listener aos tratadores de evento de ao do boto, utilizando botao.addActionListener(<objetoActionListener>).
6.2.3 Classe Adapter Quando construirmos classes especficas para o tratamento de eventos e estas no possuem uma superclasse, podemos utilizar classes Adapter para facilitar a implementao. Classes Adapter so classes abstratas que implementam os mtodos das interfaces que possuem dois ou mais mtodos. A grande vantagem de utilizar classes Adapter que no necessrio implementar todos os mtodos, o que na interface eles so obrigatorios, mesmo que no sejam utilizados. Utilizando as classes abstratas, deve-se apenas sobrescrever os mtodos que tenham que realizar alguma tarefa. As classes Adapters e seus respectivos tratadores de eventos so ilustradas a seguir:
Pag.: 62
Pag.: 63
Applets
Pag.: 64
Applets
No Swing, os componentes so mais lentos para aparecer na tela que os componentes AWT. Porm, nas mquinas atuais, estas diferenas no chega a ser um problema. Razes para utilizar o Swing: Maior e melhor conjunto de elementos para Interfaces do usurio Menos dependente da plataforma Menos bugs especificos da plataforma Mais robusto, mais caractristicas, maior portabilidade importante destacar que no se deve misturar componentes AWT com Swing.
7.1 Frames
Os frames so a janela mais alta da hierarquia, ou seja, no est inserida em nenhuma outra janela. Porm, os frames so containers, ou seja, eles podem conter outros componetes da Interface do usurio, como botoes, campos de texto, etc. Na verso do Swing, o nome do componente JFrame que estende a classe Frame. Segue um exemplo de manipulao: class PrimeiraInterface extends JFrame{ public PrimeiraInterface(){ setSize(300,200); } Descreve o que public static void main(String[] args){ deve ser feito PrimeiraInterface frame = new PrimeiraInterface(); quando o usurio frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); fechar o frame. frame.show(); } Os frames iniciam sua vida invisiveis(para } permitir adicionar componentes, antes de
mostrar eles pela primeira vez).Logo, o show() deixa o frame visivel e coloca sempre em primeiro plano.
A manipulao de componentes dentro do AWT e do Swing so diferentes. No AWT para adicionar componentes ao Frame, nos utilizamos diretamente o mtodo ADD. No Swing, todos os componentes devem ser adicionados dentro de um CONTENT PANE, como segue: Container contentPane = frame.getContentPane(); frame.setContentPane(c); onde c o componente.
Pag.: 65
Applets
Em relao ao tratamento de eventos, o Swing manipula a verso a partir do Java 1.1. Para isso aplicaes Swing utilizam as classes Adapter para manipulao dos eventos e tambm as InnerClasses, ou seja, as classes que no possuem instancias declaradas, so classes que as instancias existem, mas no so definidas em um objeto pre-determinado. Segue abaixo um exemplo de tratamento de eventos utilizando a nova verso com as classes Adpter: frame.addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){ System.exit(0); } }); Neste exemplo acima, graas a classe Adapter utilizada, nos no precisamos tratar todos os 7 mtodos da WindowListerner, visto que nos estamos manipulando a WindowAdapter que uma classe abstrata. Se estivessemos manipulando a interface WondowListener, nos teriamos que tratar cada um dos 7 metodos pertencente nesta interface, mesmo se nos fossemos utilizar somente o mtodo WindowClosing.
Pag.: 66
Applets
8. Applets
Applets so programas Java embutidos em pginas HTML. Quando uma pgina HTML carregada e identificada a presena de um applet nessa pgina, o browser carrega tambm a classe Java do applet e o executa. Todas as classes utilizadas pelo applet tambm so carregadas pelo browser.
8.1 Hierarquia
java.lang.Object | +--java.awt.Component | +--java.awt.Container | +--java.awt.Panel | +--java.applet.Applet
8.2 Estrutura
Um applet deve possuir a seguinte estrutura: import java.applet.Applet; public class <NomeDaClasse> extends Applet { //corpo do Applet } A classe Applet est no pacote java.applet, devendo portanto ser incluida para acessar seus mtodos. As applets tambm podem pertencer ao pacote do Swing, e o nome da mesma passa a ser JApplet. Alguns mtodos so chamados automaticamente pelo interpretador: init(): chamado quando o mtodo carregado ou descarregado star(): chamado toda vez que a pgina que contm o applet visitada paint(): chamado sempre que for necessrio desenhar o applet stop(): chamado quando a pgina que contm o applet for substituda destroy(): chamado quando todos os recursos do sistema precisam ser liberados. Por exemplo: quando o browser fechado. Esse mtodos esto definidos na classe java.applet.Applet , porm no tm funcionalidade. Dessa forma, deve-se redefinir esses mtodos ou alguns deles. Ao contrrio das aplicaes, quando um applet carregado criada uma instncia da classe a que ele pertence. Quando um applet carregado, chamado o construtor do applet, depois os mtodos init(), start() e paint(). Quando abandona-se a pgina, o mtodo stop() chamado e posteriormente o mtodo destroy(). Os mtodos init() e start() podem ser considerados os pontos de entrada de um applet.
Pag.: 67
8.4.1 Passagem de Parmetros Parmetros so passados de pginas HTML para applets atravs da tag <PARAM> que deve estar entre <APPLET> e </APPLET>. A tag <PARAM> possui os atributos: NAME: indica o nome do parmetro VALUE: indica o valor do parmetro
<APPLET CODE=...> <PARAM NAME=NomeParam1 VALUE=ValorParam1 > <PARAM NAME=NomeParam2 VALUE=ValorParam2 > ... </APPLET >
Pag.: 68
Applets
Dentro do applet, os parmetros so recuperados atravs do mtodo getParameter(). Geralmente, mas no necessariamente, o cdigo para recuperao dos parmetros passados feito no mtodo init(). ... public void init() { ... param1 = getParameter(NomeParam1); param2 = getParameter(NomeParam2); ... } ... Segue um exemplo mais completo da applet:
import java.applet.*; import java.awt.*; public class ParamApplet extends Applet{ String codigo; public void init(){ codigo=getParameter("codigo"); } public void paint(Graphics g){ g.drawString("Codigo: "+codigo ,20,20); } }
Pag.: 69
Applets
Retorna o valor do parmetro nomeParam ShowStatus(String msg) Mostra a msg na barra de status do browser String getDocumentBase() Retorna o endereo da pgina HTML String getCodeBase() Retorna o endereo do applet Image getImage(URL url) Retorna a imagem da url especificada GetAppletContext() Retorna o contexto onde o applet est inserido
8.9 Fontes
A classe utilizada para representar fontes a classe java.awt.Font. A descrio de uma fonte feita especificando-se o nome, estilo e tamanho da fonte. Font f = new Font (<nomeFonte>, <estilo>, <tamanho>); O nome da fonte pode ser: Dialog, DialogInput, Monospaced, Serif, SansSerif ou Symbol. O estilo da fonte pode ser: Font.PLAIN, Font.BOLD ou Font.ITALIC. A maioria dos componentes AWT possuem os mtodos setFont() e getFont() para definir e para retornar a fonte do componente. Trocando a fonte do objeto grfico: public void paint(Graphics g){ g.setFont(new Font(Symbol, Font.BOLD, 14)); }
8.10 Cores
Pag.: 70
Applets
A classe Java para representar cores a classe java.awt.Color. Uma maneira de aproveitar a classe Color aproveitar as cores j definidas na classe. Essas cores so basicas como: Color.white, Color.blue, Color.black, Color.lightGray, Color.red e etc.Outra maneira criar uma instancia de Color, passando valores entre 0.0 e 1.0 para compor uma cor no padro RGB. A seguir as trs maneiras: Color c1 = Color.white; Color c2 = new Color(255, 0, 0); Color c3 = new Color( 0.0f, 1.0f, 0.0f ); A maioria dos componentes AWT possuem mtodos setForeground(), getForeground(), setBackground() para definio e retorno das cores de frente e de fundo utilizadas. Para trocar a cor do objeto grfico: public void paint(Graphics g ){ g.setColor(Color.red); }
Pag.: 71
Pag.: 72
public class Thread1 extends Applet implements ActionListener, Runnable{ Button btnOk; TextField edNome; Label lbTitulo; Label lbMensagem; Panel pnSaida; MessageBox mensagem; Thread appClock; public void init(){ setLayout(null); setSize(400,300); setBackground(Color.gray); pnSaida = new Panel(); pnSaida.setBounds(20,20,330,40); pnSaida.setBackground(Color.yellow); add(pnSaida); lbTitulo = new Label("Gerador de Mensagens"); lbTitulo.setBounds(170,25,200,40); pnSaida.add(lbTitulo); lbMensagem = new Label("Mensagem:"); lbMensagem.setBounds(20,80,80,30); add(lbMensagem);
Pag.: 73
edNome = new TextField("Daniela Claro"); edNome.setBounds(20,110,200,24); add(edNome); btnOk = new Button("Mostra Mensagem!"); btnOk.setBounds(250,90,120,40); add(btnOk); btnOk.addActionListener(this); } public void start(){ appClock = new Thread(this, "Clock"); appClock.start(); } public void run(){ while (appClock == Thread.currentThread()) { repaint(); } } public void paint(Graphics g){ Calendar cal = Calendar.getInstance(); Date data = cal.getTime(); DateFormat dateFormatter = DateFormat.getTimeInstance(); g.drawString(dateFormatter.format(data),5,10); } public void actionPerformed(ActionEvent e){ if (e.getSource() == btnOk){ mensagem = new MessageBox(edNome.getText()); mensagem.setVisible(true); showStatus(edNome.getText()); } } } O mtodo de classe currentThread() pode ser chamado para obter a thread na qual um mtodo est sendo presentemente executado. Freqentemente, dentro dos mtodos chamados pelo mtodo run() necessitar saber qual a thread que est em atual execuo.
public class Sequencia implements Runnable{ public void run(){ while(true){ System.out.println(Thread.currentThread().getName()); } } public static void main (String args[]){ Sequencia form = new Sequencia(); new Thread(form, "Primeira Sequencia").start(); new Thread(form, "Segunda Sequencia").start(); } } O mtodo yield() (ceder) d uma chance de iniciar a execuo, a qualquer outra Thread que queira ser executada. Se no houver threads esperando para serem executados, o thread que realiza o yield() simplesmente continuar.
Pag.: 74
9.1 Sincronizao
Aplicativos com multiplas linhas de execuo tem que compartilhar o acesso aos mesmos objetos, ou seja, cada linha pode chamar um mtodo que modifica o estado do objeto. Neste caso, o paralelismo desejvel e poderoso, mas pode introduzir muitos problemas. Esta situao chamada de condio de corrida. A integridade dos estados dos objetos deve ser mantida, e para evitar o acesso simultaneo, deve-se sincronizar o acesso estes mtodos. Baseado nos monitores, toda operao que no deva ser interrompida deve ser declarada como SYNCHRONIZED. Abaixo h um exemplo de um cdigo que sofre problema de sincronizao. O mtodo contar() ser executado diversas vezes e em intervalos ligeiramente diferentes, podendo ocorrer em um erro do valor que esta sendo resgatado por uma outra Thread. Neste caso h o uso do synchronized que informa ao Java para tornar o bloco de cdigo prova de conflitos entre Threads. Apenas uma thread de cada vez ser permitida dentro deste mtodo, e as outras precisaro esperar at que a atual linha em execuo termine de executar o mtodo, para que outras Threads possam comear a execut-lo. public class ContadorSeguro { int ValorCrucial; public synchronized void contar(){ ValorCrucial += 1; } } Neste caso, fica garantido que o mtodo concluir sua execuo antes que outro possa executar. Se uma linha de execuo chama contar() e outra linha de execuo tambm chama, a segunda fica esperando. Em contrapartida, a sincronizao de um mtodo extenso e demorado, quase sempre uma idia ruim. Todas as Threads acabariam sendo deixadas nesse gargalo, aguardando em uma fila simples pela sua vez, nesse mtodo lento. Ainda neste contexto, caso tenhamos uma determinada operao que depende de outra, por exemplo, dentro de uma operao bancria, poderemos fazer transferncia. Porm, somente poderemos fazer transferncia de uma conta bancaria que tenha saldo. Assim, se o mtodo de transferncia for synchronized, e se no tiver saldo, esta Thread no sair do mtodo at que o mesmo tenha executado, mas para o mesmo executar ele precisar que outra Thread efetue o deposito, porm o objeto est bloqueado para a primeira Thread. Neste caso ocorre um Deadlock, ou seja, um bloqueio mutuamente exclusivo visto que ningum resolver este imparse. Para tal h uma soluo que a utilizao dos mtodos WAIT() e NOTIFY() dentro dos mtodos declarados como SYNCHRONIZED. O mtodo WAIT() utilizado quando se precisa esperar dentro de um mtodo SYNCHRONIZED, ou seja, ele bloqueia a Thread corrente, que entra para uma lista de
Pag.: 75
Pag.: 76
Sockets
10. Sockets
A idia de um socket faz parte do TCP/IP, o conjunto de protocolos usado pela Internet. Um socket uma conexo de dados transparente entre dois computadores em uma rede. Ele identificado pelo endereo de rede dos computadores, seus pontos finais e uma porta em cada computador. Os computadores em rede direcionam os streams de dados recebidos da rede para programas receptores especficos, associando cada programa a um nmero diferente, a porta do programa. Da mesma forma, quando o trfego de sada gerado, o programa de origem recebe um nmero de porta para a transao. Caso contrrio, o computador remoto poderia no responder entrada. Determinados nmeros de portas so reservados no TCP/IP para protocolos especficos por exemplo, 25 para o SMTP e 80 para o HTTP. Todos os nmero de porta abaixo do 1024 so reservados para o superusurio de cada computador. Um servidor um programa que fica executando em uma mquina, possui um nome (host) e este fica aguardando conexes de clientes em uma porta que identificada por um nmero. Se criamos um programa cliente que deve se comunicar com um programa servidor, precisamos dizer ao nosso programa cliente em que mquina est sendo executado o servidor e em que porta ele est escutando. Isso feito atravs de sockets. Num mesmo instante, vrios clientes podem estar solicitando a aplicao do servidor. Para cada um teremos um novo socket. Teremos um socket do lado do servidor e um socket em cada um dos clientes. Essa conexo no fsica, podemos cham-la de virtual ou lgica. Os pacotes continuaro circulando pela rede em caminhos diversos para depois serem reunidos numa mensagem.
Cliente 1
Socket Cliente
Servidor
Socket Servidor
Cliente 2
Socket Cliente
A classe Socket do Java rene todas estas informaes em um nico lugar e ainda fornece uma grande variedade de mtodos para trabalharmos com o sockets. Todas as classes relacionadas a Sockets encontram-se no pacote java.net. Hierarquia java.lang.Object | +--java.net.Socket
Pag.: 77
Inicialmente criado o ServerSocket que ir ouvir a porta 3333. Aps isso atravs do mtodo accept() do SocketServidor, o servidor aguarda uma solicitao de conexo de um cliente. Quando isso acontece, um Socket criado. Os objetos da classe PrintWriter e BufferedReader so utilizados para efetuar a comunicao.
Pag.: 78
Sockets
Thread independente e paralela. Assim, consegue-se obter maiores beneficios da manipulao dos Sockets. Segue um exemplo de Socket no cliente. Estes dois programas permitem que se faa uma aplicao Echo, onde tudo que enviado do Cliente para o Servidor, o Servidor responde a mesma coisa.
import java.io.*; import java.net.*; public class EchoClient { public static void main(String[] args) throws IOException { Socket echoSocket = null; PrintWriter out = null; BufferedReader in = null; try { echoSocket = new Socket("127.0.0.1", 4445); out = new PrintWriter(echoSocket.getOutputStream(), true); in = new BufferedReader( new InputStreamReader(echoSocket.getInputStream())); } catch (UnknownHostException e) { System.err.println("Host desconhecido"); System.exit(1); } catch (IOException e) { System.err.println("Nao foi possivel estabeler uma conexao."); System.exit(1); } for(int vc=0; vc<args.length; vc++) { out.println(args[vc]); System.out.println("echo: " + in.readLine()); } out.close(); in.close(); echoSocket.close(); } }
Pag.: 79
A verso utilizada atualmente o JDBC2.0, apesar de j existir o JDBC 3.0. A partir da verso 2.0, novas caractersticas e suporte forem implementados, podemos citar: controle de atualizaes em bloco, manipulao de registros atravs de programao, suporte a Scrollable Resultset, dentre outras caractersticas. O JDBC2.0 tambm suporta o SQL3, linguagem de consulta para banco de dados objeto-relacional. Uma API ao nvel do SQL permite construir sentenas SQL e coloc-las dentro das chamadas da API Java. Assim, JDBC permite uma transmutao transparente entre o mundo do Banco de Dados e as aplicaes JAVA. Os resultados das bases de dados so retornados atravs de variveis do Java e problemas com acessos so recebidos pelas excees, que contm uma classe especial chamada de SQLException. Devido aos problemas surgidos com a proliferao dos acessos as APIs dos bancos de dados proprietrios, a idia do acesso ao BD universal no uma soluo nova. De fato, a JavaSoft aproveitou todos os aspectos de uma API, a ODBC (Open DataBase Connectivity). O ODBC foi desenvolvido com o intuito de criar um padro de acesso s bases de dados no ambiente Windows. Embora a indstria tenha aceitado o ODBC como um primeiro recurso, o mesmo lento, deixando as aplicaes com conexes aos bancos de dados dificeis de manipular. Adicionando ao ODBC, o JDBC fortemente influenciado pelas APIs existentes nos BD tais como X/Open SQL Call Level Interface. Assim, a JavaSoft se utilizou deste recurso e construiu uma simples API com o intuito de ser aceito pelas empresas de BD. Alm disso, desenvolvendo uma API partindo dos produtos j existentes diminui o tempo de desenvolvimento. Especificamente, a JavaSoft trabalhou em paralelo com o a Intersolv para criar uma ponte no ODBC que mapeasse as chamadas JDBC para o ODBC, permitindo que os acessos s aplicaes Java sejam realizados por qualquer base de dados que suporte o ODBC.
Pag.: 80
11.1.1 JDBC 1.0 O JDBC na verso 1.0 prov o bsico para fornecer acesso aos dados. Ele composto pelas principais interfaces e classes tais como Driver, DriverManager, Connection, Statement, PreparedStatement, CallableStatement e ResultSet. 11.1.2 JDBC 2.0 A partir do JDBC 2.0 a API foi dividida em duas partes: core API e um pacote adicional, que a partir da verso 1.4 do JDK j foi incorporado. Esta verso 2.0 adicionou algumas classes e funcionalidades, tais como: Scrollable Resultsets permite a manipulao de next() e prior() dentro do ResultSet, o que antes so era possivel percorrer o resultado do inicio para o fim(mtodo next()). Insert, delete e update atravs da programao permite que faamos manipulaes de insero de registro dentro da propria aplicao, como acontece com linguagens como Delphi, VB. Suporte aos tipos de dados SQL-3 permite que manipulemos dados vindos de Banco de Dados Objeto-Relacional, ou seja, que manipulemos os registros como objetos.
11.1.3 JDBC 3.0 Foram incluidas mais funcionalidades a partir do JDK 1.4.
11.2.1 Driver JDBC Tipo 1 Este driver caracteriza a ponte JDBC-ODBC. Foi o primeiro tipo de driver desenvolvido e atualmente no utilizado devido presena dos drivers nativos. Tambm caracterizado pela sua lentido, visto que entre o BD e a aplicao Java temos duas camadas, sendo a primeiro o ODBC e a segunda o JDBC, como segue na ilustrao:
Pag.: 81
ODBC
JDBC
Programa Java
Banco de Dados
11.2.2 Driver JDBC Tipo 2 O driver do tipo 2 caracterizado por possuir um software cliente do Banco de Dados em cada estao que possua a aplicao. Assim, por exemplo, se voc esta desenvolvendo uma aplicao para Banco de Dados DB2, significa que quando for instalar nos seus 100 clientes, precisara antes instalar o cliente do DB2 em cada uma das 100 estaes que vai colocar o seu aplicativo. Alm disso, se a sua aplicao se tratasse de uma aplicao para a Web, cada vez que um cliente(usuario da Web) fosse executar a sua aplicao ele teria que baixar o cliente do BD. So para esclarecer, um cliente de um banco de dados uma media de uns 100Mb, em se tratando por exemplo do DB2. Segue uma ilustrao: Lado Cliente Lado Servidor
Cliente BD
JDBC
Programa Java
Banco de Dados
11.2.3 Driver JDBC Tipo 3 O driver tipo 3 caracterizado por uma classe Java que pode ser carregada. Atravs desta classe Java, criada uma porta para a comunicao com o Banco de Dados. Desta vez, o cliente do respectivo Banco de Dados estara instalado no lado do Servidor. Segue uma ilustrao: Lado Cliente Lado Servidor
Programa Java
Cliente BD
JDBC
Banco de Dados
Pag.: 82
11.2.4 Driver JDBC Tipo 4 O Driver tipo 4 caracterizado como um driver puro Java, com protocolo nativo. No necessita de Cliente do BD, o acesso realizado diretamente ao banco de dados, tambm chamado de Cliente Magro(Thin Client). Como segue a ilustrao:
JDBC
Programa Java
Banco de Dados
11.3.1 Driver A aplicao que estiver sendo desenvolvida deve estar desprovida de detalhes contendo, estritamente, a implementao do Driver para esta base de dados. Assim, uma aplicao utiliza o JDBC como uma interface por onde trafegam todos os requerimentos feitos ao Banco. Atravs do mtodo Class.forName(DriverClassName) possivel dizer qual o tipo de Driver que se esta utilizando. O nome do Driver definido por um tipo especfico de URL, como segue um exemplo abaixo: jdbc:<subprotocolo>:<subname> onde podemos ter especificamente: jdbc:odbc:JdbcOdbcDriver O subprotocolo identifica qual o Driver que ser utilizado e o subname identifica algum parmetro necessrio ao Driver. 11.3.2 DriverManager A classe DriverManager obtm uma conexo utilizando a URL passada. O DriverManager seleciona o driver apropriado se existirem mais de um. Utilizando a URL da base de
Pag.: 83
11.3.3 java.sql.Connection Esta classe Connection permite que se trabalhe com uma conexo do BD. A classe DriverManager devolve uma conexo, como segue: Connection con = DriverManager.getConnection(url, userid, passwd); Assim, para realizar a conexo, o JDBC utiliza de uma classe (java.sql.DriverManager) e duas interfaces (java.sql.Driver) e (java.sql.Connection). Enfim, a classe Connection representa uma transao de base de dados lgica. Esta classe utilizada para enviar uma srie de sentenas SQL para o banco de dados, gerenciando o commit ou abort destas sentenas.
import java.SQL.*; Pacote do JDBC. Nome do Driver do JDBC. UserID
try{ Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection con = DriverManager.getConnection("jdbc:odbc:JavafichaDB", "", ""); } catch (Exception e){ System.out.println(e.toString()); Passwd Caminho da Fonte System.exit(0); de Dados. } con.close(); Fechando a conexo com o Banco para o envio das sentenas SQL.
11.4.1 java.sql.Statement A classe Statement permite manipular as sentenas onde sero inseridos os comandos SQL. Como citado anteriormente, o acesso a base de dados se inicializa com a conexo ao BD atravs dos objetos da classe Connection. Este objeto tem como objetivo armazenar implementaes da classe java.sql.Statement em uma mesma transao. importante se distinguir entre o tipo de sentena SQL se deseja utilizar, visto que o mtodo de enviar
Pag.: 84
Statement stmt = con.createStatement(); stmt.executeQuery(SELECT * FROM curso); stmt.executeUpdate(DELETE FROM curso WHERE cpf=3333); A principal diferena ocorre pois o mtodo da consulta retorna uma instncia da classe java.sql.ResultSet enquanto que a atualizao retorna um nmero inteiro. Ainda h o mtodo Execute() da classe Statement que utilizado em situaes onde no se tenham o conhecimento dos tipos das sentenas. Ele retorna TRUE, caso tenha afetado algum registro. E para obter os dados utiliza-se o mtodo getResultSet().
11.4.2 java.sql.ResultSet Um ResultSet uma linha ou conjunto de dados resultante de uma Consulta (Query). Assim, atravs dela, nos poderemos manipular os resultados da nossa consulta base de dados. Outra caracteristica desta classe, que podemos armazenar neste conjnto de dados uma determinada coluna de um tipo de dados, mas mostrar este resultado como um tipo de dado diferente. Por exemplo, se eu tenho uma coluna chamada Data e no banco de dados ela esta armazenada como DateTime, eu posso retornar ela como uma String. Assim, a manipulao dos dados de retorno podem ser diferente do que os tipos armazenados. A classe permite manipular os resultados de acordo com as colunas da base. Segue a estrutura: Type get type ( int| String ) Assim, a coluna pode ser referenciada por um numero ou o nome da coluna no BD, como segue: ResultSet rs = stmt.executeQuery("SELECT * FROM curso"); rs.getString(nome); rs.getString(2); Neste caso a coluna 2 corresponde a coluna Nome. H ainda o mtodo next() que permite navegar pelos registros de um ResultSet. Se o mtodo next() retornar TRUE significa que h outra linha na seqncia, e se retornar FALSE significa que no falta nenhum registro no ResultSet.
11.4.3 java.sql.PreparedStatement Esta classe uma subinterface da classe Statement, e representa as sentenas que so enviadas ao Banco de Dados e so compiladas ou seja, preparadas antecipadamente. Com isso, elas ficam armazenadas em cache ou ele pode ser reutilizado, dependendo do BD, tornando a execuo muito mais rpida. A classe Statement requer uma compilao em toda execuo. Os valores variaveis para as colunas so passados como parmatros atravs da clusula IN, como segue um exemplo:
Pag.: 85
11.5.1 Scrollable ResultSet Atravs do Scrollable ResultSet nos conseguimos manipular os resultset para frente e para trs. Para tal precisamos de dois argumentos: 1. Tratamento do tipo de Scroll a. TYPE_FORWARD_ONLY Antigamente utilizado b. TYPE_SCROLL_INSENSITIVE No ve as atualizaoes no ResultSet se o mesmo estiver aberto c. TYPE_SCROLL_SENSITIVE V as atualizaes no ResultSet se o mesmo estiver aberto 2. Somente leitura ou atualizvel a. CONCUR_READ_ONLY Somente leitura b. CONCUR_UPDATABLE Pode ser atualizado atravs de mtodos do Java Segue um exemplo:
Statement stmt = con.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
Os mtodos disponiveis so: next(), previous() e getRow(). Segue um exemplo de uma aplicao:
if (ae.getSource()== btnConsulta){ System.out.println("Realizando uma consulta..."); stmt= con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY); rs = stmt.executeQuery(MetodoSQL.mConsultar()); if (rs.last()){ int nQtde = rs.getRow(); lbQuantidade.setText("Quantidade: "+nQtde); rs.beforeFirst(); } if (rs.next()){ edCPF.setText(rs.getString("CPF")); edNome.setText(rs.getString("nome")); edCidade.setText(rs.getString("cidade")); } }
Pag.: 86
11.5.3 Consultas com o SQL 3 As consultas com a manipulao do SQL 3 no trazem inovaes em relao manipulao dos dados no Java, mas atravs do JDBC 2.0 possivel que consultemos e faamos atualizaoes em bancos de Dados Objetos relacionis que possuem estruturas de criao de tabelas e manipulao de dados diferente, como segue um exemplo abaixo: CREATE TABLE Usuario OF objUsuario (UsuarioID PRIMARY KEY); E a manipulao deste tipo de tabela ocorre como se estivessemos referenciando objetos, como segue: SELECT Emp.UsuarioID.Nome as Nome, Emp.LivroID.Titulo as Titulo FROM Emprestimo Emp; Assim, o JDBC 2.0 permite manipularmos BDOR.
Pag.: 87
Referncias Bibliogrficas
Livros
HORSTMANN, Cay S., CORNELL, Gary; Core Java 2 Fundamentals, 5 Edio, 2003. Sun Press DEITEL & DEITEL; Java Como Programar, 4 Edio; Editora Bookman. Java Essential for C and C++ Programmers, Addison Wesley,1996 CAMARA, Fabio; Orientao a objetos com .NET, 2002
Pag.: 88
Referncias Bibliogrficas
Joo Bosco Mangueira Sobral professor associado II da Universidade Federal de Santa Catarina onde desenvolve pesquisas nas reas de Segurana de Redes, Computao Ubqua e Mvel e Auto-Organizao em redes.
Pag.: 89