SlideShare une entreprise Scribd logo

Java na Prática - Introdução à Programação Orientada a Objetos com Java

•
•
A
Albino87

Este documento apresenta uma introdução à linguagem de programação Java. Originalmente desenvolvida para dispositivos eletrônicos de consumo, Java foi projetada para ser independente de hardware e segura. Essas características tornaram Java adequada também para aplicações na Internet, que requerem portabilidade entre plataformas e segurança. O documento discute brevemente a história e objetivos iniciais da linguagem antes de entrar nos detalhes técnicos nos capítulos subsequentes.

1  sur  432
Télécharger pour lire hors ligne
UNIVERSIDADE FEDERAL DE VIÇOSA DEPARTAMENTO DE INFORMÁTICA JAVA NA PRÁTICA Alcione de Paiva Oliveira Vinícius Valente Maciel 2002
Java na Prática 1 Sumário Capítulo I - Introdução ....................................... 6 CONVENÇÕES ........................................................................................................................... 10 Capítulo II - Programação Orientada a Objetos .................. 11 CLASSES E OBJETOS E LINGUAGENS DE PROGRAMAÇÃO ......................................................... 12 Ocultando de Informação................................................................................................... 16 Especialização e Herança .................................................................................................. 17 Sobrescrita, Sobrecarga e Polimorfismo............................................................................ 18 INTRODUÇÃO À DIAGRAMA DE CLASSES ................................................................................. 20 Diagrama de Classes.......................................................................................................... 20 Capítulo III - Introdução à Linguagem Java ..................... 27 PALAVRAS RESERVADAS ......................................................................................................... 30 LITERAIS .................................................................................................................................. 31 SEPARADORES.......................................................................................................................... 34 TIPOS DE DADOS....................................................................................................................... 35 Tipos de dados simples....................................................................................................... 35 Tipos de dados compostos .................................................................................................. 37 CONVERSÃO DE TIPOS.............................................................................................................. 41 OPERADORES ........................................................................................................................... 42 Expressões e Precedência entre Operadores ..................................................................... 50 COMENTÁRIOS ......................................................................................................................... 51 BLOCOS E ESCOPO ................................................................................................................... 52 ESTRUTURAS DE CONTROLE .................................................................................................... 53 Seleção ............................................................................................................................... 53 Repetição............................................................................................................................ 57 break e continue ......................................................................................................... 60 ARGUMENTOS DA LINHA DE COMANDO .................................................................................... 61 ASSERT (ASSERTIVAS) ............................................................................................................. 63 Sintaxe e semântica ............................................................................................................ 63 Habilitando e Desabilitando Assertivas ............................................................................. 64 Capítulo IV Classes, Packages e Interfaces ................... 66 CLASSES .................................................................................................................................. 66 Construtores ....................................................................................................................... 68 Valor de Retorno ................................................................................................................ 68 OBJETOS .................................................................................................................................. 69 MODIFICADORES DE ACESSO .................................................................................................... 72 Outros Modificadores......................................................................................................... 74 REFERÊNCIAS COMPARTILHADAS ............................................................................................ 78 COPIANDO OBJETOS ................................................................................................................. 81 O objeto this ................................................................................................................... 81 PACKAGES ............................................................................................................................... 83 Usando Packages ............................................................................................................... 83 Criando Packages .............................................................................................................. 84 O Mecanismo de Extensão ................................................................................................. 86 DERIVANDO CLASSES ............................................................................................................... 88 super ................................................................................................................................... 90 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 2 A classe Object ............................................................................................................... 91 Sobrescrita e Polimorfismo ................................................................................................ 92 CLASSES E MÉTODOS ABSTRATOS ........................................................................................... 95 INTERFACES ............................................................................................................................. 96 CLASSES INTERNAS .................................................................................................................. 99 Classes Internas Anônimas............................................................................................... 101 CONVERSÃO........................................................................................................................... 103 EXCEÇÕES.............................................................................................................................. 103 A hierarquia de Exceções................................................................................................. 105 Capturando mais de uma exceção.................................................................................... 106 Lançando exceções........................................................................................................... 107 Comportamento do Sistema diante das Exceções ............................................................ 109 Criando suas próprias exceções....................................................................................... 110 A cláusula finally ....................................................................................................... 111 DOCUMENTANDO O CÓDIGO................................................................................................... 112 Rótulos.............................................................................................................................. 113 HTML embutida ............................................................................................................... 115 AGENDA ELETRÔNICA VERSÃO CONSOLE 1.0 ........................................................................ 115 Capítulo V – Entrada e Saída (java.io) ...................... 122 ACESSO SEQUENCIAL............................................................................................................. 122 ACESSO DIRETO ..................................................................................................................... 127 Capítulo VI – java.util ..................................... 131 LIDANDO COM COLEÇÕES ...................................................................................................... 131 As Interfaces Iterator e Enumeration ................................................................... 131 Vector ........................................................................................................................... 133 Stack.............................................................................................................................. 136 Hashtable .................................................................................................................... 138 MISCELÂNEA DE CLASSES DO PACOTE JAVA.UTIL................................................................. 141 Arrays ........................................................................................................................... 141 Date ................................................................................................................................ 144 Observable .................................................................................................................. 146 StringTokenizer ...................................................................................................... 150 AGENDA ELETRÔNICA VERSÃO CONSOLE 2.0 ........................................................................ 152 Capítulo VII - Serialização e Persistência .................... 159 AGENDA ELETRÔNICA VERSÃO CONSOLE 2.1 ........................................................................ 161 Capítulo VIII – AWT (Abstract Window Toolkit) ............... 164 A HIERARQUIA DE COMPONENTES ......................................................................................... 164 OLÁ MUNDO AWT ................................................................................................................ 166 TRATAMENTO DE EVENTOS ................................................................................................... 167 Modelo de Eventos 1.1 ..................................................................................................... 167 Tratamento de Eventos com classes Internas................................................................... 171 EXEMPLO BÁSICO .................................................................................................................. 176 ACRESCENTANDO CORES ....................................................................................................... 180 GERENCIANDO O LAYOUT...................................................................................................... 181 Exemplo com BorderLayout....................................................................................... 182 Exemplo com FlowLayout ........................................................................................... 183 Exemplo com CardLayout ........................................................................................... 184 Exemplo com GridLayout ........................................................................................... 186 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 3 Exemplo com GridBagLayout .................................................................................... 187 UTILIZANDO LISTAS............................................................................................................... 189 TRABALHANDO COM MENUS E DIÁLOGOS ............................................................................. 192 CAPTURANDO EVENTOS DO TECLADO ................................................................................... 196 PRINCIPAIS CLASSES .............................................................................................................. 196 Color.............................................................................................................................. 196 Component .................................................................................................................... 198 Button ........................................................................................................................... 200 Label.............................................................................................................................. 201 List ................................................................................................................................ 202 TextField .................................................................................................................... 203 TextArea....................................................................................................................... 204 CONTAINERS .......................................................................................................................... 205 Panel.............................................................................................................................. 207 Frame.............................................................................................................................. 208 AGENDA ELETRÔNICA VERSÃO GRÁFICA 1.0......................................................................... 211 Capítulo IX - Applets ....................................... 217 DESCRIÇÃO DO CÓDIGO HTML ............................................................................................. 221 MÉTODOS DA CLASSE APPLET ............................................................................................... 222 EXIBINDO UMA IMAGEM ........................................................................................................ 226 ÁUDIO .................................................................................................................................... 229 OBTENDO PARÂMETROS ......................................................................................................... 230 EXECUTANDO UM APPLET COMO APLICAÇÃO ........................................................................ 232 PREPARANDO APPLETS PARA PRODUÇÃO E ARQUIVOS JARS ................................................. 232 CRIANDO OS PRÓPRIOS ARQUIVOS MANIFEST ......................................................................... 235 AGENDA ELETRÔNICA VERSÃO APPLET 1.0 ........................................................................... 236 Capítulo X JavaBean ......................................... 237 O QUE É UM JAVABEAN? ....................................................................................................... 237 JAVABEANS E FERRAMENTAS RAD ....................................................................................... 237 PROPRIEDADES ...................................................................................................................... 238 Simples ............................................................................................................................. 238 Indexada ........................................................................................................................... 239 Ligada (Bound)................................................................................................................. 240 Restringidas(Constrained) ............................................................................................... 241 EVENTOS................................................................................................................................ 243 DESENVOLVIMENTO DO EXEMPLO ......................................................................................... 244 TimerEventListener .......................................................................................................... 244 TimerEvent ....................................................................................................................... 245 TimerBean ........................................................................................................................ 245 INSTALANDO O BEANS DEVELOPMENT KIT (BDK)................................................................ 249 TESTANDO EXEMPLO NO BDK ............................................................................................... 249 Capítulo XI - Concorrência .................................... 255 CRIANDO THREADS EM JAVA ................................................................................................. 257 Criando threads por meio da interface Runnable ........................................................ 259 A CLASSE THREAD ................................................................................................................. 259 Hierarquia ........................................................................................................................ 259 Construtores ..................................................................................................................... 259 Métodos ............................................................................................................................ 259 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 4 Variáveis públicas ............................................................................................................ 259 CICLO DE VIDA DOS THREADS ............................................................................................... 259 sleep(), yield(), join(), destroy(), stop(), suspend() e resume(). .............. 259 DAEMON THREADS ................................................................................................................ 259 INFLUÊNCIA DO SISTEMA OPERACIONAL NO COMPORTAMENTO DOS THREADS..................... 259 Forma de escalonamento de threads................................................................................ 259 Relacionamento entre os níveis de prioridades definidas na linguagem Java e os níveis de prioridades definidas nos Sistemas Operacionais............................................................ 259 COMPARTILHAMENTO DE MEMÓRIA E SINCRONIZAÇÃO ........................................................ 259 Atomicidade de Instruções e Sincronização do Acesso à Sessões Críticas ...................... 259 Comunicação entre Threads: wait() e notify() ................................................................. 259 Capítulo XII - Animação ....................................... 259 Capítulo XIII - Programação em rede ......................... 259 CONCEITOS SOBRE PROTOCOLOS USADOS NA INTERNET....................................................... 259 TCP................................................................................................................................... 259 UDP.................................................................................................................................. 259 IDENTIFICAÇÃO DE HOSTS (Número IP).................................................................... 259 Identificação de Processos (Portas)................................................................................. 259 PROGRAMAÇÃO EM REDE COM JAVA ..................................................................................... 259 Comunicação Básica Entre Aplicações............................................................................ 259 Comunicação Sem Conexão (UDP) ................................................................................. 259 Comunicação por meio de URL ....................................................................................... 259 Capítulo XIV – Computação Distribuída (RMI) ................. 259 CRIANDO NOSSA AGENDA DISTRIBUÍDA ................................................................................. 259 Implementar interface do objeto remoto .......................................................................... 259 Capítulo XV - Acesso a Banco de Dados ....................... 259 MODELOS DE ACESSO A SERVIDORES .................................................................................... 259 TIPOS DE DRIVERS JDBC....................................................................................................... 259 Obtendo os Drivers JDBC................................................................................................ 259 PREPARANDO UM BANCO DE DADOS ..................................................................................... 259 Configurando o ODBC..................................................................................................... 259 EXEMPLO INICIAL .................................................................................................................. 259 Carregando o Driver........................................................................................................ 259 Estabelecendo a conexão ................................................................................................. 259 Criando e Executando Comandos .................................................................................... 259 RECUPERANDO VALORES....................................................................................................... 259 TRANSAÇÕES E NÍVEL DE ISOLAMENTO ................................................................................. 259 Transação......................................................................................................................... 259 Níveis de isolamento......................................................................................................... 259 PREPARED STATEMENTS ........................................................................................................ 259 PROCEDIMENTOS ARMAZENADOS (STORED PROCEDURES).................................................... 259 AGENDA ELETRÔNICA VERSÃO JDBC ................................................................................... 259 Capítulo XVI Servlets e JSP ................................. 259 SERVLETS .............................................................................................................................. 259 Applets X Servlets............................................................................................................. 259 CGI X Servlets .................................................................................................................. 259 A API SERVLET ..................................................................................................................... 259 Exemplo de Servlet ........................................................................................................... 259 COMPILANDO O SERVLET....................................................................................................... 259 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 5 Instalando o Tomcat......................................................................................................... 259 PREPARANDO PARA EXECUTAR O SERVLET ............................................................................ 259 Compilando o Servlet ....................................................................................................... 259 Criando uma aplicação no Tomcat .................................................................................. 259 EXECUTANDO O SERVLET ...................................................................................................... 259 Invocando diretamente pelo Navegador........................................................................... 259 Invocando em uma página HTML .................................................................................... 259 Diferenças entre as requisições GET e POST .................................................................. 259 CONCORRÊNCIA ..................................................................................................................... 259 OBTENDO INFORMAÇÕES SOBRE A REQUISIÇÃO .................................................................... 259 LIDANDO COM FORMULÁRIOS................................................................................................ 259 LIDANDO COM COOKIES......................................................................................................... 259 LIDANDO COM SESSÕES ......................................................................................................... 259 JSP......................................................................................................................................... 259 PHP X JSP ....................................................................................................................... 259 ASP X JSP ........................................................................................................................ 259 Primeiro exemplo em JSP ................................................................................................ 259 Executando o arquivo JSP................................................................................................ 259 Objetos implícitos............................................................................................................. 259 Tags JSP........................................................................................................................... 259 Comentários ..................................................................................................................... 259 Diretivas ........................................................................................................................... 259 Extraindo Valores de Formulários................................................................................... 259 Criando e Modificando Cookies....................................................................................... 259 Lidando com sessões ........................................................................................................ 259 O Uso de JavaBeans......................................................................................................... 259 REENCAMINHANDO OU REDIRECIONANDO REQUISIÇÕES ....................................................... 259 UMA ARQUITETURA PARA COMÉRCIO ELETRÔNICO ............................................................... 259 Tipos de aplicações na WEB ............................................................................................ 259 Arquitetura MVC para a Web .......................................................................................... 259 Agenda Web: Um Exemplo de uma aplicação Web usando a arquitetura MVC.............. 259 Capítulo XVII Perguntas Frequentes .......................... 259 Bibliografia ................................................ 259 Links ....................................................... 259 Índice ...................................................... 259 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 6 Capítulo I - Introdução Java é uma linguagem de programação desenvolvida pela Sun Microsystems e lançada em versão beta em 1995. O seu desenvolvimento foi iniciado em 1991 pela equipe liderada por James Gosling visando o mercado de bens eletrônicos de consumo. Por isso foi projetada desde o início para ser independente de hardware, uma vez que as características dos equipamentos variam amplamente neste nicho de desenvolvimento. Outro objetivo estabelecido desde sua concepção foi o de ser uma linguagem segura. Segura tanto no sentido de evitar algumas falhas comuns que os programadores costumam cometer durante o desenvolvimento, como no sentido de evitar ataques externos. Isto é importante no mercado de bens eletrônicos de consumo por que ninguém gostaria de adquirir um produto que necessitasse desligar e religar para que voltasse a funcionar corretamente. Estas características despertaram o interesse para utilização de Java em outro ambiente que também necessitava de uma linguagem com este perfil: a Internet. A Internet também é um ambiente constituído por equipamentos de diferentes arquiteturas e necessita muito de uma linguagem que permita a construção de aplicativos seguros. Muitas pessoas argumentarão que estas características podem ser encontradas em outras linguagens e portanto isto não explica o súbito sucesso da linguagem. Podemos arriscar alguns palpites apesar de este ser um terreno um pouco pantanoso para se aventurar, até por que as linguagens de programação tendem assumir um caráter quase religioso. Uma das razões que na nossa opinião favoreceram a rápida adoção da linguagem foi a sintaxe. Java é sintaticamente muito semelhante à linguagem C/C++, apesar de existirem diferenças fundamentais na filosofia de implementação entre as duas linguagens. Isto facilitou a migração de uma legião imensa de programadores C/C++ para a nova linguagem. Outra razão que não pode ser desprezada é o momento atual onde os desenvolvedores estão ansiosos para se libertarem de sistemas proprietários. Portanto, apesar de não serem novas as idéias embutidas na linguagem Java, a reunião delas em uma só linguagem, juntamente com a facilidade migração dos programadores e o momento atual, contribuíram para o rápido sucesso da linguagem. Hoje, segundo a International Data Corp. (IDC), existem mais de 2 milhões de programadores Java no mundo e a estimativa é que o número de desenvolvedores ultrapasse os 5 milhões em 2004. O número de programadores Java deve ultrapassar o de programadores C++ ainda este ano (2002), segundo a consultoria americana Evans Data. Os profissionais que dominam a linguagem Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 7 estão entre os mais bem pagos da área de Tecnologia da Informação (TI), com salários variando de 3 a 10 mil reais, podendo em alguns casos chegar à 16 mil reais, segundo a revista Info Exame (dezembro de 2001). A lista abaixo apresenta as principais características de Java de modo que o leitor tenha uma visão geral da linguagem: • Orientação a objetos. Java não é uma linguagem totalmente orientada a objetos como Smalltalk, onde tudo é objeto ou métodos de objetos. Por questões de eficiência foram mantidos alguns tipos primitivos e suas operações. No entanto, Java possui um grau de orientação a objetos bem maior que C/C++, o que a torna bem mais harmoniosa e fácil de assimilar, uma vez que o programador tenha compreendido esta forma de desenvolvimento. • Compilação do código fonte para código de uma máquina virtual (Bytecodes). Esta característica visa tornar a linguagem independente de plataforma de Hardware e Sistema Operacional. Obviamente é necessário que exista um programa capaz de interpretar o código em Bytecodes para cada Sistema Operacional, denominado de Máquina Virtual. No entanto, nada impede que o código fonte seja traduzido diretamente para o código executável na máquina de destino. Já existem ambientes de desenvolvimento que apresentam este tipo de opção. Alternativamente, é possível projetar equipamentos que processem em hardware os Bytecodes. A Sun desenvolveu um processador que executa operações em Bytecodes, denominado de JavaChip. O diagrama abaixo ilustra as etapas envolvidas na execução de um código Java. Figura I-1. Fases para execução de um programa fonte em Java • Ausência de manipulação explícita de ponteiros. Em linguagens como C/C++ e Pascal existe o tipo ponteiro como tipo primitivo da linguagem. A especificação original de Pascal é restritiva no uso de ponteiros, permitindo que sejam usados apenas para referenciar memória obtida na área de alocação dinâmica (heap) e não permite que o programador examine o valor Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 8 da variável do tipo ponteiro, nem que realize operações aritméticas com ponteiros. Já a linguagem C/C++ permite que o valor armazenado na variável do tipo ponteiro faça referência a qualquer área de memória, inclusive à área estática e automática (pilha), além de permitir aritmética de ponteiros e o exame direto do valor armazenado. A manipulação do tipo ponteiro exige uma grande dose de atenção por parte do programador e mesmo programadores experientes frequentemente cometem erros no seu uso. Além disso, o uso de ponteiros é uma fonte de insegurança na linguagem, uma vez que permite que o usuário faça acesso a memória que pode pertencer a outros processos, abrindo a possibilidade para desenvolvimento de programas hostis ao sistema. A linguagem Java não possui o tipo ponteiro. Isto não que dizer que não seja possível realizar alocação dinâmica de memória. Todo objeto criado é alocado na área de heap, mas o usuário não pode manipular a referência ao objeto explicitamente. • Recuperação automática de memória não utilizada (Coleta de Lixo – Garbage Collection). Nas linguagens onde existe alocação dinâmica de memória, o programador é responsável pela liberação de memória previamente obtida na área de alocação dinâmica e que não está sendo mais utilizada. Se houver falhas na execução desta responsabilidade ocorrerá o problema que é conhecido sob a denominação de “vazamento de memória”. Este problema faz com que a partir de certo ponto o programa não consiga obter memória para criação de novos objetos, apesar de existir área que não está sendo mais usada mas que não foi devolvida ao gerente de memória. Outro erro comum é a tentativa de acesso á áreas de memória já liberadas. Todos os programadores que trabalham com linguagens que permitem alocação dinâmica conhecem bem estes problemas e sabem o quanto é difícil implementar programas que não possuam estes tipos de erros. A maior parte dos erros que ocorrem no uso destas linguagens é devido a problemas na alocação/liberação de memória. Visando o desenvolvimento de aplicações robustas, livres deste tipo de falha, os projetistas de Java incorporaram um procedimento de coleta automática de lixo à máquina virtual. Deste modo, os objetos que não estão sendo mais usados são identificados pelo procedimento, que libera a memória para ser utilizada na criação de novos objetos. • Segurança. As pessoas costumam dizer que Java é uma linguagem segura. Mas o que é ser uma linguagem de programação segura? Segurança possui significados distintos para pessoas diferentes. No caso da linguagem Java na Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 9 versão 1.0 segurança significa impedir que programas hostis que possam causar danos ao ambiente computacional, ou que busquem informações sigilosas em computadores remotos para uso não autorizado. Na versão 1.1 foi adicionada a capacidade de permitir a verificação da identidade dos programas (autenticação) e na versão 1.2 os dados que os programas enviam e recebem podem ser criptografados por meio do uso de um pacote adicional. Na versão 1.4 o pacote de criptografia JCE (JavaTM Cryptography Extension) foi incorporado ao J2SDK. • Suporte à Concorrência. A construção de servidores, a criação de programas com interfaces gráficas, e programas semelhantes que tem em comum a necessidade de que o atendimento de uma solicitação não incapacite o sistema de responder a outras solicitações concorrentemente, demandam o uso de uma linguagem que facilite o desenvolvimento deste tipo de programa. As linguagens projetadas antes do surgimento destas necessidades, como C/C++, não previam facilidades para este tipo de programação, o que obrigou a incorporação destes recursos posteriormente, por meio de funções adicionais. Como a programação concorrente é uma forma de programação que difere bastante da programação sequencial convencional, a simples adição de novas funções para tentar adaptar a linguagem a esta forma de codificação, não cria um ajuste perfeito com a linguagem subjacente. Por outro lado, Java foi projetada visando facilitar a programação concorrente. Isto faz com que a criação linhas de execução (threads) seja bem mais natural dos que nas linguagens tradicionais.Programação em rede. Java possui em seu núcleo básico classes para comunicação em rede por meio dos protocolos pertencentes à pilha de protocolos TCP/IP. A pilha de protocolos TCP/IP é a utilizada pela Internet e tornou-se o padrão de fato para comunicação entre computadores em uma rede heterogênea. Isto torna Java particularmente atrativa para o desenvolvimento de aplicações na Internet. Além disso Java está incorpora um amplo de conjunto de soluções para computação distribuída, como CORBA (Common Object Request Broker Architecture), RMI (Remote Method Invocation) e Servlets/JSP (aplicações Java que são executadas por servidores Web). Após o lançamento da versão beta da linguagem em 1995, a Sun tem liberado diversas evoluções da linguagem na forma de versões e releases de um conjunto de ferramentas denominado de Java Development Kit (JDK) até a versão 1.2, quando se passou a denominar Java 2 SDK (Standard Development Kit). Isto ocorreu porque outros kits de desenvolvimento com propósitos Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 10 específicos foram lançados, como o J2EE (Java 2 Enterprise Edition), voltado para aplicações distribuídas escaláveis e o J2ME (Java 2 Micro Edition), voltado para aplicações embutidas em dispositivos eletrônicos (Celulares, handheld, etc.). Durante a elaboração deste livro, a última versão estável do SDK era a de número 1.3.1 que pode ser obtida gratuitamente no site http://java.sun.com/. Convenções As seguintes convenções são usadas neste livro. 1. Fontes com larguras constantes são usadas em: • exemplos de código public class Ponto { private int x,y; } • nomes de métodos, classes e variáveis mencionadas no texto. 2. Fontes com larguras constantes em negrito são usadas dentro de exemplos de códigos para destacar palavras chave. 3. Fontes em itálico são usadas: • em termos estrangeiros; • na primeira vez que for usado um termo cujo significado não for conhecimento generalizado. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 11 Capítulo II - Programação Orientada a Objetos O mundo pode ser visto como um conjunto de objetos que se relacionam. Por exemplo, uma pessoa, uma casa, uma cadeira da casa, etc. Os objetos não são necessariamente físicos. Podem possuir uma natureza abstrata, como um evento (uma partida de futebol) ou algo inexistente no mundo real (elefante cor- de-rosa). Na verdade, o conceito de objeto atua no nível lógico e não no real. Se iremos representar algo como objeto ou não depende apenas de uma decisão a nível lógico que pode facilitar a simulação de determinado aspecto da realidade. Os objetos se agrupam em classes, segundo propriedades ou atributos comuns. Por exemplo, a classe dos retângulos agrupa todas as formas geométricas com a propriedade de possuir quatro lados formando ângulos de 90o. A relação entre um objeto e uma classe é de pertinência. Dizemos que um objeto pertence a uma classe ou, mais comumente, que é uma instância de uma classe. O Figura abaixo ilustra exemplos de classes. Figura II-1. Classe dos (a) retângulos e dos (b) dos triângulos. As classes podem ser relacionar com outra classe no sentido que uma classe pode conter outra. Por exemplo, a classe de retângulos está inserida em uma classe mais genérica, a classe dos polígonos. A classe mais genérica é denominada de Superclasse e as classes mais específicas são denominadas de Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 12 Subclasses. As subclasses herdam as propriedades das superclasses. No nosso exemplo, os polígonos possuem as propriedades de ter uma área, uma posição no plano, um número n de vértices e n-1 ângulos. Todas essas propriedades são herdadas tanto pela classe dos retângulos como pela classe do triângulos. Podemos desta forma organizar os objetos em uma hierarquia onde as classes mais específicas herdam as propriedades das classes mais genéricas. Figura II-2. Classe dos polígonos. Os objetos de uma classe possuem comportamentos que podem alterar o valor de suas propriedades. Por exemplo, um carro pode sofrer uma aceleração ou ser freado e com isso alterar a sua velocidade. Um objeto qualquer pode ser deslocado, alterando assim as suas coordenadas no espaço. Classes e Objetos e Linguagens de Programação As linguagens de programação são utilizadas para construir simulações de aspectos da realidade no computador. Quanto mais facilmente pudermos expressar os conceitos capturados da realidade, mais facilmente construiremos a simulação. Seguindo este raciocínio podemos concluir que as linguagens que possuem facilidades para representação de objetos permitem uma modelagem mais fácil dos conceitos do mundo real. No entanto, podemos utilizar uma linguagem de programação convencional para modelar as classes e objetos abstraídos da realidade. Por exemplo, podemos modelar a classe dos retângulos por meio de um registro (record) em Pascal. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 13 type Classe_Retangulo = record X1,Y1,X2,Y2: integer; end; Exemplo II-1. Representação da Classe Retângulo em Pascal. No Exemplo II-1 o retângulo é definido por dois pontos, sendo X1 e Y1 o ponto superior esquerdo e X2 e Y2 o ponto inferior direito. Os objetos podem ser representados por meio de variáveis do tipo definido: type Classe_Retangulo = record X1,Y1,X2,Y2: integer; end; var Retangulo1 : Classe_Retangulo; Exemplo II-2. Criação de objetos em Pascal. procedure intRetangulo(XA,YA,XB,YB: integer; var R: Classe_Retangulo); begin R.X1 := XA; R.Y1 := YA; R.X2 := XB; R.Y2 := YB; end; procedure MudaPos(X,Y: integer; var R: Classe_Retangulo); begin R.X2 := X+(R.X2-R.X1); R.Y2 = Y+(R.Y2-R.Y1); R.X1 = X; R.Y1 = Y; end; Exemplo II-3. Definição das operações em Pascal. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 14 As propriedades dos objetos podem ser manipuladas através de funções e procedimentos. Por exemplo, podemos ter uma operação para inicializar os valores da estrutura e outra para alterar a posição do retângulo. O Exemplo II-3 mostra essas duas operações. Contudo, existem algumas limitações das linguagens convencionais que as tornam inadequadas para a modelagem de objetos: • Não existem recursos para ocultar a estrutura de dados de procedimentos que não foram projetados para a sua manipulação. É muito importante que a linguagem forneça recursos para se implementar este tipo de isolamento. Se acessarmos uma estrutura apenas por meio dos procedimentos projetados para este fim, quando a estrutura for alterada apenas os procedimentos que manipulam a estrutura sofreriam modificações. No entanto, se não agirmos desta forma será necessário procurar em todo o programa os acessos diretos à estrutura. Claro que este comportamento pode ser adotado em qualquer linguagem, mas é mais seguro se a linguagem fornece meios para o programador forçar este tipo de comportamento. A capacidade de “esconder” a estrutura de dados de acessos diretos é chamada de ocultação de informação. • Não existem recursos para herança de propriedades entre classes e subclasses. Se precisarmos implementar uma estrutura que é uma especialização de outra já implementada, será preciso codificar novamente todas as propriedades, mesmo as comuns, e todos os procedimentos de acesso. Isto dificulta o reaproveitamento de código, o que, consequentemente aumenta o tempo de desenvolvimento e a possibilidade de erros. • Não existe uma forma de relacionar explicitamente as estruturas de dados com os procedimentos que as manipulam. O relacionamento entre os procedimentos que manipulam uma estrutura de dados e a estrutura é estabelecido implicitamente, por meio de alguma convenção definida pelo programador. É importante que a linguagem obrigue o programador relacionar explicitamente os procedimentos com a estrutura de dados, de modo que fique claro qual é a interface de acesso ao objeto. A adoção de uma linguagem programação orientada a objetos resolve todos esses problemas. Existem várias linguagens comerciais com esta característica: Smalltalk, Eiffel, C++, etc. Algumas com elementos não orientados a objetos como C++, outras puramente orientadas a objetos como Smalltalk, onde tudo é Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 15 objeto. Java é uma linguagem orientada a objetos mais “pura” do que C++, fugindo desta orientação apenas em alguns pontos bem definidos, em nome da eficiência de execução. Em Java podemos representar diretamente as classes e objetos. Por exemplo, a classe retângulo seria declarada da seguinte forma: class Retangulo { int X1,Y1,X2,Y2; public Retangulo(int XA, int YA, int XB, int YB) { X1 = XA; Y1 = YA; X2 = XB; Y2 = YB; } void MudaPos(int X, int Y) { X2 = X+(X2-X1); Y2 = Y+(Y2-Y1); X1 = X; Y1 = Y; }; } Exemplo II-4.Representação da Classe Retângulo em Java. No Exemplo II-4 mudamos o nome do procedimento iniRetangulo para Retangulo, que é o mesmo nome da classe. No momento não é importante entendermos a razão desta mudança, que será esclarecida no próximo capítulo. Note que os procedimentos são declarados dentro do corpo da classe, tornando explícito relacionamento entre a classe e os procedimento. As funções declaradas nas classes são chamadas de métodos e a partir de agora nos referenciaremos a eles como tal. Note também que diferentemente do exemplo em Pascal, não é preciso passar o objeto como parâmetro, uma vez que as variáveis que estão sendo modificadas pertencem ao objeto corrente, ao qual está associado o método. É como se para cada objeto de uma classe fossem criadas versões de todos os métodos da classe, de modo que cada método só opera sobre as variáveis do objeto a quem pertencem. Para declarar uma variável do tipo da classe basta preceder a variável com o nome da classe. Retangulo ret; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 16 Até esse momento nenhum objeto foi criado. Para criar um objeto (instância) é usado o operador new. ret = new Retangulo(10,10,20,30); Note que o operador new é seguido de uma chamada ao método com o mesmo nome da classe. O métodos com esta característica são chamados de construtores e só podem ser invocados durante a criação de um objeto. Como veremos mais tarde, uma classe pode ter mais de um construtor. Após a criação do objeto é possível acessar os outros métodos do objeto através do operador “.”. Por exemplo, podemos mudar a posição do objeto por meio do método MudaPos. ret.MudaPos(40,40); Como já dissemos, não é preciso passar o objeto como argumento, já que é criada uma cópia do método para cada objeto. A grosso modo podemos dizer que cada instância da classe recebe uma cópia da variáveis e dos métodos da classe. Ocultando de Informação O projetista cuidadoso deve ocultar a representação interna da classe, permitindo o acesso aos atributos da classe via métodos predefinidos. Desta forma a representação interna fica isolada do restante do programa e fica mais fácil alterá-la sem que seja preciso alterar outras partes do código. A ocultação de informação é obtida por meio de qualificadores, como o private, que impede o acesso à variáveis via métodos definidos em outras classes. O nível de ocultação depende do qualificador utilizado. Todos os qualificadores serão abordados com detalhes no Capítulo IV. O exemplo II-5 mostra como impedir que as variáveis declaradas na classe Retangulo sejam acessadas diretamente. class Retangulo { private int X1,Y1,X2,Y2; public Retangulo(int XA, int YA, int XB, int YB) { X1 = XA; Y1 = YA; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 17 X2 = XB; Y2 = YB; } void MudaPos(int X, int Y) { X2 = X+(X2-X1); Y2 = Y+(Y2-Y1); X1 = X; Y1 = Y; }; } Exemplo II-5. Ocultando informação em Java. Especialização e Herança Para criar uma subclasse de uma classe pré-existente utilizamos o operador extends. Por exemplo, podemos definir uma subclasse da classe Retangulo, chamada de RetanguloColorido, que possui, além das variáveis e métodos herdados da superclasse, uma variável para armazenar a cor do retângulo, juntamente com um método para alterar o valor. class RetanguloColorido extends Retangulo { private Color Cor; void AtribuiCor(Color C) { Cor = C; }; } Exemplo II-6. Declarando subclasses em Java. A princípio, subclasse pode acessar todos os métodos e variáveis da superclasse. No entanto, isto também pode ser alterado via qualificadores. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 18 Sobrescrita, Sobrecarga e Polimorfismo Podemos definir mais de um método com o mesmo nome na mesma classe ou subclasses. Caso o método possua a mesma assinatura (número e tipos de argumentos e tipo de retorno) que outro método, então o método não pode pertencer à mesma classe do anterior. Se ambos os métodos estiverem na mesma linha hierárquica (classe/subclasse), dizemos que o método da subclasse sobrescreve o método da superclasse. O método que será executado dependerá da classe do objeto. class Empregado { protected float salario; public float getSalario() {return salario;} } class Vendedor extends Empregado { protected float comissao; public float getSalario() {return salario+comissao;} } Exemplo II-7. Sobrescrita do método getSalario(). No exemplo II-7 o método getSalario() da classe Vendedor sobrescreve o método do mesmo nome da classe Empregado. Se a assinatura do método for diferente de outro método com o mesmo nome definido anteriormente na mesma classe ou em outra classe da mesma linha hierárquica, então estamos realizando uma sobrecarga sobre o identificador do método. Quando for usado o identificador dentro do código de um programa o método invocado será determinado pela classe a que pertence o objeto do método e pelo número e tipos dos argumentos passados para o método. O termo sobrecarga advém do fato de um mesmo identificador denotar mais de método. class Empregado { protected float salario; public void aumento() {salario= salario*10.0;} public void aumento(float porcent) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 19 { salario= salario*porcent; } } Exemplo II-8. Sobrecarga do método aumento(). No exemplo II-8 o identificador aumento pode referenciar dois métodos distintos. Um aumenta o salário em 10% e no outro o aumento depende do valor da porcentagem passado como parâmetro. Note que as assinaturas do métodos diferem entre si. Alguns autores chamam sobrecarga de polimorfismo, que é a habilidade de um determinado objeto se comportar ou ser visto de diferentes formas, quando na verdade a sobrecarga é um tipo particular de polimorfismo, chamado de polimorfismo ad hoc . Na sobrecarga um identificador representa vários métodos com computações distintas. Existe também o polimorfismo paramétrico, onde um método pode realizar a mesma computação sobre objetos de tipos distintos. Isso pode ser implementado em Java definindo um método que recebe e retorna objetos da classe Object. Como a classe Object é a “mãe de todas as classes” o método pode operar da mesma forma independente da classe a qual o objeto realmente pertence, desde que a computação seja independente da classe. class Poli { public Object identidade(Object objeto) { return Object; } } Exemplo II-9. Polimorfismo paramétrico. No Exemplo II-9 o método identidade() retorna o objeto passado como parâmetro. Este método realiza a mesma computação, independentemente da classe do objeto. Obviamente é um exemplo muito simples e sem utilidade prática mas serve para ilustrar o conceito de polimorfismo paramétrico. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 20 Introdução à Diagrama de Classes É possível registrar diretamente em uma linguagem de programação os objetos percebidos em uma determinada realidade. No entanto, é melhor utilizarmos uma notação gráfica intermediária para melhor visualizarmos os objetos e as relações entre objetos, e ir alterando esta representação até estarmos seguros que possuímos um entendimento razoável do problema, e ai sim, partirmos para a codificação da solução. Muitas vezes é preciso recorrer a mais de uma notação gráfica, de modo a expressar várias facetas da realidade que está sendo modelada. Neste livro, recorreremos ao uso de notação gráfica em alguns exemplos para ilustrarmos a arquitetura dos programas antes de apresentarmos o código. Acreditamos que desta forma o leitor compreenderá melhor os exemplos. A notação gráfica que adotamos mostra as relações estáticas entre classes de objetos. Ela faz parte do conjunto de notações da UML (Unified Modeling Language ou Linguagem de Modelagem Unificada) proposta por Grady Booch, James Rumbaugh e Ivar Jacobson em 1995. A UML é um conjunto de notações que tem por objetivo modelar diversos aspectos de um sistema em diferentes níveis de abstração. Ou seja, pode ser utilizado para a captura de requisitos de um sistema assim como em projeto de programas. É voltada para análise e projeto de sistemas orientados a objetos. A área de análise e projeto orientados a objetos ainda não possui uma notação “vencedora” como existe para a análise e projeto estruturado. Contudo, a UML vem se popularizando rapidamente, e é encontrada com facilidade em textos de programação, sobretudo em se tratando de Java. Portanto, um conhecimento sobre as principais notações que constituem a UML é importante para qualquer um que deseja ingressar na área de programação orientada a objetos. Este livro utiliza uma das linguagens, ou diagramas, que compõem a UML: o diagrama de classes. Diagrama de Classes O Diagrama de Classes representa graficamente as classes do sistema e o relacionamento estático entre as classes, isto é, o relacionamento que não muda com o tempo. Por exemplo, em um sistema acadêmico, um aluno cursa várias disciplinas. O número de disciplinas e a disciplina que efetivamente está sendo cursada pode alterar, mas o vínculo aluno-cursa-displinas permanece. Para ilustrar o nosso estudo dos diagramas da UML utilizaremos exemplos sobre modelagem de aspectos realidade acadêmica. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 21 Uma classe é representada no diagrama de classes por meio de um retângulo, que pode ser dividido em até três seções horizontais, como mostrado na figura abaixo: Figura II-3. Forma geral para representação de uma classe. A seção superior é usada para registrar o nome da classe. A seção intermediária é reservada para registro das propriedades da classe, caso existam, e na seção inferior é registrado a assinatura dos métodos que pertencem à classe, caso existam. Por assinatura do método queremos dizer o nome do método, juntamente com seus argumentos e valor de retorno. A figura abaixo mostra uma representação da classe das disciplinas. Figura II-4. Representação da classe das disciplinas De modo geral, por razões de simplicidade, não se representam os métodos que tratam da alteração dos atributos e construtores. Se Assumi que toda classe possui estes métodos. Portanto, podemos simplificar a representação acima, omitindo a seção do métodos. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 22 Figura II-5. Representação simplificada da classe das disciplinas. Podemos indicar tanto nos atributos quanto nas classes a visibilidade deles em relação a outras classes. As visibilidades possíveis, juntamente com os símbolos adotados estão listados na tabela abaixo: Visibilidade Símbolo Descrição Pública + Sem restrição de acesso. Protegida # Pode ser acessado apenas na própria classe e por subclasses. Privada - Pode ser acessado apenas na própria classe. Tabela II-1. Visibilidades possíveis para atributos e métodos. A visibilidade é atribuída a um atributo ou método precedendo a declaração do método com o símbolo adequado, como na figura abaixo: Figura II-6. Representação com visibilidade. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 23 As classes podem se relacionar de diversas formas: por associação comum, por agregação e generalização. Abaixo é apresentada cada forma de relacionamento, juntamente com suas as notações. Associação comum A notação utilizada para associar duas classes é simplesmente uma linha unindo as classes. A figura II.7 mostra a associação entre a classe dos alunos e a classe das disciplinas. Figura II-7. Associação entre Aluno e Disciplina. A figura acima expressa que alunos se associam com disciplinas mas não indica se um aluno se relaciona com várias ou apenas uma disciplina. Esta informação é chamada de cardinalidade da relação e é expressa anotando-se o valor da cardinalidade na associação junto à classe que está sendo relacionada. Assim, a figura II.8 expressa que um aluno se relaciona com várias disciplinas. Figura II-8. Associação de um Aluno com várias Disciplinas. Como uma disciplina se relaciona com vários alunos, o diagrama completo é o representado na figura II-9. Figura II-9. Associação de vários Aluno com várias Disciplinas. A tabela II-2 mostra algumas representações de cardinalidade: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 24 Notação Descrição 1 Exatamente um * ou 0..* Zero ou mais 0..1 Opcional (zero ou um) n..m Máximo e mínimo Tabela II-2. Representações de cardinalidade. Até agora apresentamos apenas associações entre duas classes, mas nada impede que mais de duas classes participem de uma associação. Por exemplo, a figura II-10 ilustra uma associação ternária que representa o fato de um aluno cursar uma disciplina em um período. Figura II-10. Associação entre aluno, disciplina e período. Uma associação pode ter atributos próprios. Ou seja, atributos que não pertençam a nenhuma das classes envolvidas na associação mas sim à própria associação. Na associação entre alunos e disciplina o atributo nota, não pertence a aluno, tampouco à disciplina, uma vez que para saber uma nota é preciso saber quem é o aluno e qual é a disciplina. A representação de atributos da associação é representada por meio de um retângulo ligado à associação por meio de uma linha tracejada. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 25 Figura II-11. Representação de atributos de associação. Agregação Alguns objetos são compostos por outros objetos. Por exemplo, um carro é composto por chassi, lataria, pneus e motor, que por sua vez é composto pelo carburador, pistões, bloco, etc. Este tipo de associação é representada por uma linha com um losango na ponta. Figura II-12. Agregação entre Curso e Disciplina. Generalização O último tipo de associação entre classes é o que o ocorre entre superclasses e subclasses. Uma superclasse é uma generalização das suas subclasses, que herdam os atributos e métodos da primeira. A notação utilizada para representar a generalização é uma linha com um triângulo na extremidade da associação no lado da classe mais genérica. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 26 Figura II-13. Representação da generalização. A figura II-14 procura representar todas associações discutidas em um único diagrama. Figura II-14. Associação entre as classes do domínio acadêmico. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 27 Capítulo III - Introdução à Linguagem Java Existe uma tradição entre os programadores que estabelece que ao se começar a aprender uma nova linguagem de programação, o primeiro programa a ser escrito deve ser um que imprima a frase “Olá mundo” em um dispositivo de saída. Dizem que isto atrai a sorte e espanta os bugs. Independente da crença geral, existem algumas razões bastante justificáveis para se começar o aprendizado de uma linguagem executando logo um programa, mesmo sem ter muita idéia do que se está fazendo. Primeiramente, existe o fator psicológico. Iniciar o aprendizado executando um programa sem erros, aumenta confiança do aluno e elimina temores de se estar aprendendo algo muito complexo. Existe também o fato de que apesar de um programa muito simples dar uma visão um pouco limitada da linguagem, já é possível observar alguns elementos importantes. Afinal trata-se de um programa completo. Portanto, para não fugir a tradição, eis o programa OlaMundo em Java: public class OlaMundo { public void exibeOla() { System.out.println(“Ola, Mundo!”); } public static void main(String args[]) { OlaMundo obj = new OlaMundo(); Obj.exibeOla(); } } Exemplo III-1. Programa OlaMundo. O programa acima é composto por uma única classe que possui apenas dois métodos. Isto é importante, porque não é possível fazer um programa Java sem recorrer às classes, uma vez que os procedimentos são definidos como métodos de classes. Isto não é verdade em linguagens como C++, o que diminui o seu “grau” de orientação a objetos. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 28 Os métodos com o nome main são métodos especiais e servem como ponto inicial para execução do programa. Ou seja, a execução do programa será iniciada a partir da execução de um método main(). A assinatura do método main é sempre a mesma e a sua descrição em detalhes será vista na seção Argumentos da linha de comando. Podemos adiantar apenas que o qualificador public estabelece que este método pode ser chamado por métodos ou procedimentos externos à classe. O qualificador static significa que o método pertence à classe e não às instâncias da classe, e deste modo pode ser invocado mesmo antes de ser criado algum objeto para a classe. void indica que o método não retornará valor algum. Já argumento String args[] é um array de Strings contendo os parâmetros passados na linha de comando. O corpo do método main() possui duas linhas. A primeira instrução cria um objeto da classe OlaMundo e o atribui à variável obj. A segunda linha invoca o método exibeOla() do objeto recém criado. O método exibeOla() invoca o método println() do objeto out da classe System, que faz parte do pacote de classes fornecido com a linguagem. Este método exibe no dispositivo de saída padrão a String que é passada como argumento. Se você olhar os programas “OlaMundo” mostrados em outros livros sobre Java irá notar que o programa apresentado aqui é um pouco mais complicado que o exibido nesses livros. Geralmente este programa inicial é apresentado apenas com um método: o método main(). A razão de termos usado uma abordagem diferente é que desejamos desenvolver um hábito saudável na programação em Java: procure usar o método main() apenas para criar os objetos e deixe que os objetos executem a lógica do problema. Este programa deve ser salvo em um arquivo contendo O MESMO NOME DA CLASSE e com as mesmas letras maiúsculas e minúsculas (é importante frisar, uma vez que esquecer este detalhe é um erro muito comum), e com a extensão “.java”. Portanto o arquivo contendo o programa acima deverá se chamar OlaMundo.java. Se você instalou o Java 2 development kit (SDK), que pode ser obtido gratuitamente no site http://java.sun.com/products/, então para compilar o programa basta digitar o comando: javac OlaMundo.java O código Java é traduzido (o termo mais comum é compilado) para instruções de uma máquina virtual (bytecodes) para que possa ser executado de forma independente da plataforma (sistema operacional e hardware). O código em bytecodes é armazenado em um arquivo com o mesmo nome do original e com a extensão “.class”. Assim após a execução do comando acima será Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 29 gerado o arquivo OlaMundo.class. A invocação da máquina virtual para executar o código em bytecodes é efetuada por meio do seguinte comando: java OlaMundo Neste ponto nota-se uma desagradável idiossincrasia do SDK. Para compilar o programa para bytecode foi necessário explicitar a extensão do arquivo, porém, para executar o código é preciso omitir a extensão “.class”. Apesar de ser um detalhe que aparentemente não prejudica o uso do ambiente, confunde o usuário, principalmente o iniciante. Quando recebe um arquivo de bytecodes para a executar, a máquina virtual procura o método main() em uma classe com o mesmo nome do arquivo. Uma vez encontrado o método a execução é iniciada com a execução do método. Isto significa que em nosso exemplo será procurado o método main() da classe OlaMundo para servir de ponto de entrada. Podem existir outros métodos main() em outras classes codificadas no mesmo arquivo de bytecodes, mas apenas o método main() da classe com o mesmo nome do arquivo servirá de ponto inicial de execução. Portanto, em nosso caso, o programa será executado produzindo a saída: Ola, Mundo! Agora que já cumprimos o ritual de iniciação na linguagem, podemos passar a descrever os detalhes da linguagem. Grande parte das descrições que seguem abaixo foram baseadas na especificação da linguagem registrada no livro The Java Language Specification, segunda edição, por James Gosling e outros. Identificadores Todos os identificadores da linguagem devem iniciar com uma letra, ou o caractere ´_`, ou o caractere ´$`. Deve-se evitar o uso do caractere ´$`, de modo que fique reservado para geração de código automático. Tratamos por letra todo caractere reconhecido pelo método Character.isJavaLetter. Isto inclui uma ampla gama de caracteres do conjunto Unicode1, de modo que os programadores podem usar identificadores adaptados a uma ampla gama de idiomas. Após o 1 O conjunto de caracteres Unicode foi criado para substituir o conjunto ASCII. Ele usa 16 bits para representar os caracteres, o que resulta em 65536 caracteres possíveis, em oposição aos 7 bits do código ASCII (8 para o ASCII estendido), o que resulta em 128 caracteres possíveis (256 para 8 bits). Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 30 primeiro caractere, também podem ser usados os caracteres que vão de ´0` até ´9`. A linguagem Java distingue as letras maiúsculas das minúsculas, portanto o identificador Aluno é distinto do identificador aluno. A tabela III-1 mostra alguns identificadores válidos e inválidos. Válido Inválido Aluno10 Aluno#10 Num_Alunos Num Alunos _disciplina$ !disciplina Professor_10 10Professor αβγ &uuu Não Não? Tabela III-1. Identificadores válidos e inválidos em Java. Palavras Reservadas As seguintes sequências de caracteres são reservadas para o uso como palavras chave e, portanto, não podem ser usadas como identificadores: abstract continue goto package synchronized assert2 default if private this boolean do implements protected throw break double import public throws byte else instanceof return transient case extends int short try catch final interface static void char finally long strictfp3 volatile class float native super while const for new switch Tabela III-2. Palavras reservadas da linguagem Java. As palavras chave const e goto, apesar de serem reservadas, não estão sendo usadas correntemente na linguagem. 2 Introduzida a partir da versão 1.4 do SDK. 3 Introduzida a partir da versão 1.2 do SDK Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 31 Literais Literais são elementos do código que representam um valor de tipo primitivo, tipo String ou null. Os literais podem ser numéricos, booleanos, caracteres ou cadeias de caracteres (Strings). Literais numéricos incluem inteiros, ponto flutuante. Literais Inteiros Um literal inteiro é do tipo primitivo long (longo) se possui o sufixo ´L` ou ´l`, caso contrário é do tipo primitivo int (inteiro). Um numeral hexadecimal é prefixado pelos caracteres ´0x` ou ´0X` seguidos de um ou mais dígitos hexadecimais. Os dígitos hexadecimais com valores entre 10 e 15 são representados pela letras ´a` até ´f` ou ´A` até ´F`, nessa ordem. Um numeral octal consiste de um dígito 0 seguido de um ou mais dígitos de 0 até 7. O maior literal decimal do tipo int é 2147483648. Os literais decimais de 0 até 2147483647 podem aparecer em qualquer lugar que um literal inteiro pode aparecer, mas o literal 2147483648 pode aparecer somente como operando de uma negação unária. Os maiores literais hexadecimal e octal positivos inteiros são 0x7fffffff e 017777777777, respectivamente, que correspondem ao valor decimal 2147483647. Os maiores literais hexadecimal e octal negativos inteiros são 0x80000000 e 020000000000, respectivamente, que representam o valor decimal -2147483648 (). Os literais hexadecimal e octal 0xffffffff e 037777777777, representam o valor decimal -1. Abaixo estão listados alguns exemplos de literais inteiros: 0 -12 0372 0xCafe 1999 0x00FF00FF O maior literal decimal do tipo longo é o 9223372036854775808L. Os literais decimais de 0L até 9223372036854775807L podem aparecer em qualquer lugar que um literal inteiro longo pode aparecer, porém o literal 9223372036854775808L pode aparecer somente como operando de uma negação unária. Os maiores literais hexadecimal e octal positivos inteiros longos são 0x7fffffffffffffffL e 0777777777777777777777L, respectivamente, que correspondem ao valor decimal 9223372036854775807L.Os maiores literais Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 32 hexadecimal e octal negativos inteiros longos são 0x8000000000000000L e 01000000000000000000000L, respectivamente, que representam o valor decimal -9223372036854775808L. Os literais hexadecimal e octal 0xffffffffffffffffL e 01777777777777777777777L, representam o valor decimal - 1. Abaixo estão listados alguns exemplos de literais inteiros longos: 0L 0777L 0xC0B0L 0xCafe 1999 0x100000000L Literais de Ponto Flutuante Um literal de ponto flutuante é composto por uma parte inteira seguida de um ponto decimal, uma parte fracionária, um expoente e um sufixo determinando o tipo. O expoente, se presente, é indicado pela letra ‘E’ ou ‘e’, seguido por um inteiro com sinal um opcional. Pelo menos um dígito na parte inteira ou fracionária e o ponto decimal ou o expoente ou o sufixo indicando o tipo são exigidos. Todos os outros componentes são opcionais. Um tipo ponto flutuante é do tipo float se possuir o sufixo ‘F’ ou ‘f’, caso contrário é do tipo double. O tipo double possuir opcionalmente o sufixo ‘D’ ou ‘d’. O tipo float e double de Java obedecem a especificação IEEE 754 para binários de ponto flutuante de precisão simples (32-bit) e dupla (64-bit). O maior literal positivo do tipo float é 3.40282347e+38f. O menor literal positivo do tipo float diferente de zero é 1.40239846e-45f. O maior literal positivo do tipo double é 1.79769313486231570e+308. O menor literal positivo do tipo double diferente de zero é 4.94065645841246544e-324. Um programa em Java pode representar quantidades infinitas sem produzir erros de compilação por meio da utilização de expressões constantes tais como 1f/0f e -1d/0d ou pela utilização das constantes predefinidas POSITIVE_INFINITY e NEGATIVE_INFINITY das classes Float e Double. Exemplos de literais do tipo float: 1e1f 2.f .3f 0f 3.14f 6.022137e+23f Exemplos de literais do tipo double: 1e1 2. .3 0.0 3.14 1e-9d 1e137 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 33 Literais Booleanos O tipo boolean possui dois valores, representados pelos literais true e false. Literais de Caracteres Um literal do tipo char é expresso como um caractere ou uma sequência de escape, envolvida por aspas simples. Os caracteres CR e LF nunca são caracteres de entrada, uma vez que são reconhecidos como terminadores de linha. Exemplos de literais do tipo char: Caractere Descrição 'a' o caractere a. '%' o caractere % 'n' line feed 't' Tab '' o caractere ''' o caractere '. 'u03a9' 'uFFFF' '177' Tabela III-3. Exemplo de literais do tipo char. Literais de Cadeia de Caracteres (Strings) Um literal do tipo String consiste de zero ou mais caracteres envolvidos por aspas duplas. Cada caractere pode ser representado por uma sequência de escapes. O tipo String não é um tipo primitivo e sim uma classe denominada String. Portanto, um literal é na verdade uma instância da classe String. Uma String longa pode ser particionada em cadeias menores unidas pelo operador de concatenação ´+’. Exemplos de literais do tipo String: Literal Descrição "" Cadeia vazia. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 34 """ Uma cadeia com apenas o caractere ". "esta é uma cadeia" Uma cadeia contendo 17 caracteres. "esta é uma " Uma cadeia formada por dois literais do +"cadeia " tipo String. Tabela III-4. Exemplo de literais do tipo String. Sequências de escape Sequências de escape permitem a representação de alguns caracteres não gráficos, assim como as aspas simples e duplas e a barra invertida. Exemplos de sequências de escape: Sequência Descrição b u0008: backspace BS t u0009: tab horizontal HT n u000a: linefeed LF f u000c: form feed FF r u000d: carriage return CR " u0022: aspas duplas " ' u0027: aspas simples ' u005c: barra invertida Tabela III-5. Exemplo sequências de escape. O Literal null O tipo null possui apenas um valor, representado pelo literal null. Separadores Java possui nove separadores (caracteres de pontuação), listados abaixo: ( ) { } [ ] ; , . Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 35 Tipos de dados Os tipos de dados definem como devem ser interpretados os dados armazenados. São essenciais a toda linguagem de programação e devem ser cuidadosamente selecionados para compor a linguagem, de modo a não limitar a sua área de atuação. A maioria da linguagens modernas definem um conjunto de tipos simples, um conjunto de tipos compostos, formados por tipos mais primitivos e alguma forma de definição de novos tipos, de modo que possa modelar mais apropriadamente a realidade. A linguagem Java obedece esta regra, fornecendo um conjunto de tipos simples e um conjunto de tipos compostos. O mecanismo para definição de novos tipos utilizado por Java é simplesmente a definição de classes. Java é uma linguagem fortemente tipada. Isto significa que toda variável e expressão possui um tipo determinado em tempo de compilação. Os tipos primitivos disponíveis em Java não são classes. Esta é uma das razões porque Java não é uma linguagem 100% orientada a objetos. No entanto, para cada tipo primitivo existe uma classe correspondente onde são declarados um conjunto de métodos para a manipulação dos valores primitivos, focalizando principalmente na conversão de tipos. Estas classes estão agrupadas no pacote java.lang. Por exemplo, o tipo primitivo int é usado para expressar valores inteiros. A classe correspondente ao tipo int é a Integer. Nela estão declaradas variáveis públicas contendo o valor máximo e mínimo que uma variável do tipo inteiro pode armazenar e métodos para conversão para outros tipos. Tipos de dados simples Tipos de dados simples são aqueles que não podem ser divididos em tipos mais primitivos. Os tipos de dados simples de Java podem ser divididos em inteiros, ponto flutuante, booleano e caractere. Para se definir uma variável de um determinado tipo basta preceder o nome da variável com o nome do tipo desejado, como na forma abaixo: <nome do tipo> <nome da variável>; Assim, para se declarar uma variável var1 do tipo inteiro basta a linha de código abaixo: int var1; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 36 Podemos também declarar mais de uma variável em com o mesmo tipo, usando o caractere ‘,’ como separador. Portanto, a declaração int var1, var2; é equivalente às declarações int var1; int var2; Java também permite que as variáveis sejam inicializadas durante a declaração. Assim, para inicializarmos a variável var1 com o valor 1 na declaração basta a linha de código abaixo: int var1=1; Segue abaixo as categorias de tipos de dados simples. Inteiros Nome Tamanho byte 8 bits short 16 bits int 32 bits long 64 bits Tabela III-6. Tipos inteiros. Ponto Flutuante Nome Tamanho float 32 bits double 64 bits Tabela III-7. Tipos de ponto flutuante. booleanos boolean {true,false} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 37 Caractere char 16 bits Tipos de dados compostos Os tipos de dados compostos são constituídos por tipos mais simples. Todos os tipos compostos em Java são Classes. Nesta seção trataremos duas classes de objetos muito usadas em Java para criação de tipos compostos: os arrays (arranjos) e strings. Posteriormente abordaremos a declaração de objetos no caso geral e no Capítulo VI será apresentado o pacote de classes java.util que contém várias classes para agrupamento de objetos. Arrays Um array é um objeto, e como tal herda todos os métodos da classe Object. Um array contém um certo número de variáveis chamadas de componentes. Em Java todo objeto é acessado indiretamente, via uma referência. Ou seja, não se cria uma variável do tipo de um objeto e sim uma variável que pode referenciar um objeto. Estamos falando de ponteiros, o que pode parecer contraditório, uma vez que tínhamos mencionado que Java não possui ponteiros. Na verdade Java acessa as instâncias de objeto por meio de ponteiros mas eles não estão disponíveis como tipo da linguagem e nem é possível que o programador os manipule diretamente. Pode parecer pouco importante para o programador saber que a variável não armazena o objeto diretamente e sim uma referência a um objeto, uma vez que ele não pode manipular ponteiros. No entanto, acreditamos que esta informação é importante para que o leitor possa entender as etapas para a criação de objetos. A primeira etapa é a declaração da variável para referenciar o objeto e a segunda etapa é a criação do objeto propriamente dito. Para se declarar uma variável para referenciar objetos do tipo array é usada a seguinte sintaxe: tipo identificador[]; tipo[] identificador; Exemplos int numeros[]; char[] letras; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 38 long grade[][]; Note que não é definido o número de elementos do array. Isto faz parte do objeto. Note também que existem duas formas de declarações de referências a arrays. O número de “[]” indica o número de dimensões do array. A criação do objeto é realizada por meio do operador new, seguido pelo tipo do array e pelo número de componentes de cada dimensão, como nos exemplos abaixo: numeros = new int[10]; char alfabeto[] = new char[26]; grade = new long[10][10]; Alternativamente podemos realizar as duas etapas acima e ainda definir os elementos do array em uma única declaração como no exemplo abaixo, onde é criado um array de três inteiros, referenciados pela variável primos e onde o primeiro elemento é 7, o segundo é 11 e o terceiro é 13. int primos = {7, 11, 13}; De agora em diante não faremos distinção entre referência a objeto do tipo array e o objeto array, a não ser que seja necessário explicitar esta distinção. O acesso aos elementos do array é realizado por meio do nome da variável seguida por um expressão inteira não negativa envolvida pelos caracteres ‘[’ e ‘]’. A expressão inteira é chamada de índice e os valores admissíveis para a expressão vai de 0 a n-1, onde n é número de elementos do array. O índice do primeiro elemento é 0. Abaixo seguem alguns exemplos: alfabeto[0] = ‘a’; grade[0][5] = 10L; for(int i=0; i<10; i++) numeros[i] = i*2; É possível descobrir o tamanho de um array em tempo de execução acessando a variável pública length do objeto, onde está armazenada a capacidade do array. Por exemplo: for(int i=0; i< numeros.length; i++) numeros[i] = i*2; Strings Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 39 O manipulação de cadeias de caracteres (strings) em Java é realizada por uma classe do pacote java.lang denominada String. Ou seja, não existe um tipo primitivo para tratar cadeias de caracteres. Para se declarar uma variável que faz referencia a um objeto String usa-se a seguinte linha de comando: String nome; Para que a variável faça referência a um objeto basta criar um objeto por meio do operador new ou atribuir a referência de um objeto preexistente. nome = new String(“Pedro”); String x, y; x= nome; y = “Pedro”; No primeiro caso a variável nome faz referencia a um objeto recém criado contendo o valor “Pedro”. Já a variável x faz referencia ao mesmo objeto referenciado pela variável nome. Ou seja, nenhum novo objeto String é criado, ocorrendo um compartilhamento de objetos. Já a variável y faz referência a um objeto String contendo o valor “Pedro”, distinto do objeto referenciado por x e nome. Podemos também inicializar a variável durante a declaração. String nome = “Pedro”; Os objetos do tipo String possuem um conjunto extenso de métodos e construtores para a manipulação e criação de Strings. A tabela abaixo mostra alguns dos mais utilizados. Construtor Descrição String(byte[] bytes, int offset, Constrói uma nova String convertendo o subarray de int num) bytes especificado String(StringBuffer buffer) Constrói uma nova String usando a sequência de caracteres contida no StringBuffer. String(byte[] bytes) Constrói uma nova String convertendo o array de bytes especificado String(String valor) Constrói uma nova String com o mesmo conteúdo da String passada como argumento. String() Constrói uma nova String contendo zero caracteres. String(char[] valor) Constrói uma nova String convertendo o array de caracteres especificado. String(char[] valor, int offset, Constrói uma nova String convertendo o subarray de int num) caracteres especificado. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 40 Tabela III-8. Principais construtores da classe String. Método Descrição charAt(int indice) Retorna o caractere localizado no índice especificado. compareTo(String Compara duas Strings lexicograficamente. outraString) equals(Object anObject) Verifica se dois objetos são iguais. getChars(int srcBegin, Copia os caracteres da String em um array de int srcEnd, char[] dst, caracteres. int dstBegin) indexOf(String str) Retorna o índice da primeira ocorrência do substring no string. indexOf(String str, int Retorna o índice da primeira ocorrência do substring fromIndex) no string a partir do índice especificado. indexOf(int ch, int Retorna o índice da primeira ocorrência do caractere fromIndex) no string a partir do índice especificado. indexOf(int ch) Retorna o índice da primeira ocorrência do caractere no string . length() Retorna o comprimento do string. replace(char oldChar, Retorna uma nova String onde todos os caracteres char newChar) oldChar foram substituídos pelos caracteres newChar. substring(int beginIndex) Retorna uma nova string que é substring da atual. substring(int beginIndex, Retorna uma nova string que é substring da atual. int endIndex) toLowerCase() Converte para minúsculas. toUpperCase() Converte para Maiúsculas. trim() Remove os espaços em branco do inicio e do fim do String. valueOf(Object obj) Retorna a representação em String do argumento Object. valueOf(char c) Retorna a representação em String do argumento char. valueOf(boolean b) Retorna a representação em String do argumento booleano. valueOf(long l) Retorna a representação em String do argumento long. valueOf(int i) Retorna a representação em String do argumento int.. valueOf(char[] data) Retorna a representação em String do argumento array de caracteres valueOf(float f) Retorna a representação em String do argumento float. valueOf(double d) Retorna a representação em String do argumento double. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 41 Tabela III-9. Principais métodos da classe String. Os literais de Strings são tratados como instâncias da classe String e como tal possuem os métodos de um objeto da classe String. Por exemplo, após a execução da expressão abaixo a variável x conterá o valor 5. int x = “Pedro”.length(); Conversão de Tipos De forma geral as conversões entre tipos em Java devem ser especificadas explicitamente. A forma mais comum de se especificar uma conversão é por meio da notação abaixo: (<tipo destino>) <expressão> Por exemplo: int i = 10; char c = (char) i; Este tipo de conversão é chamada de casting. O programador deve ficar bastante atento no que diz respeito a conversões, uma vez que pode acontecer perda de informação quando convertemos um tipo para outro que ocupa um espaço menor na memória. A tabela abaixo mostra as conversões entre tipos primitivos que podem causar perda de informação: do tipo para o tipo byte char short byte, char char byte, short int byte, short, char long byte, short, char, int float byte, short, char, int, long double byte, short, char, int, long, float Tabela III-10. Conversão de tipos que podem causar perda de informação. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática 42 Outra forma de converter tipos é usando os métodos fornecidos pelas classes associadas aos tipos. A tabela abaixo mostra a classe associada a cada tipo primitivo. Tipo Classe int Integer float Float double Double boolean Boolean byte Byte short Short long Long Tabela III-11. Classes associadas a cada tipo primitivo. As classes fornecem métodos para conversão mais sofisticados como do tipo primitivo para String e vice-versa. Por exemplo, a classe Integer fornece um método para converter String para int: int i = Integer.parseInt(“12”); Para se converter um inteiro para String podemos utilizar o método toString(): String s = Integer.toString(12); Existem métodos semelhantes nas outras classes. Existe também um tipo de conversão que somente se aplica aos operandos do operador binário ‘+’ quando um dos operandos é um objeto da classe String. Caso o outro operando não seja um objeto da classe String, então ele será convertido para String e o resultado da operação será a concatenação das duas cadeias. As Conversões entre objetos de classes distintas serão tratadas no próximo Capítulo. Operadores Os operadores atuam sobre valores e variáveis de modo a gerar novos valores ou modificar os valores das variáveis. Os símbolos abaixo representam os 37 operadores da linguagem Java: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java
Java na Prática - Introdução à Programação Orientada a Objetos com Java

Recommandé

Guia cosmetico
Guia cosmeticoGuia cosmetico
Guia cosmeticoJeane Oliveira
 
Manual de Enfermagem
Manual de EnfermagemManual de Enfermagem
Manual de EnfermagemGabriela Montargil
 
Manual Crioscópio Eletrônico pzl 7000 rev. 1.0
Manual Crioscópio Eletrônico pzl 7000 rev. 1.0Manual Crioscópio Eletrônico pzl 7000 rev. 1.0
Manual Crioscópio Eletrônico pzl 7000 rev. 1.0PZL Tecnologia
 
Manual PráTico De TéCnicas De Enfermagem
Manual PráTico De TéCnicas De EnfermagemManual PráTico De TéCnicas De Enfermagem
Manual PráTico De TéCnicas De EnfermagemEduardo Gomes da Silva
 
Ciesa.tecnologia design moda.projeto político pedagógico.2010
Ciesa.tecnologia design moda.projeto político pedagógico.2010Ciesa.tecnologia design moda.projeto político pedagógico.2010
Ciesa.tecnologia design moda.projeto político pedagógico.2010PORANJE
 
[Apostila] segurança e saúde no trabalho sesi
[Apostila] segurança e saúde no trabalho sesi[Apostila] segurança e saúde no trabalho sesi
[Apostila] segurança e saúde no trabalho sesiSolange Montosa
 
Livro custos e contabilidade
Livro custos e contabilidadeLivro custos e contabilidade
Livro custos e contabilidadeReila Márcia Rezende
 
Taxonomias
TaxonomiasTaxonomias
TaxonomiasHsiang (Chan) Wang Ying
 

Recommandé

Guia cosmetico
Guia cosmeticoGuia cosmetico
Guia cosmeticoJeane Oliveira
 
Manual de Enfermagem
Manual de EnfermagemManual de Enfermagem
Manual de EnfermagemGabriela Montargil
 
Manual Crioscópio Eletrônico pzl 7000 rev. 1.0
Manual Crioscópio Eletrônico pzl 7000 rev. 1.0Manual Crioscópio Eletrônico pzl 7000 rev. 1.0
Manual Crioscópio Eletrônico pzl 7000 rev. 1.0PZL Tecnologia
 
Manual PráTico De TéCnicas De Enfermagem
Manual PráTico De TéCnicas De EnfermagemManual PráTico De TéCnicas De Enfermagem
Manual PráTico De TéCnicas De EnfermagemEduardo Gomes da Silva
 
Ciesa.tecnologia design moda.projeto político pedagógico.2010
Ciesa.tecnologia design moda.projeto político pedagógico.2010Ciesa.tecnologia design moda.projeto político pedagógico.2010
Ciesa.tecnologia design moda.projeto político pedagógico.2010PORANJE
 
[Apostila] segurança e saúde no trabalho sesi
[Apostila] segurança e saúde no trabalho sesi[Apostila] segurança e saúde no trabalho sesi
[Apostila] segurança e saúde no trabalho sesiSolange Montosa
 
Livro custos e contabilidade
Livro custos e contabilidadeLivro custos e contabilidade
Livro custos e contabilidadeReila Márcia Rezende
 
Taxonomias
TaxonomiasTaxonomias
TaxonomiasHsiang (Chan) Wang Ying
 
Pontes Ferroviárias
Pontes FerroviáriasPontes Ferroviárias
Pontes FerroviáriasDaniel Campos
 
Luos
LuosLuos
Luoskarinemaiara123
 
Programacao Orientada A Objetos (Java)
Programacao Orientada A Objetos (Java)Programacao Orientada A Objetos (Java)
Programacao Orientada A Objetos (Java)Robson Silva Espig
 
Certificação Digital : Uma Nova Era de Segurança Eletrônica
Certificação Digital : Uma Nova Era de Segurança EletrônicaCertificação Digital : Uma Nova Era de Segurança Eletrônica
Certificação Digital : Uma Nova Era de Segurança Eletrônicaluizrbs
 
Manual+de+enfermagem+(messauandra+de+oliveira+silva)
Manual+de+enfermagem+(messauandra+de+oliveira+silva)Manual+de+enfermagem+(messauandra+de+oliveira+silva)
Manual+de+enfermagem+(messauandra+de+oliveira+silva)Marcelo Leal Souza
 
Tecnicas Gerais De Enfermagem
Tecnicas Gerais De EnfermagemTecnicas Gerais De Enfermagem
Tecnicas Gerais De EnfermagemRutesilva
 
Apostila estatistica 2004_2
Apostila estatistica 2004_2Apostila estatistica 2004_2
Apostila estatistica 2004_2Míriam Pimenta
 
Apostila tga i sem
Apostila tga i semApostila tga i sem
Apostila tga i semadm2011jba
 
Calendário seguros
Calendário segurosCalendário seguros
Calendário segurosvicelima
 
contabilidade
contabilidadecontabilidade
contabilidadewixbrasil
 
Classificação Fiscal de Mercadorias na Prática - IOB e-Store
Classificação Fiscal de Mercadorias na Prática - IOB e-StoreClassificação Fiscal de Mercadorias na Prática - IOB e-Store
Classificação Fiscal de Mercadorias na Prática - IOB e-StoreIOB News
 
Manual getic 23-out_09
Manual getic 23-out_09Manual getic 23-out_09
Manual getic 23-out_09Patrícia Eusébio
 
Matemática - Geometria Plana - Livro pdf
Matemática - Geometria Plana - Livro pdfMatemática - Geometria Plana - Livro pdf
Matemática - Geometria Plana - Livro pdfLucas pk'
 
Curso de Direito Processual Penal para Procurador da República 2019
Curso de Direito Processual Penal para Procurador da República 2019Curso de Direito Processual Penal para Procurador da República 2019
Curso de Direito Processual Penal para Procurador da República 2019Estratégia Carreira Jurídica
 
Koscianski sumario
Koscianski sumarioKoscianski sumario
Koscianski sumarioJair Alarcón
 
Adwords passo-a-passo
Adwords passo-a-passoAdwords passo-a-passo
Adwords passo-a-passoWilliam Silva
 
Matemática Básica - Livro pdf
Matemática Básica - Livro pdfMatemática Básica - Livro pdf
Matemática Básica - Livro pdfLucas pk'
 
COMÉRCIO ELETRÔNICO DE PRODUTOS VIA WEB
COMÉRCIO ELETRÔNICO DE PRODUTOS VIA WEB COMÉRCIO ELETRÔNICO DE PRODUTOS VIA WEB
COMÉRCIO ELETRÔNICO DE PRODUTOS VIA WEB Norton Guimarães
 
Proinov 10 anos
Proinov 10 anosProinov 10 anos
Proinov 10 anosProinov
 
Exercicios java2016 - resolvidos
Exercicios java2016 - resolvidosExercicios java2016 - resolvidos
Exercicios java2016 - resolvidosHelda Matos
 
Maratona de programação 2009. Exercícios para Iniciantes.
Maratona de programação 2009. Exercícios para Iniciantes.Maratona de programação 2009. Exercícios para Iniciantes.
Maratona de programação 2009. Exercícios para Iniciantes.Rayan Teixeira
 
Java basico modulo_01
Java basico modulo_01Java basico modulo_01
Java basico modulo_01Daniel Alves
 

Contenu connexe

Tendances

Pontes Ferroviárias
Pontes FerroviáriasPontes Ferroviárias
Pontes FerroviáriasDaniel Campos
 
Programacao Orientada A Objetos (Java)
Programacao Orientada A Objetos (Java)Programacao Orientada A Objetos (Java)
Programacao Orientada A Objetos (Java)Robson Silva Espig
 
Certificação Digital : Uma Nova Era de Segurança Eletrônica
Certificação Digital : Uma Nova Era de Segurança EletrônicaCertificação Digital : Uma Nova Era de Segurança Eletrônica
Certificação Digital : Uma Nova Era de Segurança Eletrônicaluizrbs
 
Manual+de+enfermagem+(messauandra+de+oliveira+silva)
Manual+de+enfermagem+(messauandra+de+oliveira+silva)Manual+de+enfermagem+(messauandra+de+oliveira+silva)
Manual+de+enfermagem+(messauandra+de+oliveira+silva)Marcelo Leal Souza
 
Tecnicas Gerais De Enfermagem
Tecnicas Gerais De EnfermagemTecnicas Gerais De Enfermagem
Tecnicas Gerais De EnfermagemRutesilva
 
Apostila estatistica 2004_2
Apostila estatistica 2004_2Apostila estatistica 2004_2
Apostila estatistica 2004_2Míriam Pimenta
 
Apostila tga i sem
Apostila tga i semApostila tga i sem
Apostila tga i semadm2011jba
 
Calendário seguros
Calendário segurosCalendário seguros
Calendário segurosvicelima
 
contabilidade
contabilidadecontabilidade
contabilidadewixbrasil
 
Classificação Fiscal de Mercadorias na Prática - IOB e-Store
Classificação Fiscal de Mercadorias na Prática - IOB e-StoreClassificação Fiscal de Mercadorias na Prática - IOB e-Store
Classificação Fiscal de Mercadorias na Prática - IOB e-StoreIOB News
 
Matemática - Geometria Plana - Livro pdf
Matemática - Geometria Plana - Livro pdfMatemática - Geometria Plana - Livro pdf
Matemática - Geometria Plana - Livro pdfLucas pk'
 
Curso de Direito Processual Penal para Procurador da República 2019
Curso de Direito Processual Penal para Procurador da República 2019Curso de Direito Processual Penal para Procurador da República 2019
Curso de Direito Processual Penal para Procurador da República 2019Estratégia Carreira Jurídica
 
Adwords passo-a-passo
Adwords passo-a-passoAdwords passo-a-passo
Adwords passo-a-passoWilliam Silva
 
Matemática Básica - Livro pdf
Matemática Básica - Livro pdfMatemática Básica - Livro pdf
Matemática Básica - Livro pdfLucas pk'
 
COMÉRCIO ELETRÔNICO DE PRODUTOS VIA WEB
COMÉRCIO ELETRÔNICO DE PRODUTOS VIA WEB COMÉRCIO ELETRÔNICO DE PRODUTOS VIA WEB
COMÉRCIO ELETRÔNICO DE PRODUTOS VIA WEB Norton Guimarães
 
Proinov 10 anos
Proinov 10 anosProinov 10 anos
Proinov 10 anosProinov
 

Tendances (19)

Pontes Ferroviárias
Pontes FerroviáriasPontes Ferroviárias
Pontes Ferroviárias
 
Luos
LuosLuos
Luos
 
Programacao Orientada A Objetos (Java)
Programacao Orientada A Objetos (Java)Programacao Orientada A Objetos (Java)
Programacao Orientada A Objetos (Java)
 
Certificação Digital : Uma Nova Era de Segurança Eletrônica
Certificação Digital : Uma Nova Era de Segurança EletrônicaCertificação Digital : Uma Nova Era de Segurança Eletrônica
Certificação Digital : Uma Nova Era de Segurança Eletrônica
 
Manual+de+enfermagem+(messauandra+de+oliveira+silva)
Manual+de+enfermagem+(messauandra+de+oliveira+silva)Manual+de+enfermagem+(messauandra+de+oliveira+silva)
Manual+de+enfermagem+(messauandra+de+oliveira+silva)
 
Tecnicas Gerais De Enfermagem
Tecnicas Gerais De EnfermagemTecnicas Gerais De Enfermagem
Tecnicas Gerais De Enfermagem
 
Apostila estatistica 2004_2
Apostila estatistica 2004_2Apostila estatistica 2004_2
Apostila estatistica 2004_2
 
Apostila tga i sem
Apostila tga i semApostila tga i sem
Apostila tga i sem
 
Calendário seguros
Calendário segurosCalendário seguros
Calendário seguros
 
contabilidade
contabilidadecontabilidade
contabilidade
 
Classificação Fiscal de Mercadorias na Prática - IOB e-Store
Classificação Fiscal de Mercadorias na Prática - IOB e-StoreClassificação Fiscal de Mercadorias na Prática - IOB e-Store
Classificação Fiscal de Mercadorias na Prática - IOB e-Store
 
Manual getic 23-out_09
Manual getic 23-out_09Manual getic 23-out_09
Manual getic 23-out_09
 
Matemática - Geometria Plana - Livro pdf
Matemática - Geometria Plana - Livro pdfMatemática - Geometria Plana - Livro pdf
Matemática - Geometria Plana - Livro pdf
 
Curso de Direito Processual Penal para Procurador da República 2019
Curso de Direito Processual Penal para Procurador da República 2019Curso de Direito Processual Penal para Procurador da República 2019
Curso de Direito Processual Penal para Procurador da República 2019
 
Koscianski sumario
Koscianski sumarioKoscianski sumario
Koscianski sumario
 
Adwords passo-a-passo
Adwords passo-a-passoAdwords passo-a-passo
Adwords passo-a-passo
 
Matemática Básica - Livro pdf
Matemática Básica - Livro pdfMatemática Básica - Livro pdf
Matemática Básica - Livro pdf
 
COMÉRCIO ELETRÔNICO DE PRODUTOS VIA WEB
COMÉRCIO ELETRÔNICO DE PRODUTOS VIA WEB COMÉRCIO ELETRÔNICO DE PRODUTOS VIA WEB
COMÉRCIO ELETRÔNICO DE PRODUTOS VIA WEB
 
Proinov 10 anos
Proinov 10 anosProinov 10 anos
Proinov 10 anos
 

En vedette

Exercicios java2016 - resolvidos
Exercicios java2016 - resolvidosExercicios java2016 - resolvidos
Exercicios java2016 - resolvidosHelda Matos
 
Maratona de programação 2009. Exercícios para Iniciantes.
Maratona de programação 2009. Exercícios para Iniciantes.Maratona de programação 2009. Exercícios para Iniciantes.
Maratona de programação 2009. Exercícios para Iniciantes.Rayan Teixeira
 
Java basico modulo_01
Java basico modulo_01Java basico modulo_01
Java basico modulo_01Daniel Alves
 
Revisão Sobre Programação Orientada a Objetos com Java
Revisão Sobre Programação Orientada a Objetos com Java Revisão Sobre Programação Orientada a Objetos com Java
Revisão Sobre Programação Orientada a Objetos com Java Mario Jorge Pereira
 
Linguagem Java - Conceitos e Técnicas
Linguagem Java - Conceitos e TécnicasLinguagem Java - Conceitos e Técnicas
Linguagem Java - Conceitos e TécnicasBreno Vitorino
 
Curso Java Basico
Curso Java BasicoCurso Java Basico
Curso Java BasicoJoel Lobo
 
Programação orientada a objetos
Programação orientada a objetosProgramação orientada a objetos
Programação orientada a objetosCleyton Ferrari
 

En vedette (18)

Exercicios java2016 - resolvidos
Exercicios java2016 - resolvidosExercicios java2016 - resolvidos
Exercicios java2016 - resolvidos
 
Maratona de programação 2009. Exercícios para Iniciantes.
Maratona de programação 2009. Exercícios para Iniciantes.Maratona de programação 2009. Exercícios para Iniciantes.
Maratona de programação 2009. Exercícios para Iniciantes.
 
Java basico modulo_01
Java basico modulo_01Java basico modulo_01
Java basico modulo_01
 
Revisão Sobre Programação Orientada a Objetos com Java
Revisão Sobre Programação Orientada a Objetos com Java Revisão Sobre Programação Orientada a Objetos com Java
Revisão Sobre Programação Orientada a Objetos com Java
 
POO - 20 - Wrapper Classes
POO - 20 - Wrapper ClassesPOO - 20 - Wrapper Classes
POO - 20 - Wrapper Classes
 
Exercicios java básico
Exercicios java básicoExercicios java básico
Exercicios java básico
 
Curso de Java #12 - Estruturas de Repetição (Parte 2)
Curso de Java #12 - Estruturas de Repetição (Parte 2)Curso de Java #12 - Estruturas de Repetição (Parte 2)
Curso de Java #12 - Estruturas de Repetição (Parte 2)
 
Curso de Java #13 - Estruturas de Repetição (Parte 3)
Curso de Java #13 - Estruturas de Repetição (Parte 3)Curso de Java #13 - Estruturas de Repetição (Parte 3)
Curso de Java #13 - Estruturas de Repetição (Parte 3)
 
Curso de Java #11 - Estruturas de Repetição (Parte 1)
Curso de Java #11 - Estruturas de Repetição (Parte 1)Curso de Java #11 - Estruturas de Repetição (Parte 1)
Curso de Java #11 - Estruturas de Repetição (Parte 1)
 
Curso Java Basico
Curso Java BasicoCurso Java Basico
Curso Java Basico
 
Linguagem Java - Conceitos e Técnicas
Linguagem Java - Conceitos e TécnicasLinguagem Java - Conceitos e Técnicas
Linguagem Java - Conceitos e Técnicas
 
Curso de Java #08 - Operadores Lógicos e Relacionais
Curso de Java #08 - Operadores Lógicos e RelacionaisCurso de Java #08 - Operadores Lógicos e Relacionais
Curso de Java #08 - Operadores Lógicos e Relacionais
 
Curso de Java #07 - Operadores (Parte 1)
Curso de Java #07 - Operadores (Parte 1)Curso de Java #07 - Operadores (Parte 1)
Curso de Java #07 - Operadores (Parte 1)
 
Curso de Java #05 - Swing e JavaFX
Curso de Java #05 - Swing e JavaFXCurso de Java #05 - Swing e JavaFX
Curso de Java #05 - Swing e JavaFX
 
Curso Java Basico
Curso Java BasicoCurso Java Basico
Curso Java Basico
 
Programação orientada a objetos
Programação orientada a objetosProgramação orientada a objetos
Programação orientada a objetos
 
Curso de Java #10 - Estruturas Condicionais (Parte 2)
Curso de Java #10 - Estruturas Condicionais (Parte 2)Curso de Java #10 - Estruturas Condicionais (Parte 2)
Curso de Java #10 - Estruturas Condicionais (Parte 2)
 
Curso de Java #09 - Estruturas Condicionais (Parte 1)
Curso de Java #09 - Estruturas Condicionais (Parte 1)Curso de Java #09 - Estruturas Condicionais (Parte 1)
Curso de Java #09 - Estruturas Condicionais (Parte 1)
 

Similaire à Java na Prática - Introdução à Programação Orientada a Objetos com Java

Apostila de-logistica canal de distribuição
Apostila de-logistica canal de distribuiçãoApostila de-logistica canal de distribuição
Apostila de-logistica canal de distribuiçãoIandra Gasparini
 
javscript para iniciantes
javscript para iniciantesjavscript para iniciantes
javscript para iniciantesbradock1964
 
Estrutura e Análise de Balanço - IOB e-Store
Estrutura e Análise de Balanço - IOB e-StoreEstrutura e Análise de Balanço - IOB e-Store
Estrutura e Análise de Balanço - IOB e-StoreIOB News
 
Contabilidade geral e tributaria – 7ª edição
Contabilidade geral e tributaria – 7ª edição Contabilidade geral e tributaria – 7ª edição
Contabilidade geral e tributaria – 7ª edição IOB News
 
Análise Financeira e Orçamentária - IOB e-Store
Análise Financeira e Orçamentária - IOB e-StoreAnálise Financeira e Orçamentária - IOB e-Store
Análise Financeira e Orçamentária - IOB e-StoreIOB News
 
Apostila teoria contabilidade_geral
Apostila teoria contabilidade_geralApostila teoria contabilidade_geral
Apostila teoria contabilidade_geralzeramento contabil
 
Exame de Suficiência em Contabilidade - 3ª edição - IOB e-Store
Exame de Suficiência em Contabilidade - 3ª edição - IOB e-StoreExame de Suficiência em Contabilidade - 3ª edição - IOB e-Store
Exame de Suficiência em Contabilidade - 3ª edição - IOB e-StoreIOB News
 
Coleção IOB Trabalhista e Previdenciária - Benefícios Previdenciários - Cálcu...
Coleção IOB Trabalhista e Previdenciária - Benefícios Previdenciários - Cálcu...Coleção IOB Trabalhista e Previdenciária - Benefícios Previdenciários - Cálcu...
Coleção IOB Trabalhista e Previdenciária - Benefícios Previdenciários - Cálcu...IOB News
 
Manual de gestão de marketing
Manual de gestão de marketingManual de gestão de marketing
Manual de gestão de marketingCristina Fernandes
 
Tutorial sistema vendas_em_java_com_swing
Tutorial sistema vendas_em_java_com_swingTutorial sistema vendas_em_java_com_swing
Tutorial sistema vendas_em_java_com_swingEverson Wolf
 
700-experimentos-da-consciencio-waldo-vieira-parte-1
700-experimentos-da-consciencio-waldo-vieira-parte-1700-experimentos-da-consciencio-waldo-vieira-parte-1
700-experimentos-da-consciencio-waldo-vieira-parte-1Antonio Faustino
 
Estrutura Conceitual para a Elaboração e a Divulgação de Relatório Contábil F...
Estrutura Conceitual para a Elaboração e a Divulgação de Relatório Contábil F...Estrutura Conceitual para a Elaboração e a Divulgação de Relatório Contábil F...
Estrutura Conceitual para a Elaboração e a Divulgação de Relatório Contábil F...IOB News
 

Similaire à Java na Prática - Introdução à Programação Orientada a Objetos com Java (20)

Cpa 10
Cpa 10Cpa 10
Cpa 10
 
Maquinas termicas ii
Maquinas termicas iiMaquinas termicas ii
Maquinas termicas ii
 
Apostila de-logistica canal de distribuição
Apostila de-logistica canal de distribuiçãoApostila de-logistica canal de distribuição
Apostila de-logistica canal de distribuição
 
javscript para iniciantes
javscript para iniciantesjavscript para iniciantes
javscript para iniciantes
 
Estrutura e Análise de Balanço - IOB e-Store
Estrutura e Análise de Balanço - IOB e-StoreEstrutura e Análise de Balanço - IOB e-Store
Estrutura e Análise de Balanço - IOB e-Store
 
Contabilidade geral e tributaria – 7ª edição
Contabilidade geral e tributaria – 7ª edição Contabilidade geral e tributaria – 7ª edição
Contabilidade geral e tributaria – 7ª edição
 
Análise Financeira e Orçamentária - IOB e-Store
Análise Financeira e Orçamentária - IOB e-StoreAnálise Financeira e Orçamentária - IOB e-Store
Análise Financeira e Orçamentária - IOB e-Store
 
Norma 02 2013
Norma 02 2013Norma 02 2013
Norma 02 2013
 
Norma 02 2013
Norma 02 2013Norma 02 2013
Norma 02 2013
 
Apostila teoria contabilidade_geral
Apostila teoria contabilidade_geralApostila teoria contabilidade_geral
Apostila teoria contabilidade_geral
 
Apostila
ApostilaApostila
Apostila
 
Apostila cpa 20
Apostila cpa 20Apostila cpa 20
Apostila cpa 20
 
Exame de Suficiência em Contabilidade - 3ª edição - IOB e-Store
Exame de Suficiência em Contabilidade - 3ª edição - IOB e-StoreExame de Suficiência em Contabilidade - 3ª edição - IOB e-Store
Exame de Suficiência em Contabilidade - 3ª edição - IOB e-Store
 
Coleção IOB Trabalhista e Previdenciária - Benefícios Previdenciários - Cálcu...
Coleção IOB Trabalhista e Previdenciária - Benefícios Previdenciários - Cálcu...Coleção IOB Trabalhista e Previdenciária - Benefícios Previdenciários - Cálcu...
Coleção IOB Trabalhista e Previdenciária - Benefícios Previdenciários - Cálcu...
 
Manual de gestão de marketing
Manual de gestão de marketingManual de gestão de marketing
Manual de gestão de marketing
 
Manual de marketing
Manual de marketingManual de marketing
Manual de marketing
 
Tutorial sistema vendas_em_java_com_swing
Tutorial sistema vendas_em_java_com_swingTutorial sistema vendas_em_java_com_swing
Tutorial sistema vendas_em_java_com_swing
 
Itur Manual
Itur ManualItur Manual
Itur Manual
 
700-experimentos-da-consciencio-waldo-vieira-parte-1
700-experimentos-da-consciencio-waldo-vieira-parte-1700-experimentos-da-consciencio-waldo-vieira-parte-1
700-experimentos-da-consciencio-waldo-vieira-parte-1
 
Estrutura Conceitual para a Elaboração e a Divulgação de Relatório Contábil F...
Estrutura Conceitual para a Elaboração e a Divulgação de Relatório Contábil F...Estrutura Conceitual para a Elaboração e a Divulgação de Relatório Contábil F...
Estrutura Conceitual para a Elaboração e a Divulgação de Relatório Contábil F...
 

Java na Prática - Introdução à Programação Orientada a Objetos com Java

  • 1. UNIVERSIDADE FEDERAL DE VIÇOSA DEPARTAMENTO DE INFORMÁTICA JAVA NA PRÁTICA Alcione de Paiva Oliveira Vinícius Valente Maciel 2002
  • 2. Java na Prática 1 Sumário Capítulo I - Introdução ....................................... 6 CONVENÇÕES ........................................................................................................................... 10 Capítulo II - Programação Orientada a Objetos .................. 11 CLASSES E OBJETOS E LINGUAGENS DE PROGRAMAÇÃO ......................................................... 12 Ocultando de Informação................................................................................................... 16 Especialização e Herança .................................................................................................. 17 Sobrescrita, Sobrecarga e Polimorfismo............................................................................ 18 INTRODUÇÃO À DIAGRAMA DE CLASSES ................................................................................. 20 Diagrama de Classes.......................................................................................................... 20 Capítulo III - Introdução à Linguagem Java ..................... 27 PALAVRAS RESERVADAS ......................................................................................................... 30 LITERAIS .................................................................................................................................. 31 SEPARADORES.......................................................................................................................... 34 TIPOS DE DADOS....................................................................................................................... 35 Tipos de dados simples....................................................................................................... 35 Tipos de dados compostos .................................................................................................. 37 CONVERSÃO DE TIPOS.............................................................................................................. 41 OPERADORES ........................................................................................................................... 42 Expressões e Precedência entre Operadores ..................................................................... 50 COMENTÁRIOS ......................................................................................................................... 51 BLOCOS E ESCOPO ................................................................................................................... 52 ESTRUTURAS DE CONTROLE .................................................................................................... 53 Seleção ............................................................................................................................... 53 Repetição............................................................................................................................ 57 break e continue ......................................................................................................... 60 ARGUMENTOS DA LINHA DE COMANDO .................................................................................... 61 ASSERT (ASSERTIVAS) ............................................................................................................. 63 Sintaxe e semântica ............................................................................................................ 63 Habilitando e Desabilitando Assertivas ............................................................................. 64 Capítulo IV Classes, Packages e Interfaces ................... 66 CLASSES .................................................................................................................................. 66 Construtores ....................................................................................................................... 68 Valor de Retorno ................................................................................................................ 68 OBJETOS .................................................................................................................................. 69 MODIFICADORES DE ACESSO .................................................................................................... 72 Outros Modificadores......................................................................................................... 74 REFERÊNCIAS COMPARTILHADAS ............................................................................................ 78 COPIANDO OBJETOS ................................................................................................................. 81 O objeto this ................................................................................................................... 81 PACKAGES ............................................................................................................................... 83 Usando Packages ............................................................................................................... 83 Criando Packages .............................................................................................................. 84 O Mecanismo de Extensão ................................................................................................. 86 DERIVANDO CLASSES ............................................................................................................... 88 super ................................................................................................................................... 90 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 3. Java na Prática 2 A classe Object ............................................................................................................... 91 Sobrescrita e Polimorfismo ................................................................................................ 92 CLASSES E MÉTODOS ABSTRATOS ........................................................................................... 95 INTERFACES ............................................................................................................................. 96 CLASSES INTERNAS .................................................................................................................. 99 Classes Internas Anônimas............................................................................................... 101 CONVERSÃO........................................................................................................................... 103 EXCEÇÕES.............................................................................................................................. 103 A hierarquia de Exceções................................................................................................. 105 Capturando mais de uma exceção.................................................................................... 106 Lançando exceções........................................................................................................... 107 Comportamento do Sistema diante das Exceções ............................................................ 109 Criando suas próprias exceções....................................................................................... 110 A cláusula finally ....................................................................................................... 111 DOCUMENTANDO O CÓDIGO................................................................................................... 112 Rótulos.............................................................................................................................. 113 HTML embutida ............................................................................................................... 115 AGENDA ELETRÔNICA VERSÃO CONSOLE 1.0 ........................................................................ 115 Capítulo V – Entrada e Saída (java.io) ...................... 122 ACESSO SEQUENCIAL............................................................................................................. 122 ACESSO DIRETO ..................................................................................................................... 127 Capítulo VI – java.util ..................................... 131 LIDANDO COM COLEÇÕES ...................................................................................................... 131 As Interfaces Iterator e Enumeration ................................................................... 131 Vector ........................................................................................................................... 133 Stack.............................................................................................................................. 136 Hashtable .................................................................................................................... 138 MISCELÂNEA DE CLASSES DO PACOTE JAVA.UTIL................................................................. 141 Arrays ........................................................................................................................... 141 Date ................................................................................................................................ 144 Observable .................................................................................................................. 146 StringTokenizer ...................................................................................................... 150 AGENDA ELETRÔNICA VERSÃO CONSOLE 2.0 ........................................................................ 152 Capítulo VII - Serialização e Persistência .................... 159 AGENDA ELETRÔNICA VERSÃO CONSOLE 2.1 ........................................................................ 161 Capítulo VIII – AWT (Abstract Window Toolkit) ............... 164 A HIERARQUIA DE COMPONENTES ......................................................................................... 164 OLÁ MUNDO AWT ................................................................................................................ 166 TRATAMENTO DE EVENTOS ................................................................................................... 167 Modelo de Eventos 1.1 ..................................................................................................... 167 Tratamento de Eventos com classes Internas................................................................... 171 EXEMPLO BÁSICO .................................................................................................................. 176 ACRESCENTANDO CORES ....................................................................................................... 180 GERENCIANDO O LAYOUT...................................................................................................... 181 Exemplo com BorderLayout....................................................................................... 182 Exemplo com FlowLayout ........................................................................................... 183 Exemplo com CardLayout ........................................................................................... 184 Exemplo com GridLayout ........................................................................................... 186 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 4. Java na Prática 3 Exemplo com GridBagLayout .................................................................................... 187 UTILIZANDO LISTAS............................................................................................................... 189 TRABALHANDO COM MENUS E DIÁLOGOS ............................................................................. 192 CAPTURANDO EVENTOS DO TECLADO ................................................................................... 196 PRINCIPAIS CLASSES .............................................................................................................. 196 Color.............................................................................................................................. 196 Component .................................................................................................................... 198 Button ........................................................................................................................... 200 Label.............................................................................................................................. 201 List ................................................................................................................................ 202 TextField .................................................................................................................... 203 TextArea....................................................................................................................... 204 CONTAINERS .......................................................................................................................... 205 Panel.............................................................................................................................. 207 Frame.............................................................................................................................. 208 AGENDA ELETRÔNICA VERSÃO GRÁFICA 1.0......................................................................... 211 Capítulo IX - Applets ....................................... 217 DESCRIÇÃO DO CÓDIGO HTML ............................................................................................. 221 MÉTODOS DA CLASSE APPLET ............................................................................................... 222 EXIBINDO UMA IMAGEM ........................................................................................................ 226 ÁUDIO .................................................................................................................................... 229 OBTENDO PARÂMETROS ......................................................................................................... 230 EXECUTANDO UM APPLET COMO APLICAÇÃO ........................................................................ 232 PREPARANDO APPLETS PARA PRODUÇÃO E ARQUIVOS JARS ................................................. 232 CRIANDO OS PRÓPRIOS ARQUIVOS MANIFEST ......................................................................... 235 AGENDA ELETRÔNICA VERSÃO APPLET 1.0 ........................................................................... 236 Capítulo X JavaBean ......................................... 237 O QUE É UM JAVABEAN? ....................................................................................................... 237 JAVABEANS E FERRAMENTAS RAD ....................................................................................... 237 PROPRIEDADES ...................................................................................................................... 238 Simples ............................................................................................................................. 238 Indexada ........................................................................................................................... 239 Ligada (Bound)................................................................................................................. 240 Restringidas(Constrained) ............................................................................................... 241 EVENTOS................................................................................................................................ 243 DESENVOLVIMENTO DO EXEMPLO ......................................................................................... 244 TimerEventListener .......................................................................................................... 244 TimerEvent ....................................................................................................................... 245 TimerBean ........................................................................................................................ 245 INSTALANDO O BEANS DEVELOPMENT KIT (BDK)................................................................ 249 TESTANDO EXEMPLO NO BDK ............................................................................................... 249 Capítulo XI - Concorrência .................................... 255 CRIANDO THREADS EM JAVA ................................................................................................. 257 Criando threads por meio da interface Runnable ........................................................ 259 A CLASSE THREAD ................................................................................................................. 259 Hierarquia ........................................................................................................................ 259 Construtores ..................................................................................................................... 259 Métodos ............................................................................................................................ 259 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 5. Java na Prática 4 Variáveis públicas ............................................................................................................ 259 CICLO DE VIDA DOS THREADS ............................................................................................... 259 sleep(), yield(), join(), destroy(), stop(), suspend() e resume(). .............. 259 DAEMON THREADS ................................................................................................................ 259 INFLUÊNCIA DO SISTEMA OPERACIONAL NO COMPORTAMENTO DOS THREADS..................... 259 Forma de escalonamento de threads................................................................................ 259 Relacionamento entre os níveis de prioridades definidas na linguagem Java e os níveis de prioridades definidas nos Sistemas Operacionais............................................................ 259 COMPARTILHAMENTO DE MEMÓRIA E SINCRONIZAÇÃO ........................................................ 259 Atomicidade de Instruções e Sincronização do Acesso à Sessões Críticas ...................... 259 Comunicação entre Threads: wait() e notify() ................................................................. 259 Capítulo XII - Animação ....................................... 259 Capítulo XIII - Programação em rede ......................... 259 CONCEITOS SOBRE PROTOCOLOS USADOS NA INTERNET....................................................... 259 TCP................................................................................................................................... 259 UDP.................................................................................................................................. 259 IDENTIFICAÇÃO DE HOSTS (Número IP).................................................................... 259 Identificação de Processos (Portas)................................................................................. 259 PROGRAMAÇÃO EM REDE COM JAVA ..................................................................................... 259 Comunicação Básica Entre Aplicações............................................................................ 259 Comunicação Sem Conexão (UDP) ................................................................................. 259 Comunicação por meio de URL ....................................................................................... 259 Capítulo XIV – Computação Distribuída (RMI) ................. 259 CRIANDO NOSSA AGENDA DISTRIBUÍDA ................................................................................. 259 Implementar interface do objeto remoto .......................................................................... 259 Capítulo XV - Acesso a Banco de Dados ....................... 259 MODELOS DE ACESSO A SERVIDORES .................................................................................... 259 TIPOS DE DRIVERS JDBC....................................................................................................... 259 Obtendo os Drivers JDBC................................................................................................ 259 PREPARANDO UM BANCO DE DADOS ..................................................................................... 259 Configurando o ODBC..................................................................................................... 259 EXEMPLO INICIAL .................................................................................................................. 259 Carregando o Driver........................................................................................................ 259 Estabelecendo a conexão ................................................................................................. 259 Criando e Executando Comandos .................................................................................... 259 RECUPERANDO VALORES....................................................................................................... 259 TRANSAÇÕES E NÍVEL DE ISOLAMENTO ................................................................................. 259 Transação......................................................................................................................... 259 Níveis de isolamento......................................................................................................... 259 PREPARED STATEMENTS ........................................................................................................ 259 PROCEDIMENTOS ARMAZENADOS (STORED PROCEDURES).................................................... 259 AGENDA ELETRÔNICA VERSÃO JDBC ................................................................................... 259 Capítulo XVI Servlets e JSP ................................. 259 SERVLETS .............................................................................................................................. 259 Applets X Servlets............................................................................................................. 259 CGI X Servlets .................................................................................................................. 259 A API SERVLET ..................................................................................................................... 259 Exemplo de Servlet ........................................................................................................... 259 COMPILANDO O SERVLET....................................................................................................... 259 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 6. Java na Prática 5 Instalando o Tomcat......................................................................................................... 259 PREPARANDO PARA EXECUTAR O SERVLET ............................................................................ 259 Compilando o Servlet ....................................................................................................... 259 Criando uma aplicação no Tomcat .................................................................................. 259 EXECUTANDO O SERVLET ...................................................................................................... 259 Invocando diretamente pelo Navegador........................................................................... 259 Invocando em uma página HTML .................................................................................... 259 Diferenças entre as requisições GET e POST .................................................................. 259 CONCORRÊNCIA ..................................................................................................................... 259 OBTENDO INFORMAÇÕES SOBRE A REQUISIÇÃO .................................................................... 259 LIDANDO COM FORMULÁRIOS................................................................................................ 259 LIDANDO COM COOKIES......................................................................................................... 259 LIDANDO COM SESSÕES ......................................................................................................... 259 JSP......................................................................................................................................... 259 PHP X JSP ....................................................................................................................... 259 ASP X JSP ........................................................................................................................ 259 Primeiro exemplo em JSP ................................................................................................ 259 Executando o arquivo JSP................................................................................................ 259 Objetos implícitos............................................................................................................. 259 Tags JSP........................................................................................................................... 259 Comentários ..................................................................................................................... 259 Diretivas ........................................................................................................................... 259 Extraindo Valores de Formulários................................................................................... 259 Criando e Modificando Cookies....................................................................................... 259 Lidando com sessões ........................................................................................................ 259 O Uso de JavaBeans......................................................................................................... 259 REENCAMINHANDO OU REDIRECIONANDO REQUISIÇÕES ....................................................... 259 UMA ARQUITETURA PARA COMÉRCIO ELETRÔNICO ............................................................... 259 Tipos de aplicações na WEB ............................................................................................ 259 Arquitetura MVC para a Web .......................................................................................... 259 Agenda Web: Um Exemplo de uma aplicação Web usando a arquitetura MVC.............. 259 Capítulo XVII Perguntas Frequentes .......................... 259 Bibliografia ................................................ 259 Links ....................................................... 259 Índice ...................................................... 259 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 7. Java na Prática 6 Capítulo I - Introdução Java é uma linguagem de programação desenvolvida pela Sun Microsystems e lançada em versão beta em 1995. O seu desenvolvimento foi iniciado em 1991 pela equipe liderada por James Gosling visando o mercado de bens eletrônicos de consumo. Por isso foi projetada desde o início para ser independente de hardware, uma vez que as características dos equipamentos variam amplamente neste nicho de desenvolvimento. Outro objetivo estabelecido desde sua concepção foi o de ser uma linguagem segura. Segura tanto no sentido de evitar algumas falhas comuns que os programadores costumam cometer durante o desenvolvimento, como no sentido de evitar ataques externos. Isto é importante no mercado de bens eletrônicos de consumo por que ninguém gostaria de adquirir um produto que necessitasse desligar e religar para que voltasse a funcionar corretamente. Estas características despertaram o interesse para utilização de Java em outro ambiente que também necessitava de uma linguagem com este perfil: a Internet. A Internet também é um ambiente constituído por equipamentos de diferentes arquiteturas e necessita muito de uma linguagem que permita a construção de aplicativos seguros. Muitas pessoas argumentarão que estas características podem ser encontradas em outras linguagens e portanto isto não explica o súbito sucesso da linguagem. Podemos arriscar alguns palpites apesar de este ser um terreno um pouco pantanoso para se aventurar, até por que as linguagens de programação tendem assumir um caráter quase religioso. Uma das razões que na nossa opinião favoreceram a rápida adoção da linguagem foi a sintaxe. Java é sintaticamente muito semelhante à linguagem C/C++, apesar de existirem diferenças fundamentais na filosofia de implementação entre as duas linguagens. Isto facilitou a migração de uma legião imensa de programadores C/C++ para a nova linguagem. Outra razão que não pode ser desprezada é o momento atual onde os desenvolvedores estão ansiosos para se libertarem de sistemas proprietários. Portanto, apesar de não serem novas as idéias embutidas na linguagem Java, a reunião delas em uma só linguagem, juntamente com a facilidade migração dos programadores e o momento atual, contribuíram para o rápido sucesso da linguagem. Hoje, segundo a International Data Corp. (IDC), existem mais de 2 milhões de programadores Java no mundo e a estimativa é que o número de desenvolvedores ultrapasse os 5 milhões em 2004. O número de programadores Java deve ultrapassar o de programadores C++ ainda este ano (2002), segundo a consultoria americana Evans Data. Os profissionais que dominam a linguagem Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 8. Java na Prática 7 estão entre os mais bem pagos da área de Tecnologia da Informação (TI), com salários variando de 3 a 10 mil reais, podendo em alguns casos chegar à 16 mil reais, segundo a revista Info Exame (dezembro de 2001). A lista abaixo apresenta as principais características de Java de modo que o leitor tenha uma visão geral da linguagem: • Orientação a objetos. Java não é uma linguagem totalmente orientada a objetos como Smalltalk, onde tudo é objeto ou métodos de objetos. Por questões de eficiência foram mantidos alguns tipos primitivos e suas operações. No entanto, Java possui um grau de orientação a objetos bem maior que C/C++, o que a torna bem mais harmoniosa e fácil de assimilar, uma vez que o programador tenha compreendido esta forma de desenvolvimento. • Compilação do código fonte para código de uma máquina virtual (Bytecodes). Esta característica visa tornar a linguagem independente de plataforma de Hardware e Sistema Operacional. Obviamente é necessário que exista um programa capaz de interpretar o código em Bytecodes para cada Sistema Operacional, denominado de Máquina Virtual. No entanto, nada impede que o código fonte seja traduzido diretamente para o código executável na máquina de destino. Já existem ambientes de desenvolvimento que apresentam este tipo de opção. Alternativamente, é possível projetar equipamentos que processem em hardware os Bytecodes. A Sun desenvolveu um processador que executa operações em Bytecodes, denominado de JavaChip. O diagrama abaixo ilustra as etapas envolvidas na execução de um código Java. Figura I-1. Fases para execução de um programa fonte em Java • Ausência de manipulação explícita de ponteiros. Em linguagens como C/C++ e Pascal existe o tipo ponteiro como tipo primitivo da linguagem. A especificação original de Pascal é restritiva no uso de ponteiros, permitindo que sejam usados apenas para referenciar memória obtida na área de alocação dinâmica (heap) e não permite que o programador examine o valor Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 9. Java na Prática 8 da variável do tipo ponteiro, nem que realize operações aritméticas com ponteiros. Já a linguagem C/C++ permite que o valor armazenado na variável do tipo ponteiro faça referência a qualquer área de memória, inclusive à área estática e automática (pilha), além de permitir aritmética de ponteiros e o exame direto do valor armazenado. A manipulação do tipo ponteiro exige uma grande dose de atenção por parte do programador e mesmo programadores experientes frequentemente cometem erros no seu uso. Além disso, o uso de ponteiros é uma fonte de insegurança na linguagem, uma vez que permite que o usuário faça acesso a memória que pode pertencer a outros processos, abrindo a possibilidade para desenvolvimento de programas hostis ao sistema. A linguagem Java não possui o tipo ponteiro. Isto não que dizer que não seja possível realizar alocação dinâmica de memória. Todo objeto criado é alocado na área de heap, mas o usuário não pode manipular a referência ao objeto explicitamente. • Recuperação automática de memória não utilizada (Coleta de Lixo – Garbage Collection). Nas linguagens onde existe alocação dinâmica de memória, o programador é responsável pela liberação de memória previamente obtida na área de alocação dinâmica e que não está sendo mais utilizada. Se houver falhas na execução desta responsabilidade ocorrerá o problema que é conhecido sob a denominação de “vazamento de memória”. Este problema faz com que a partir de certo ponto o programa não consiga obter memória para criação de novos objetos, apesar de existir área que não está sendo mais usada mas que não foi devolvida ao gerente de memória. Outro erro comum é a tentativa de acesso á áreas de memória já liberadas. Todos os programadores que trabalham com linguagens que permitem alocação dinâmica conhecem bem estes problemas e sabem o quanto é difícil implementar programas que não possuam estes tipos de erros. A maior parte dos erros que ocorrem no uso destas linguagens é devido a problemas na alocação/liberação de memória. Visando o desenvolvimento de aplicações robustas, livres deste tipo de falha, os projetistas de Java incorporaram um procedimento de coleta automática de lixo à máquina virtual. Deste modo, os objetos que não estão sendo mais usados são identificados pelo procedimento, que libera a memória para ser utilizada na criação de novos objetos. • Segurança. As pessoas costumam dizer que Java é uma linguagem segura. Mas o que é ser uma linguagem de programação segura? Segurança possui significados distintos para pessoas diferentes. No caso da linguagem Java na Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 10. Java na Prática 9 versão 1.0 segurança significa impedir que programas hostis que possam causar danos ao ambiente computacional, ou que busquem informações sigilosas em computadores remotos para uso não autorizado. Na versão 1.1 foi adicionada a capacidade de permitir a verificação da identidade dos programas (autenticação) e na versão 1.2 os dados que os programas enviam e recebem podem ser criptografados por meio do uso de um pacote adicional. Na versão 1.4 o pacote de criptografia JCE (JavaTM Cryptography Extension) foi incorporado ao J2SDK. • Suporte à Concorrência. A construção de servidores, a criação de programas com interfaces gráficas, e programas semelhantes que tem em comum a necessidade de que o atendimento de uma solicitação não incapacite o sistema de responder a outras solicitações concorrentemente, demandam o uso de uma linguagem que facilite o desenvolvimento deste tipo de programa. As linguagens projetadas antes do surgimento destas necessidades, como C/C++, não previam facilidades para este tipo de programação, o que obrigou a incorporação destes recursos posteriormente, por meio de funções adicionais. Como a programação concorrente é uma forma de programação que difere bastante da programação sequencial convencional, a simples adição de novas funções para tentar adaptar a linguagem a esta forma de codificação, não cria um ajuste perfeito com a linguagem subjacente. Por outro lado, Java foi projetada visando facilitar a programação concorrente. Isto faz com que a criação linhas de execução (threads) seja bem mais natural dos que nas linguagens tradicionais.Programação em rede. Java possui em seu núcleo básico classes para comunicação em rede por meio dos protocolos pertencentes à pilha de protocolos TCP/IP. A pilha de protocolos TCP/IP é a utilizada pela Internet e tornou-se o padrão de fato para comunicação entre computadores em uma rede heterogênea. Isto torna Java particularmente atrativa para o desenvolvimento de aplicações na Internet. Além disso Java está incorpora um amplo de conjunto de soluções para computação distribuída, como CORBA (Common Object Request Broker Architecture), RMI (Remote Method Invocation) e Servlets/JSP (aplicações Java que são executadas por servidores Web). Após o lançamento da versão beta da linguagem em 1995, a Sun tem liberado diversas evoluções da linguagem na forma de versões e releases de um conjunto de ferramentas denominado de Java Development Kit (JDK) até a versão 1.2, quando se passou a denominar Java 2 SDK (Standard Development Kit). Isto ocorreu porque outros kits de desenvolvimento com propósitos Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 11. Java na Prática 10 específicos foram lançados, como o J2EE (Java 2 Enterprise Edition), voltado para aplicações distribuídas escaláveis e o J2ME (Java 2 Micro Edition), voltado para aplicações embutidas em dispositivos eletrônicos (Celulares, handheld, etc.). Durante a elaboração deste livro, a última versão estável do SDK era a de número 1.3.1 que pode ser obtida gratuitamente no site http://java.sun.com/. Convenções As seguintes convenções são usadas neste livro. 1. Fontes com larguras constantes são usadas em: • exemplos de código public class Ponto { private int x,y; } • nomes de métodos, classes e variáveis mencionadas no texto. 2. Fontes com larguras constantes em negrito são usadas dentro de exemplos de códigos para destacar palavras chave. 3. Fontes em itálico são usadas: • em termos estrangeiros; • na primeira vez que for usado um termo cujo significado não for conhecimento generalizado. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 12. Java na Prática 11 Capítulo II - Programação Orientada a Objetos O mundo pode ser visto como um conjunto de objetos que se relacionam. Por exemplo, uma pessoa, uma casa, uma cadeira da casa, etc. Os objetos não são necessariamente físicos. Podem possuir uma natureza abstrata, como um evento (uma partida de futebol) ou algo inexistente no mundo real (elefante cor- de-rosa). Na verdade, o conceito de objeto atua no nível lógico e não no real. Se iremos representar algo como objeto ou não depende apenas de uma decisão a nível lógico que pode facilitar a simulação de determinado aspecto da realidade. Os objetos se agrupam em classes, segundo propriedades ou atributos comuns. Por exemplo, a classe dos retângulos agrupa todas as formas geométricas com a propriedade de possuir quatro lados formando ângulos de 90o. A relação entre um objeto e uma classe é de pertinência. Dizemos que um objeto pertence a uma classe ou, mais comumente, que é uma instância de uma classe. O Figura abaixo ilustra exemplos de classes. Figura II-1. Classe dos (a) retângulos e dos (b) dos triângulos. As classes podem ser relacionar com outra classe no sentido que uma classe pode conter outra. Por exemplo, a classe de retângulos está inserida em uma classe mais genérica, a classe dos polígonos. A classe mais genérica é denominada de Superclasse e as classes mais específicas são denominadas de Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 13. Java na Prática 12 Subclasses. As subclasses herdam as propriedades das superclasses. No nosso exemplo, os polígonos possuem as propriedades de ter uma área, uma posição no plano, um número n de vértices e n-1 ângulos. Todas essas propriedades são herdadas tanto pela classe dos retângulos como pela classe do triângulos. Podemos desta forma organizar os objetos em uma hierarquia onde as classes mais específicas herdam as propriedades das classes mais genéricas. Figura II-2. Classe dos polígonos. Os objetos de uma classe possuem comportamentos que podem alterar o valor de suas propriedades. Por exemplo, um carro pode sofrer uma aceleração ou ser freado e com isso alterar a sua velocidade. Um objeto qualquer pode ser deslocado, alterando assim as suas coordenadas no espaço. Classes e Objetos e Linguagens de Programação As linguagens de programação são utilizadas para construir simulações de aspectos da realidade no computador. Quanto mais facilmente pudermos expressar os conceitos capturados da realidade, mais facilmente construiremos a simulação. Seguindo este raciocínio podemos concluir que as linguagens que possuem facilidades para representação de objetos permitem uma modelagem mais fácil dos conceitos do mundo real. No entanto, podemos utilizar uma linguagem de programação convencional para modelar as classes e objetos abstraídos da realidade. Por exemplo, podemos modelar a classe dos retângulos por meio de um registro (record) em Pascal. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 14. Java na Prática 13 type Classe_Retangulo = record X1,Y1,X2,Y2: integer; end; Exemplo II-1. Representação da Classe Retângulo em Pascal. No Exemplo II-1 o retângulo é definido por dois pontos, sendo X1 e Y1 o ponto superior esquerdo e X2 e Y2 o ponto inferior direito. Os objetos podem ser representados por meio de variáveis do tipo definido: type Classe_Retangulo = record X1,Y1,X2,Y2: integer; end; var Retangulo1 : Classe_Retangulo; Exemplo II-2. Criação de objetos em Pascal. procedure intRetangulo(XA,YA,XB,YB: integer; var R: Classe_Retangulo); begin R.X1 := XA; R.Y1 := YA; R.X2 := XB; R.Y2 := YB; end; procedure MudaPos(X,Y: integer; var R: Classe_Retangulo); begin R.X2 := X+(R.X2-R.X1); R.Y2 = Y+(R.Y2-R.Y1); R.X1 = X; R.Y1 = Y; end; Exemplo II-3. Definição das operações em Pascal. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 15. Java na Prática 14 As propriedades dos objetos podem ser manipuladas através de funções e procedimentos. Por exemplo, podemos ter uma operação para inicializar os valores da estrutura e outra para alterar a posição do retângulo. O Exemplo II-3 mostra essas duas operações. Contudo, existem algumas limitações das linguagens convencionais que as tornam inadequadas para a modelagem de objetos: • Não existem recursos para ocultar a estrutura de dados de procedimentos que não foram projetados para a sua manipulação. É muito importante que a linguagem forneça recursos para se implementar este tipo de isolamento. Se acessarmos uma estrutura apenas por meio dos procedimentos projetados para este fim, quando a estrutura for alterada apenas os procedimentos que manipulam a estrutura sofreriam modificações. No entanto, se não agirmos desta forma será necessário procurar em todo o programa os acessos diretos à estrutura. Claro que este comportamento pode ser adotado em qualquer linguagem, mas é mais seguro se a linguagem fornece meios para o programador forçar este tipo de comportamento. A capacidade de “esconder” a estrutura de dados de acessos diretos é chamada de ocultação de informação. • Não existem recursos para herança de propriedades entre classes e subclasses. Se precisarmos implementar uma estrutura que é uma especialização de outra já implementada, será preciso codificar novamente todas as propriedades, mesmo as comuns, e todos os procedimentos de acesso. Isto dificulta o reaproveitamento de código, o que, consequentemente aumenta o tempo de desenvolvimento e a possibilidade de erros. • Não existe uma forma de relacionar explicitamente as estruturas de dados com os procedimentos que as manipulam. O relacionamento entre os procedimentos que manipulam uma estrutura de dados e a estrutura é estabelecido implicitamente, por meio de alguma convenção definida pelo programador. É importante que a linguagem obrigue o programador relacionar explicitamente os procedimentos com a estrutura de dados, de modo que fique claro qual é a interface de acesso ao objeto. A adoção de uma linguagem programação orientada a objetos resolve todos esses problemas. Existem várias linguagens comerciais com esta característica: Smalltalk, Eiffel, C++, etc. Algumas com elementos não orientados a objetos como C++, outras puramente orientadas a objetos como Smalltalk, onde tudo é Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 16. Java na Prática 15 objeto. Java é uma linguagem orientada a objetos mais “pura” do que C++, fugindo desta orientação apenas em alguns pontos bem definidos, em nome da eficiência de execução. Em Java podemos representar diretamente as classes e objetos. Por exemplo, a classe retângulo seria declarada da seguinte forma: class Retangulo { int X1,Y1,X2,Y2; public Retangulo(int XA, int YA, int XB, int YB) { X1 = XA; Y1 = YA; X2 = XB; Y2 = YB; } void MudaPos(int X, int Y) { X2 = X+(X2-X1); Y2 = Y+(Y2-Y1); X1 = X; Y1 = Y; }; } Exemplo II-4.Representação da Classe Retângulo em Java. No Exemplo II-4 mudamos o nome do procedimento iniRetangulo para Retangulo, que é o mesmo nome da classe. No momento não é importante entendermos a razão desta mudança, que será esclarecida no próximo capítulo. Note que os procedimentos são declarados dentro do corpo da classe, tornando explícito relacionamento entre a classe e os procedimento. As funções declaradas nas classes são chamadas de métodos e a partir de agora nos referenciaremos a eles como tal. Note também que diferentemente do exemplo em Pascal, não é preciso passar o objeto como parâmetro, uma vez que as variáveis que estão sendo modificadas pertencem ao objeto corrente, ao qual está associado o método. É como se para cada objeto de uma classe fossem criadas versões de todos os métodos da classe, de modo que cada método só opera sobre as variáveis do objeto a quem pertencem. Para declarar uma variável do tipo da classe basta preceder a variável com o nome da classe. Retangulo ret; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 17. Java na Prática 16 Até esse momento nenhum objeto foi criado. Para criar um objeto (instância) é usado o operador new. ret = new Retangulo(10,10,20,30); Note que o operador new é seguido de uma chamada ao método com o mesmo nome da classe. O métodos com esta característica são chamados de construtores e só podem ser invocados durante a criação de um objeto. Como veremos mais tarde, uma classe pode ter mais de um construtor. Após a criação do objeto é possível acessar os outros métodos do objeto através do operador “.”. Por exemplo, podemos mudar a posição do objeto por meio do método MudaPos. ret.MudaPos(40,40); Como já dissemos, não é preciso passar o objeto como argumento, já que é criada uma cópia do método para cada objeto. A grosso modo podemos dizer que cada instância da classe recebe uma cópia da variáveis e dos métodos da classe. Ocultando de Informação O projetista cuidadoso deve ocultar a representação interna da classe, permitindo o acesso aos atributos da classe via métodos predefinidos. Desta forma a representação interna fica isolada do restante do programa e fica mais fácil alterá-la sem que seja preciso alterar outras partes do código. A ocultação de informação é obtida por meio de qualificadores, como o private, que impede o acesso à variáveis via métodos definidos em outras classes. O nível de ocultação depende do qualificador utilizado. Todos os qualificadores serão abordados com detalhes no Capítulo IV. O exemplo II-5 mostra como impedir que as variáveis declaradas na classe Retangulo sejam acessadas diretamente. class Retangulo { private int X1,Y1,X2,Y2; public Retangulo(int XA, int YA, int XB, int YB) { X1 = XA; Y1 = YA; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 18. Java na Prática 17 X2 = XB; Y2 = YB; } void MudaPos(int X, int Y) { X2 = X+(X2-X1); Y2 = Y+(Y2-Y1); X1 = X; Y1 = Y; }; } Exemplo II-5. Ocultando informação em Java. Especialização e Herança Para criar uma subclasse de uma classe pré-existente utilizamos o operador extends. Por exemplo, podemos definir uma subclasse da classe Retangulo, chamada de RetanguloColorido, que possui, além das variáveis e métodos herdados da superclasse, uma variável para armazenar a cor do retângulo, juntamente com um método para alterar o valor. class RetanguloColorido extends Retangulo { private Color Cor; void AtribuiCor(Color C) { Cor = C; }; } Exemplo II-6. Declarando subclasses em Java. A princípio, subclasse pode acessar todos os métodos e variáveis da superclasse. No entanto, isto também pode ser alterado via qualificadores. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 19. Java na Prática 18 Sobrescrita, Sobrecarga e Polimorfismo Podemos definir mais de um método com o mesmo nome na mesma classe ou subclasses. Caso o método possua a mesma assinatura (número e tipos de argumentos e tipo de retorno) que outro método, então o método não pode pertencer à mesma classe do anterior. Se ambos os métodos estiverem na mesma linha hierárquica (classe/subclasse), dizemos que o método da subclasse sobrescreve o método da superclasse. O método que será executado dependerá da classe do objeto. class Empregado { protected float salario; public float getSalario() {return salario;} } class Vendedor extends Empregado { protected float comissao; public float getSalario() {return salario+comissao;} } Exemplo II-7. Sobrescrita do método getSalario(). No exemplo II-7 o método getSalario() da classe Vendedor sobrescreve o método do mesmo nome da classe Empregado. Se a assinatura do método for diferente de outro método com o mesmo nome definido anteriormente na mesma classe ou em outra classe da mesma linha hierárquica, então estamos realizando uma sobrecarga sobre o identificador do método. Quando for usado o identificador dentro do código de um programa o método invocado será determinado pela classe a que pertence o objeto do método e pelo número e tipos dos argumentos passados para o método. O termo sobrecarga advém do fato de um mesmo identificador denotar mais de método. class Empregado { protected float salario; public void aumento() {salario= salario*10.0;} public void aumento(float porcent) Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 20. Java na Prática 19 { salario= salario*porcent; } } Exemplo II-8. Sobrecarga do método aumento(). No exemplo II-8 o identificador aumento pode referenciar dois métodos distintos. Um aumenta o salário em 10% e no outro o aumento depende do valor da porcentagem passado como parâmetro. Note que as assinaturas do métodos diferem entre si. Alguns autores chamam sobrecarga de polimorfismo, que é a habilidade de um determinado objeto se comportar ou ser visto de diferentes formas, quando na verdade a sobrecarga é um tipo particular de polimorfismo, chamado de polimorfismo ad hoc . Na sobrecarga um identificador representa vários métodos com computações distintas. Existe também o polimorfismo paramétrico, onde um método pode realizar a mesma computação sobre objetos de tipos distintos. Isso pode ser implementado em Java definindo um método que recebe e retorna objetos da classe Object. Como a classe Object é a “mãe de todas as classes” o método pode operar da mesma forma independente da classe a qual o objeto realmente pertence, desde que a computação seja independente da classe. class Poli { public Object identidade(Object objeto) { return Object; } } Exemplo II-9. Polimorfismo paramétrico. No Exemplo II-9 o método identidade() retorna o objeto passado como parâmetro. Este método realiza a mesma computação, independentemente da classe do objeto. Obviamente é um exemplo muito simples e sem utilidade prática mas serve para ilustrar o conceito de polimorfismo paramétrico. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 21. Java na Prática 20 Introdução à Diagrama de Classes É possível registrar diretamente em uma linguagem de programação os objetos percebidos em uma determinada realidade. No entanto, é melhor utilizarmos uma notação gráfica intermediária para melhor visualizarmos os objetos e as relações entre objetos, e ir alterando esta representação até estarmos seguros que possuímos um entendimento razoável do problema, e ai sim, partirmos para a codificação da solução. Muitas vezes é preciso recorrer a mais de uma notação gráfica, de modo a expressar várias facetas da realidade que está sendo modelada. Neste livro, recorreremos ao uso de notação gráfica em alguns exemplos para ilustrarmos a arquitetura dos programas antes de apresentarmos o código. Acreditamos que desta forma o leitor compreenderá melhor os exemplos. A notação gráfica que adotamos mostra as relações estáticas entre classes de objetos. Ela faz parte do conjunto de notações da UML (Unified Modeling Language ou Linguagem de Modelagem Unificada) proposta por Grady Booch, James Rumbaugh e Ivar Jacobson em 1995. A UML é um conjunto de notações que tem por objetivo modelar diversos aspectos de um sistema em diferentes níveis de abstração. Ou seja, pode ser utilizado para a captura de requisitos de um sistema assim como em projeto de programas. É voltada para análise e projeto de sistemas orientados a objetos. A área de análise e projeto orientados a objetos ainda não possui uma notação “vencedora” como existe para a análise e projeto estruturado. Contudo, a UML vem se popularizando rapidamente, e é encontrada com facilidade em textos de programação, sobretudo em se tratando de Java. Portanto, um conhecimento sobre as principais notações que constituem a UML é importante para qualquer um que deseja ingressar na área de programação orientada a objetos. Este livro utiliza uma das linguagens, ou diagramas, que compõem a UML: o diagrama de classes. Diagrama de Classes O Diagrama de Classes representa graficamente as classes do sistema e o relacionamento estático entre as classes, isto é, o relacionamento que não muda com o tempo. Por exemplo, em um sistema acadêmico, um aluno cursa várias disciplinas. O número de disciplinas e a disciplina que efetivamente está sendo cursada pode alterar, mas o vínculo aluno-cursa-displinas permanece. Para ilustrar o nosso estudo dos diagramas da UML utilizaremos exemplos sobre modelagem de aspectos realidade acadêmica. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 22. Java na Prática 21 Uma classe é representada no diagrama de classes por meio de um retângulo, que pode ser dividido em até três seções horizontais, como mostrado na figura abaixo: Figura II-3. Forma geral para representação de uma classe. A seção superior é usada para registrar o nome da classe. A seção intermediária é reservada para registro das propriedades da classe, caso existam, e na seção inferior é registrado a assinatura dos métodos que pertencem à classe, caso existam. Por assinatura do método queremos dizer o nome do método, juntamente com seus argumentos e valor de retorno. A figura abaixo mostra uma representação da classe das disciplinas. Figura II-4. Representação da classe das disciplinas De modo geral, por razões de simplicidade, não se representam os métodos que tratam da alteração dos atributos e construtores. Se Assumi que toda classe possui estes métodos. Portanto, podemos simplificar a representação acima, omitindo a seção do métodos. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 23. Java na Prática 22 Figura II-5. Representação simplificada da classe das disciplinas. Podemos indicar tanto nos atributos quanto nas classes a visibilidade deles em relação a outras classes. As visibilidades possíveis, juntamente com os símbolos adotados estão listados na tabela abaixo: Visibilidade Símbolo Descrição Pública + Sem restrição de acesso. Protegida # Pode ser acessado apenas na própria classe e por subclasses. Privada - Pode ser acessado apenas na própria classe. Tabela II-1. Visibilidades possíveis para atributos e métodos. A visibilidade é atribuída a um atributo ou método precedendo a declaração do método com o símbolo adequado, como na figura abaixo: Figura II-6. Representação com visibilidade. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 24. Java na Prática 23 As classes podem se relacionar de diversas formas: por associação comum, por agregação e generalização. Abaixo é apresentada cada forma de relacionamento, juntamente com suas as notações. Associação comum A notação utilizada para associar duas classes é simplesmente uma linha unindo as classes. A figura II.7 mostra a associação entre a classe dos alunos e a classe das disciplinas. Figura II-7. Associação entre Aluno e Disciplina. A figura acima expressa que alunos se associam com disciplinas mas não indica se um aluno se relaciona com várias ou apenas uma disciplina. Esta informação é chamada de cardinalidade da relação e é expressa anotando-se o valor da cardinalidade na associação junto à classe que está sendo relacionada. Assim, a figura II.8 expressa que um aluno se relaciona com várias disciplinas. Figura II-8. Associação de um Aluno com várias Disciplinas. Como uma disciplina se relaciona com vários alunos, o diagrama completo é o representado na figura II-9. Figura II-9. Associação de vários Aluno com várias Disciplinas. A tabela II-2 mostra algumas representações de cardinalidade: Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 25. Java na Prática 24 Notação Descrição 1 Exatamente um * ou 0..* Zero ou mais 0..1 Opcional (zero ou um) n..m Máximo e mínimo Tabela II-2. Representações de cardinalidade. Até agora apresentamos apenas associações entre duas classes, mas nada impede que mais de duas classes participem de uma associação. Por exemplo, a figura II-10 ilustra uma associação ternária que representa o fato de um aluno cursar uma disciplina em um período. Figura II-10. Associação entre aluno, disciplina e período. Uma associação pode ter atributos próprios. Ou seja, atributos que não pertençam a nenhuma das classes envolvidas na associação mas sim à própria associação. Na associação entre alunos e disciplina o atributo nota, não pertence a aluno, tampouco à disciplina, uma vez que para saber uma nota é preciso saber quem é o aluno e qual é a disciplina. A representação de atributos da associação é representada por meio de um retângulo ligado à associação por meio de uma linha tracejada. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 26. Java na Prática 25 Figura II-11. Representação de atributos de associação. Agregação Alguns objetos são compostos por outros objetos. Por exemplo, um carro é composto por chassi, lataria, pneus e motor, que por sua vez é composto pelo carburador, pistões, bloco, etc. Este tipo de associação é representada por uma linha com um losango na ponta. Figura II-12. Agregação entre Curso e Disciplina. Generalização O último tipo de associação entre classes é o que o ocorre entre superclasses e subclasses. Uma superclasse é uma generalização das suas subclasses, que herdam os atributos e métodos da primeira. A notação utilizada para representar a generalização é uma linha com um triângulo na extremidade da associação no lado da classe mais genérica. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 27. Java na Prática 26 Figura II-13. Representação da generalização. A figura II-14 procura representar todas associações discutidas em um único diagrama. Figura II-14. Associação entre as classes do domínio acadêmico. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 28. Java na Prática 27 Capítulo III - Introdução à Linguagem Java Existe uma tradição entre os programadores que estabelece que ao se começar a aprender uma nova linguagem de programação, o primeiro programa a ser escrito deve ser um que imprima a frase “Olá mundo” em um dispositivo de saída. Dizem que isto atrai a sorte e espanta os bugs. Independente da crença geral, existem algumas razões bastante justificáveis para se começar o aprendizado de uma linguagem executando logo um programa, mesmo sem ter muita idéia do que se está fazendo. Primeiramente, existe o fator psicológico. Iniciar o aprendizado executando um programa sem erros, aumenta confiança do aluno e elimina temores de se estar aprendendo algo muito complexo. Existe também o fato de que apesar de um programa muito simples dar uma visão um pouco limitada da linguagem, já é possível observar alguns elementos importantes. Afinal trata-se de um programa completo. Portanto, para não fugir a tradição, eis o programa OlaMundo em Java: public class OlaMundo { public void exibeOla() { System.out.println(“Ola, Mundo!”); } public static void main(String args[]) { OlaMundo obj = new OlaMundo(); Obj.exibeOla(); } } Exemplo III-1. Programa OlaMundo. O programa acima é composto por uma única classe que possui apenas dois métodos. Isto é importante, porque não é possível fazer um programa Java sem recorrer às classes, uma vez que os procedimentos são definidos como métodos de classes. Isto não é verdade em linguagens como C++, o que diminui o seu “grau” de orientação a objetos. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 29. Java na Prática 28 Os métodos com o nome main são métodos especiais e servem como ponto inicial para execução do programa. Ou seja, a execução do programa será iniciada a partir da execução de um método main(). A assinatura do método main é sempre a mesma e a sua descrição em detalhes será vista na seção Argumentos da linha de comando. Podemos adiantar apenas que o qualificador public estabelece que este método pode ser chamado por métodos ou procedimentos externos à classe. O qualificador static significa que o método pertence à classe e não às instâncias da classe, e deste modo pode ser invocado mesmo antes de ser criado algum objeto para a classe. void indica que o método não retornará valor algum. Já argumento String args[] é um array de Strings contendo os parâmetros passados na linha de comando. O corpo do método main() possui duas linhas. A primeira instrução cria um objeto da classe OlaMundo e o atribui à variável obj. A segunda linha invoca o método exibeOla() do objeto recém criado. O método exibeOla() invoca o método println() do objeto out da classe System, que faz parte do pacote de classes fornecido com a linguagem. Este método exibe no dispositivo de saída padrão a String que é passada como argumento. Se você olhar os programas “OlaMundo” mostrados em outros livros sobre Java irá notar que o programa apresentado aqui é um pouco mais complicado que o exibido nesses livros. Geralmente este programa inicial é apresentado apenas com um método: o método main(). A razão de termos usado uma abordagem diferente é que desejamos desenvolver um hábito saudável na programação em Java: procure usar o método main() apenas para criar os objetos e deixe que os objetos executem a lógica do problema. Este programa deve ser salvo em um arquivo contendo O MESMO NOME DA CLASSE e com as mesmas letras maiúsculas e minúsculas (é importante frisar, uma vez que esquecer este detalhe é um erro muito comum), e com a extensão “.java”. Portanto o arquivo contendo o programa acima deverá se chamar OlaMundo.java. Se você instalou o Java 2 development kit (SDK), que pode ser obtido gratuitamente no site http://java.sun.com/products/, então para compilar o programa basta digitar o comando: javac OlaMundo.java O código Java é traduzido (o termo mais comum é compilado) para instruções de uma máquina virtual (bytecodes) para que possa ser executado de forma independente da plataforma (sistema operacional e hardware). O código em bytecodes é armazenado em um arquivo com o mesmo nome do original e com a extensão “.class”. Assim após a execução do comando acima será Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 30. Java na Prática 29 gerado o arquivo OlaMundo.class. A invocação da máquina virtual para executar o código em bytecodes é efetuada por meio do seguinte comando: java OlaMundo Neste ponto nota-se uma desagradável idiossincrasia do SDK. Para compilar o programa para bytecode foi necessário explicitar a extensão do arquivo, porém, para executar o código é preciso omitir a extensão “.class”. Apesar de ser um detalhe que aparentemente não prejudica o uso do ambiente, confunde o usuário, principalmente o iniciante. Quando recebe um arquivo de bytecodes para a executar, a máquina virtual procura o método main() em uma classe com o mesmo nome do arquivo. Uma vez encontrado o método a execução é iniciada com a execução do método. Isto significa que em nosso exemplo será procurado o método main() da classe OlaMundo para servir de ponto de entrada. Podem existir outros métodos main() em outras classes codificadas no mesmo arquivo de bytecodes, mas apenas o método main() da classe com o mesmo nome do arquivo servirá de ponto inicial de execução. Portanto, em nosso caso, o programa será executado produzindo a saída: Ola, Mundo! Agora que já cumprimos o ritual de iniciação na linguagem, podemos passar a descrever os detalhes da linguagem. Grande parte das descrições que seguem abaixo foram baseadas na especificação da linguagem registrada no livro The Java Language Specification, segunda edição, por James Gosling e outros. Identificadores Todos os identificadores da linguagem devem iniciar com uma letra, ou o caractere ´_`, ou o caractere ´$`. Deve-se evitar o uso do caractere ´$`, de modo que fique reservado para geração de código automático. Tratamos por letra todo caractere reconhecido pelo método Character.isJavaLetter. Isto inclui uma ampla gama de caracteres do conjunto Unicode1, de modo que os programadores podem usar identificadores adaptados a uma ampla gama de idiomas. Após o 1 O conjunto de caracteres Unicode foi criado para substituir o conjunto ASCII. Ele usa 16 bits para representar os caracteres, o que resulta em 65536 caracteres possíveis, em oposição aos 7 bits do código ASCII (8 para o ASCII estendido), o que resulta em 128 caracteres possíveis (256 para 8 bits). Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 31. Java na Prática 30 primeiro caractere, também podem ser usados os caracteres que vão de ´0` até ´9`. A linguagem Java distingue as letras maiúsculas das minúsculas, portanto o identificador Aluno é distinto do identificador aluno. A tabela III-1 mostra alguns identificadores válidos e inválidos. Válido Inválido Aluno10 Aluno#10 Num_Alunos Num Alunos _disciplina$ !disciplina Professor_10 10Professor αβγ &uuu Não Não? Tabela III-1. Identificadores válidos e inválidos em Java. Palavras Reservadas As seguintes sequências de caracteres são reservadas para o uso como palavras chave e, portanto, não podem ser usadas como identificadores: abstract continue goto package synchronized assert2 default if private this boolean do implements protected throw break double import public throws byte else instanceof return transient case extends int short try catch final interface static void char finally long strictfp3 volatile class float native super while const for new switch Tabela III-2. Palavras reservadas da linguagem Java. As palavras chave const e goto, apesar de serem reservadas, não estão sendo usadas correntemente na linguagem. 2 Introduzida a partir da versão 1.4 do SDK. 3 Introduzida a partir da versão 1.2 do SDK Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 32. Java na Prática 31 Literais Literais são elementos do código que representam um valor de tipo primitivo, tipo String ou null. Os literais podem ser numéricos, booleanos, caracteres ou cadeias de caracteres (Strings). Literais numéricos incluem inteiros, ponto flutuante. Literais Inteiros Um literal inteiro é do tipo primitivo long (longo) se possui o sufixo ´L` ou ´l`, caso contrário é do tipo primitivo int (inteiro). Um numeral hexadecimal é prefixado pelos caracteres ´0x` ou ´0X` seguidos de um ou mais dígitos hexadecimais. Os dígitos hexadecimais com valores entre 10 e 15 são representados pela letras ´a` até ´f` ou ´A` até ´F`, nessa ordem. Um numeral octal consiste de um dígito 0 seguido de um ou mais dígitos de 0 até 7. O maior literal decimal do tipo int é 2147483648. Os literais decimais de 0 até 2147483647 podem aparecer em qualquer lugar que um literal inteiro pode aparecer, mas o literal 2147483648 pode aparecer somente como operando de uma negação unária. Os maiores literais hexadecimal e octal positivos inteiros são 0x7fffffff e 017777777777, respectivamente, que correspondem ao valor decimal 2147483647. Os maiores literais hexadecimal e octal negativos inteiros são 0x80000000 e 020000000000, respectivamente, que representam o valor decimal -2147483648 (). Os literais hexadecimal e octal 0xffffffff e 037777777777, representam o valor decimal -1. Abaixo estão listados alguns exemplos de literais inteiros: 0 -12 0372 0xCafe 1999 0x00FF00FF O maior literal decimal do tipo longo é o 9223372036854775808L. Os literais decimais de 0L até 9223372036854775807L podem aparecer em qualquer lugar que um literal inteiro longo pode aparecer, porém o literal 9223372036854775808L pode aparecer somente como operando de uma negação unária. Os maiores literais hexadecimal e octal positivos inteiros longos são 0x7fffffffffffffffL e 0777777777777777777777L, respectivamente, que correspondem ao valor decimal 9223372036854775807L.Os maiores literais Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 33. Java na Prática 32 hexadecimal e octal negativos inteiros longos são 0x8000000000000000L e 01000000000000000000000L, respectivamente, que representam o valor decimal -9223372036854775808L. Os literais hexadecimal e octal 0xffffffffffffffffL e 01777777777777777777777L, representam o valor decimal - 1. Abaixo estão listados alguns exemplos de literais inteiros longos: 0L 0777L 0xC0B0L 0xCafe 1999 0x100000000L Literais de Ponto Flutuante Um literal de ponto flutuante é composto por uma parte inteira seguida de um ponto decimal, uma parte fracionária, um expoente e um sufixo determinando o tipo. O expoente, se presente, é indicado pela letra ‘E’ ou ‘e’, seguido por um inteiro com sinal um opcional. Pelo menos um dígito na parte inteira ou fracionária e o ponto decimal ou o expoente ou o sufixo indicando o tipo são exigidos. Todos os outros componentes são opcionais. Um tipo ponto flutuante é do tipo float se possuir o sufixo ‘F’ ou ‘f’, caso contrário é do tipo double. O tipo double possuir opcionalmente o sufixo ‘D’ ou ‘d’. O tipo float e double de Java obedecem a especificação IEEE 754 para binários de ponto flutuante de precisão simples (32-bit) e dupla (64-bit). O maior literal positivo do tipo float é 3.40282347e+38f. O menor literal positivo do tipo float diferente de zero é 1.40239846e-45f. O maior literal positivo do tipo double é 1.79769313486231570e+308. O menor literal positivo do tipo double diferente de zero é 4.94065645841246544e-324. Um programa em Java pode representar quantidades infinitas sem produzir erros de compilação por meio da utilização de expressões constantes tais como 1f/0f e -1d/0d ou pela utilização das constantes predefinidas POSITIVE_INFINITY e NEGATIVE_INFINITY das classes Float e Double. Exemplos de literais do tipo float: 1e1f 2.f .3f 0f 3.14f 6.022137e+23f Exemplos de literais do tipo double: 1e1 2. .3 0.0 3.14 1e-9d 1e137 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 34. Java na Prática 33 Literais Booleanos O tipo boolean possui dois valores, representados pelos literais true e false. Literais de Caracteres Um literal do tipo char é expresso como um caractere ou uma sequência de escape, envolvida por aspas simples. Os caracteres CR e LF nunca são caracteres de entrada, uma vez que são reconhecidos como terminadores de linha. Exemplos de literais do tipo char: Caractere Descrição 'a' o caractere a. '%' o caractere % 'n' line feed 't' Tab '' o caractere ''' o caractere '. 'u03a9' 'uFFFF' '177' Tabela III-3. Exemplo de literais do tipo char. Literais de Cadeia de Caracteres (Strings) Um literal do tipo String consiste de zero ou mais caracteres envolvidos por aspas duplas. Cada caractere pode ser representado por uma sequência de escapes. O tipo String não é um tipo primitivo e sim uma classe denominada String. Portanto, um literal é na verdade uma instância da classe String. Uma String longa pode ser particionada em cadeias menores unidas pelo operador de concatenação ´+’. Exemplos de literais do tipo String: Literal Descrição "" Cadeia vazia. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 35. Java na Prática 34 """ Uma cadeia com apenas o caractere ". "esta é uma cadeia" Uma cadeia contendo 17 caracteres. "esta é uma " Uma cadeia formada por dois literais do +"cadeia " tipo String. Tabela III-4. Exemplo de literais do tipo String. Sequências de escape Sequências de escape permitem a representação de alguns caracteres não gráficos, assim como as aspas simples e duplas e a barra invertida. Exemplos de sequências de escape: Sequência Descrição b u0008: backspace BS t u0009: tab horizontal HT n u000a: linefeed LF f u000c: form feed FF r u000d: carriage return CR " u0022: aspas duplas " ' u0027: aspas simples ' u005c: barra invertida Tabela III-5. Exemplo sequências de escape. O Literal null O tipo null possui apenas um valor, representado pelo literal null. Separadores Java possui nove separadores (caracteres de pontuação), listados abaixo: ( ) { } [ ] ; , . Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 36. Java na Prática 35 Tipos de dados Os tipos de dados definem como devem ser interpretados os dados armazenados. São essenciais a toda linguagem de programação e devem ser cuidadosamente selecionados para compor a linguagem, de modo a não limitar a sua área de atuação. A maioria da linguagens modernas definem um conjunto de tipos simples, um conjunto de tipos compostos, formados por tipos mais primitivos e alguma forma de definição de novos tipos, de modo que possa modelar mais apropriadamente a realidade. A linguagem Java obedece esta regra, fornecendo um conjunto de tipos simples e um conjunto de tipos compostos. O mecanismo para definição de novos tipos utilizado por Java é simplesmente a definição de classes. Java é uma linguagem fortemente tipada. Isto significa que toda variável e expressão possui um tipo determinado em tempo de compilação. Os tipos primitivos disponíveis em Java não são classes. Esta é uma das razões porque Java não é uma linguagem 100% orientada a objetos. No entanto, para cada tipo primitivo existe uma classe correspondente onde são declarados um conjunto de métodos para a manipulação dos valores primitivos, focalizando principalmente na conversão de tipos. Estas classes estão agrupadas no pacote java.lang. Por exemplo, o tipo primitivo int é usado para expressar valores inteiros. A classe correspondente ao tipo int é a Integer. Nela estão declaradas variáveis públicas contendo o valor máximo e mínimo que uma variável do tipo inteiro pode armazenar e métodos para conversão para outros tipos. Tipos de dados simples Tipos de dados simples são aqueles que não podem ser divididos em tipos mais primitivos. Os tipos de dados simples de Java podem ser divididos em inteiros, ponto flutuante, booleano e caractere. Para se definir uma variável de um determinado tipo basta preceder o nome da variável com o nome do tipo desejado, como na forma abaixo: <nome do tipo> <nome da variável>; Assim, para se declarar uma variável var1 do tipo inteiro basta a linha de código abaixo: int var1; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 37. Java na Prática 36 Podemos também declarar mais de uma variável em com o mesmo tipo, usando o caractere ‘,’ como separador. Portanto, a declaração int var1, var2; é equivalente às declarações int var1; int var2; Java também permite que as variáveis sejam inicializadas durante a declaração. Assim, para inicializarmos a variável var1 com o valor 1 na declaração basta a linha de código abaixo: int var1=1; Segue abaixo as categorias de tipos de dados simples. Inteiros Nome Tamanho byte 8 bits short 16 bits int 32 bits long 64 bits Tabela III-6. Tipos inteiros. Ponto Flutuante Nome Tamanho float 32 bits double 64 bits Tabela III-7. Tipos de ponto flutuante. booleanos boolean {true,false} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 38. Java na Prática 37 Caractere char 16 bits Tipos de dados compostos Os tipos de dados compostos são constituídos por tipos mais simples. Todos os tipos compostos em Java são Classes. Nesta seção trataremos duas classes de objetos muito usadas em Java para criação de tipos compostos: os arrays (arranjos) e strings. Posteriormente abordaremos a declaração de objetos no caso geral e no Capítulo VI será apresentado o pacote de classes java.util que contém várias classes para agrupamento de objetos. Arrays Um array é um objeto, e como tal herda todos os métodos da classe Object. Um array contém um certo número de variáveis chamadas de componentes. Em Java todo objeto é acessado indiretamente, via uma referência. Ou seja, não se cria uma variável do tipo de um objeto e sim uma variável que pode referenciar um objeto. Estamos falando de ponteiros, o que pode parecer contraditório, uma vez que tínhamos mencionado que Java não possui ponteiros. Na verdade Java acessa as instâncias de objeto por meio de ponteiros mas eles não estão disponíveis como tipo da linguagem e nem é possível que o programador os manipule diretamente. Pode parecer pouco importante para o programador saber que a variável não armazena o objeto diretamente e sim uma referência a um objeto, uma vez que ele não pode manipular ponteiros. No entanto, acreditamos que esta informação é importante para que o leitor possa entender as etapas para a criação de objetos. A primeira etapa é a declaração da variável para referenciar o objeto e a segunda etapa é a criação do objeto propriamente dito. Para se declarar uma variável para referenciar objetos do tipo array é usada a seguinte sintaxe: tipo identificador[]; tipo[] identificador; Exemplos int numeros[]; char[] letras; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 39. Java na Prática 38 long grade[][]; Note que não é definido o número de elementos do array. Isto faz parte do objeto. Note também que existem duas formas de declarações de referências a arrays. O número de “[]” indica o número de dimensões do array. A criação do objeto é realizada por meio do operador new, seguido pelo tipo do array e pelo número de componentes de cada dimensão, como nos exemplos abaixo: numeros = new int[10]; char alfabeto[] = new char[26]; grade = new long[10][10]; Alternativamente podemos realizar as duas etapas acima e ainda definir os elementos do array em uma única declaração como no exemplo abaixo, onde é criado um array de três inteiros, referenciados pela variável primos e onde o primeiro elemento é 7, o segundo é 11 e o terceiro é 13. int primos = {7, 11, 13}; De agora em diante não faremos distinção entre referência a objeto do tipo array e o objeto array, a não ser que seja necessário explicitar esta distinção. O acesso aos elementos do array é realizado por meio do nome da variável seguida por um expressão inteira não negativa envolvida pelos caracteres ‘[’ e ‘]’. A expressão inteira é chamada de índice e os valores admissíveis para a expressão vai de 0 a n-1, onde n é número de elementos do array. O índice do primeiro elemento é 0. Abaixo seguem alguns exemplos: alfabeto[0] = ‘a’; grade[0][5] = 10L; for(int i=0; i<10; i++) numeros[i] = i*2; É possível descobrir o tamanho de um array em tempo de execução acessando a variável pública length do objeto, onde está armazenada a capacidade do array. Por exemplo: for(int i=0; i< numeros.length; i++) numeros[i] = i*2; Strings Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 40. Java na Prática 39 O manipulação de cadeias de caracteres (strings) em Java é realizada por uma classe do pacote java.lang denominada String. Ou seja, não existe um tipo primitivo para tratar cadeias de caracteres. Para se declarar uma variável que faz referencia a um objeto String usa-se a seguinte linha de comando: String nome; Para que a variável faça referência a um objeto basta criar um objeto por meio do operador new ou atribuir a referência de um objeto preexistente. nome = new String(“Pedro”); String x, y; x= nome; y = “Pedro”; No primeiro caso a variável nome faz referencia a um objeto recém criado contendo o valor “Pedro”. Já a variável x faz referencia ao mesmo objeto referenciado pela variável nome. Ou seja, nenhum novo objeto String é criado, ocorrendo um compartilhamento de objetos. Já a variável y faz referência a um objeto String contendo o valor “Pedro”, distinto do objeto referenciado por x e nome. Podemos também inicializar a variável durante a declaração. String nome = “Pedro”; Os objetos do tipo String possuem um conjunto extenso de métodos e construtores para a manipulação e criação de Strings. A tabela abaixo mostra alguns dos mais utilizados. Construtor Descrição String(byte[] bytes, int offset, Constrói uma nova String convertendo o subarray de int num) bytes especificado String(StringBuffer buffer) Constrói uma nova String usando a sequência de caracteres contida no StringBuffer. String(byte[] bytes) Constrói uma nova String convertendo o array de bytes especificado String(String valor) Constrói uma nova String com o mesmo conteúdo da String passada como argumento. String() Constrói uma nova String contendo zero caracteres. String(char[] valor) Constrói uma nova String convertendo o array de caracteres especificado. String(char[] valor, int offset, Constrói uma nova String convertendo o subarray de int num) caracteres especificado. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 41. Java na Prática 40 Tabela III-8. Principais construtores da classe String. Método Descrição charAt(int indice) Retorna o caractere localizado no índice especificado. compareTo(String Compara duas Strings lexicograficamente. outraString) equals(Object anObject) Verifica se dois objetos são iguais. getChars(int srcBegin, Copia os caracteres da String em um array de int srcEnd, char[] dst, caracteres. int dstBegin) indexOf(String str) Retorna o índice da primeira ocorrência do substring no string. indexOf(String str, int Retorna o índice da primeira ocorrência do substring fromIndex) no string a partir do índice especificado. indexOf(int ch, int Retorna o índice da primeira ocorrência do caractere fromIndex) no string a partir do índice especificado. indexOf(int ch) Retorna o índice da primeira ocorrência do caractere no string . length() Retorna o comprimento do string. replace(char oldChar, Retorna uma nova String onde todos os caracteres char newChar) oldChar foram substituídos pelos caracteres newChar. substring(int beginIndex) Retorna uma nova string que é substring da atual. substring(int beginIndex, Retorna uma nova string que é substring da atual. int endIndex) toLowerCase() Converte para minúsculas. toUpperCase() Converte para Maiúsculas. trim() Remove os espaços em branco do inicio e do fim do String. valueOf(Object obj) Retorna a representação em String do argumento Object. valueOf(char c) Retorna a representação em String do argumento char. valueOf(boolean b) Retorna a representação em String do argumento booleano. valueOf(long l) Retorna a representação em String do argumento long. valueOf(int i) Retorna a representação em String do argumento int.. valueOf(char[] data) Retorna a representação em String do argumento array de caracteres valueOf(float f) Retorna a representação em String do argumento float. valueOf(double d) Retorna a representação em String do argumento double. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 42. Java na Prática 41 Tabela III-9. Principais métodos da classe String. Os literais de Strings são tratados como instâncias da classe String e como tal possuem os métodos de um objeto da classe String. Por exemplo, após a execução da expressão abaixo a variável x conterá o valor 5. int x = “Pedro”.length(); Conversão de Tipos De forma geral as conversões entre tipos em Java devem ser especificadas explicitamente. A forma mais comum de se especificar uma conversão é por meio da notação abaixo: (<tipo destino>) <expressão> Por exemplo: int i = 10; char c = (char) i; Este tipo de conversão é chamada de casting. O programador deve ficar bastante atento no que diz respeito a conversões, uma vez que pode acontecer perda de informação quando convertemos um tipo para outro que ocupa um espaço menor na memória. A tabela abaixo mostra as conversões entre tipos primitivos que podem causar perda de informação: do tipo para o tipo byte char short byte, char char byte, short int byte, short, char long byte, short, char, int float byte, short, char, int, long double byte, short, char, int, long, float Tabela III-10. Conversão de tipos que podem causar perda de informação. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  • 43. Java na Prática 42 Outra forma de converter tipos é usando os métodos fornecidos pelas classes associadas aos tipos. A tabela abaixo mostra a classe associada a cada tipo primitivo. Tipo Classe int Integer float Float double Double boolean Boolean byte Byte short Short long Long Tabela III-11. Classes associadas a cada tipo primitivo. As classes fornecem métodos para conversão mais sofisticados como do tipo primitivo para String e vice-versa. Por exemplo, a classe Integer fornece um método para converter String para int: int i = Integer.parseInt(“12”); Para se converter um inteiro para String podemos utilizar o método toString(): String s = Integer.toString(12); Existem métodos semelhantes nas outras classes. Existe também um tipo de conversão que somente se aplica aos operandos do operador binário ‘+’ quando um dos operandos é um objeto da classe String. Caso o outro operando não seja um objeto da classe String, então ele será convertido para String e o resultado da operação será a concatenação das duas cadeias. As Conversões entre objetos de classes distintas serão tratadas no próximo Capítulo. Operadores Os operadores atuam sobre valores e variáveis de modo a gerar novos valores ou modificar os valores das variáveis. Os símbolos abaixo representam os 37 operadores da linguagem Java: Alcione de P. Oliveira, Vinícius V. Maciel - UFV