UNIVERSIDADE FEDERAL DE VIÇOSADEPARTAMENTO DE INFORMÁTICA        JAVA NA PRÁTICA      Alcione de Paiva Oliveira      Viníc...
Java na Prática                                                                    1                                      ...
Java na Prática                                                                   2     A classe Object .....................
Java na Prática                                                                    3     Exemplo com GridBagLayout ..........
Java na Prática                                                                   4     Variáveis públicas ..................
Java na Prática                                                                     5     Instalando o Tomcat................
Java na Prática                              6Capítulo I - Introdução        Java é uma linguagem de programação desenvolv...
Java na Prática                                7estão entre os mais bem pagos da área de Tecnologia da Informação (TI), co...
Java na Prática                                8    da variável do tipo ponteiro, nem que realize operações aritméticas co...
Java na Prática                               9    versão 1.0 segurança significa impedir que programas hostis que possam ...
Java na Prática                           10específicos foram lançados, como o J2EE (Java 2 Enterprise Edition), voltadopa...
Java na Prática                              11Capítulo II - Programação Orientadaa Objetos        O mundo pode ser visto ...
Java na Prática                             12Subclasses. As subclasses herdam as propriedades das superclasses. No nossoe...
Java na Prática                             13                      type Classe_Retangulo = record                        ...
Java na Prática                              14       As propriedades dos objetos podem ser manipuladas através de funções...
Java na Prática                              15objeto. Java é uma linguagem orientada a objetos mais “pura” do que C++,fug...
Java na Prática                              16        Até esse momento nenhum objeto foi criado. Para criar um objeto(ins...
Java na Prática                      17                    X2 = XB;                    Y2 = YB;          }          void M...
Java na Prática                            18Sobrescrita, Sobrecarga e Polimorfismo        Podemos definir mais de um méto...
Java na Prática                            19           {                   salario= salario*porcent;           }    }    ...
Java na Prática                                20Introdução à Diagrama de Classes        É possível registrar diretamente ...
Java na Prática                              21       Uma classe é representada no diagrama de classes por meio de umretân...
Java na Prática                               22      Figura II-5. Representação simplificada da classe das disciplinas.  ...
Java na Prática                               23       As classes podem se relacionar de diversas formas: por associaçãoco...
Java na Prática                              24                       Notação            Descrição                     1  ...
Java na Prática                             25           Figura II-11. Representação de atributos de associação.       Agr...
Java na Prática                           26               Figura II-13. Representação da generalização.       A figura II...
Java na Prática                              27Capítulo III - Introdução àLinguagem Java        Existe uma tradição entre ...
Java na Prática                             28        Os métodos com o nome main são métodos especiais e servem comoponto ...
Java na Prática                                       29gerado o arquivo OlaMundo.class. A invocação da máquina virtual pa...
Java na Prática                        30primeiro caractere, também podem ser usados os caracteres que vão de ´0` até´9`. ...
Java na Prática                                31Literais        Literais são elementos do código que representam um valor...
Java na Prática                              32hexadecimal e octal negativos inteiros longos são 0x8000000000000000L e0100...
Java na Prática                            33Literais Booleanos          O tipo boolean possui dois valores, representados...
Java na Prática                              34"""                             Uma cadeia com apenas o caractere "."esta é...
Java na Prática                              35Tipos de dados       Os tipos de dados definem como devem ser interpretados...
Java na Prática                       36      Podemos também declarar mais de uma variável em com o mesmo tipo,usando o ca...
Java na Prática                              37Caracterechar           16 bitsTipos de dados compostos       Os tipos de d...
Java na Prática                                 38long grade[][];       Note que não é definido o número de elementos do a...
Java na Prática                                   39        O manipulação de cadeias de caracteres (strings) em Java é rea...
Java na Prática                                          40             Tabela III-8. Principais construtores da classe St...
Java na Prática                             41              Tabela III-9. Principais métodos da classe String.       Os li...
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Apostila de java na pratica
Upcoming SlideShare
Loading in...5
×

Apostila de java na pratica

10,349

Published on

Teste apresentacao

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
10,349
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
185
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Transcript of "Apostila de java na pratica"

  1. 1. UNIVERSIDADE FEDERAL DE VIÇOSADEPARTAMENTO DE INFORMÁTICA JAVA NA PRÁTICA Alcione de Paiva Oliveira Vinícius Valente Maciel 2002
  2. 2. Java na Prática 1 SumárioCapítulo I - Introdução ....................................... 6 CONVENÇÕES ........................................................................................................................... 10Capí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.......................................................................................................... 20Capí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 ............................................................................. 64Capí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. 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 ........................................................................ 115Capítulo V – Entrada e Saída (java.io) ...................... 122 ACESSO SEQUENCIAL............................................................................................................. 122 ACESSO DIRETO ..................................................................................................................... 127Capí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 ........................................................................ 152Capítulo VII - Serialização e Persistência .................... 159 AGENDA ELETRÔNICA VERSÃO CONSOLE 2.1 ........................................................................ 161Capí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. 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......................................................................... 211Capí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 ........................................................................... 236Capí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 ............................................................................................... 249Capí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. 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() ................................................................. 259Capítulo XII - Animação ....................................... 259Capí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 ....................................................................................... 259Capítulo XIV – Computação Distribuída (RMI) ................. 259 CRIANDO NOSSA AGENDA DISTRIBUÍDA ................................................................................. 259 Implementar interface do objeto remoto .......................................................................... 259Capí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 ................................................................................... 259Capí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. 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.............. 259Capítulo XVII Perguntas Frequentes .......................... 259Bibliografia ................................................ 259Links ....................................................... 259Índice ...................................................... 259 Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  7. 7. Java na Prática 6Capítulo I - Introdução Java é uma linguagem de programação desenvolvida pela SunMicrosystems e lançada em versão beta em 1995. O seu desenvolvimento foiiniciado em 1991 pela equipe liderada por James Gosling visando o mercado debens eletrônicos de consumo. Por isso foi projetada desde o início para serindependente de hardware, uma vez que as características dos equipamentosvariam amplamente neste nicho de desenvolvimento. Outro objetivoestabelecido desde sua concepção foi o de ser uma linguagem segura. Seguratanto no sentido de evitar algumas falhas comuns que os programadorescostumam cometer durante o desenvolvimento, como no sentido de evitarataques externos. Isto é importante no mercado de bens eletrônicos de consumopor que ninguém gostaria de adquirir um produto que necessitasse desligar ereligar para que voltasse a funcionar corretamente. Estas característicasdespertaram o interesse para utilização de Java em outro ambiente que tambémnecessitava de uma linguagem com este perfil: a Internet. A Internet também éum ambiente constituído por equipamentos de diferentes arquiteturas e necessitamuito de uma linguagem que permita a construção de aplicativos seguros.Muitas pessoas argumentarão que estas características podem ser encontradasem 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 poucopantanoso para se aventurar, até por que as linguagens de programação tendemassumir um caráter quase religioso. Uma das razões que na nossa opiniãofavoreceram a rápida adoção da linguagem foi a sintaxe. Java é sintaticamentemuito semelhante à linguagem C/C++, apesar de existirem diferençasfundamentais na filosofia de implementação entre as duas linguagens. Istofacilitou a migração de uma legião imensa de programadores C/C++ para a novalinguagem. Outra razão que não pode ser desprezada é o momento atual onde osdesenvolvedores estão ansiosos para se libertarem de sistemas proprietários.Portanto, apesar de não serem novas as idéias embutidas na linguagem Java, areunião delas em uma só linguagem, juntamente com a facilidade migração dosprogramadores e o momento atual, contribuíram para o rápido sucesso dalinguagem. Hoje, segundo a International Data Corp. (IDC), existem mais de 2milhões de programadores Java no mundo e a estimativa é que o número dedesenvolvedores ultrapasse os 5 milhões em 2004. O número de programadoresJava deve ultrapassar o de programadores C++ ainda este ano (2002), segundo aconsultoria americana Evans Data. Os profissionais que dominam a linguagem Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  8. 8. Java na Prática 7estão entre os mais bem pagos da área de Tecnologia da Informação (TI), comsalários variando de 3 a 10 mil reais, podendo em alguns casos chegar à 16 milreais, segundo a revista Info Exame (dezembro de 2001). A lista abaixo apresenta as principais características de Java de modo queo 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. 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. 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 temliberado diversas evoluções da linguagem na forma de versões e releases de umconjunto de ferramentas denominado de Java Development Kit (JDK) até aversão 1.2, quando se passou a denominar Java 2 SDK (Standard DevelopmentKit). Isto ocorreu porque outros kits de desenvolvimento com propósitos Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  11. 11. Java na Prática 10específicos foram lançados, como o J2EE (Java 2 Enterprise Edition), voltadopara aplicações distribuídas escaláveis e o J2ME (Java 2 Micro Edition), voltadopara 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 denúmero 1.3.1 que pode ser obtida gratuitamente no site http://java.sun.com/.ConvençõesAs 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. 12. Java na Prática 11Capítulo II - Programação Orientadaa 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ãosão necessariamente físicos. Podem possuir uma natureza abstrata, como umevento (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. Seiremos representar algo como objeto ou não depende apenas de uma decisão anível lógico que pode facilitar a simulação de determinado aspecto da realidade. Os objetos se agrupam em classes, segundo propriedades ou atributoscomuns. Por exemplo, a classe dos retângulos agrupa todas as formasgeométricas com a propriedade de possuir quatro lados formando ângulos de90o. A relação entre um objeto e uma classe é de pertinência. Dizemos que umobjeto pertence a uma classe ou, mais comumente, que é uma instância de umaclasse. 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 umaclasse pode conter outra. Por exemplo, a classe de retângulos está inserida emuma 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. 13. Java na Prática 12Subclasses. As subclasses herdam as propriedades das superclasses. No nossoexemplo, os polígonos possuem as propriedades de ter uma área, uma posição noplano, um número n de vértices e n-1 ângulos. Todas essas propriedades sãoherdadas tanto pela classe dos retângulos como pela classe do triângulos.Podemos desta forma organizar os objetos em uma hierarquia onde as classesmais 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 ovalor de suas propriedades. Por exemplo, um carro pode sofrer uma aceleraçãoou ser freado e com isso alterar a sua velocidade. Um objeto qualquer pode serdeslocado, 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çõesde aspectos da realidade no computador. Quanto mais facilmente pudermosexpressar os conceitos capturados da realidade, mais facilmente construiremos asimulação. Seguindo este raciocínio podemos concluir que as linguagens quepossuem facilidades para representação de objetos permitem uma modelagemmais fácil dos conceitos do mundo real. No entanto, podemos utilizar umalinguagem de programação convencional para modelar as classes e objetosabstraídos da realidade. Por exemplo, podemos modelar a classe dos retângulospor meio de um registro (record) em Pascal. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  14. 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 oponto superior esquerdo e X2 e Y2 o ponto inferior direito. Os objetos podemser 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. 15. Java na Prática 14 As propriedades dos objetos podem ser manipuladas através de funções eprocedimentos. Por exemplo, podemos ter uma operação para inicializar osvalores da estrutura e outra para alterar a posição do retângulo. O Exemplo II-3mostra essas duas operações. Contudo, existem algumas limitações das linguagens convencionais que astornam 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 todosesses problemas. Existem várias linguagens comerciais com esta característica:Smalltalk, Eiffel, C++, etc. Algumas com elementos não orientados a objetoscomo C++, outras puramente orientadas a objetos como Smalltalk, onde tudo é Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  16. 16. Java na Prática 15objeto. Java é uma linguagem orientada a objetos mais “pura” do que C++,fugindo desta orientação apenas em alguns pontos bem definidos, em nome daeficiência de execução. Em Java podemos representar diretamente as classes eobjetos. 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 paraRetangulo, que é o mesmo nome da classe. No momento não é importanteentendermos 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, tornandoexplícito relacionamento entre a classe e os procedimento. As funçõesdeclaradas nas classes são chamadas de métodos e a partir de agora nosreferenciaremos a eles como tal. Note também que diferentemente do exemploem Pascal, não é preciso passar o objeto como parâmetro, uma vez que asvariá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 criadasversões de todos os métodos da classe, de modo que cada método só opera sobreas variáveis do objeto a quem pertencem. Para declarar uma variável do tipo daclasse basta preceder a variável com o nome da classe. Retangulo ret; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  17. 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 omesmo nome da classe. O métodos com esta característica são chamados deconstrutores e só podem ser invocados durante a criação de um objeto. Comoveremos mais tarde, uma classe pode ter mais de um construtor. Após a criaçãodo 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 dizerque cada instância da classe recebe uma cópia da variáveis e dos métodos daclasse.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. Destaforma a representação interna fica isolada do restante do programa e fica maisfácil alterá-la sem que seja preciso alterar outras partes do código. A ocultaçãode informação é obtida por meio de qualificadores, como o private, queimpede o acesso à variáveis via métodos definidos em outras classes. O nível deocultação depende do qualificador utilizado. Todos os qualificadores serãoabordados com detalhes no Capítulo IV. O exemplo II-5 mostra como impedirque 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. 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 ooperador extends. Por exemplo, podemos definir uma subclasse da classeRetangulo, chamada de RetanguloColorido, que possui, além das variáveis emétodos herdados da superclasse, uma variável para armazenar a cor doretâ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 dasuperclasse. No entanto, isto também pode ser alterado via qualificadores. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  19. 19. Java na Prática 18Sobrescrita, Sobrecarga e Polimorfismo Podemos definir mais de um método com o mesmo nome na mesmaclasse ou subclasses. Caso o método possua a mesma assinatura (número e tiposde argumentos e tipo de retorno) que outro método, então o método não podepertencer à mesma classe do anterior. Se ambos os métodos estiverem na mesmalinha hierárquica (classe/subclasse), dizemos que o método da subclassesobrescreve 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 Vendedorsobrescreve o método do mesmo nome da classe Empregado. Se a assinatura do método for diferente de outro método com o mesmonome definido anteriormente na mesma classe ou em outra classe da mesmalinha hierárquica, então estamos realizando uma sobrecarga sobre oidentificador do método. Quando for usado o identificador dentro do código deum programa o método invocado será determinado pela classe a que pertence oobjeto 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 demé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. 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étodosdistintos. Um aumenta o salário em 10% e no outro o aumento depende do valorda porcentagem passado como parâmetro. Note que as assinaturas do métodosdiferem entre si. Alguns autores chamam sobrecarga de polimorfismo, que é a habilidadede um determinado objeto se comportar ou ser visto de diferentes formas,quando na verdade a sobrecarga é um tipo particular de polimorfismo, chamadode polimorfismo ad hoc . Na sobrecarga um identificador representa váriosmétodos com computações distintas. Existe também o polimorfismoparamétrico, onde um método pode realizar a mesma computação sobre objetosde tipos distintos. Isso pode ser implementado em Java definindo um métodoque recebe e retorna objetos da classe Object. Como a classe Object é a “mãede todas as classes” o método pode operar da mesma forma independente daclasse a qual o objeto realmente pertence, desde que a computação sejaindependente 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 passadocomo parâmetro. Este método realiza a mesma computação, independentementeda classe do objeto. Obviamente é um exemplo muito simples e sem utilidadeprática mas serve para ilustrar o conceito de polimorfismo paramétrico. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  21. 21. Java na Prática 20Introdução à Diagrama de Classes É possível registrar diretamente em uma linguagem de programação osobjetos percebidos em uma determinada realidade. No entanto, é melhorutilizarmos uma notação gráfica intermediária para melhor visualizarmos osobjetos e as relações entre objetos, e ir alterando esta representação até estarmosseguros 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 maisde 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 algunsexemplos para ilustrarmos a arquitetura dos programas antes de apresentarmos ocódigo. Acreditamos que desta forma o leitor compreenderá melhor osexemplos. A notação gráfica que adotamos mostra as relações estáticas entre classesde objetos. Ela faz parte do conjunto de notações da UML (Unified ModelingLanguage ou Linguagem de Modelagem Unificada) proposta por Grady Booch,James Rumbaugh e Ivar Jacobson em 1995. A UML é um conjunto de notaçõesque tem por objetivo modelar diversos aspectos de um sistema em diferentesníveis de abstração. Ou seja, pode ser utilizado para a captura de requisitos deum sistema assim como em projeto de programas. É voltada para análise eprojeto de sistemas orientados a objetos. A área de análise e projeto orientados aobjetos ainda não possui uma notação “vencedora” como existe para a análise eprojeto estruturado. Contudo, a UML vem se popularizando rapidamente, e éencontrada com facilidade em textos de programação, sobretudo em se tratandode Java. Portanto, um conhecimento sobre as principais notações que constituema UML é importante para qualquer um que deseja ingressar na área deprogramação orientada a objetos. Este livro utiliza uma das linguagens, oudiagramas, que compõem a UML: o diagrama de classes.Diagrama de Classes O Diagrama de Classes representa graficamente as classes do sistema e orelacionamento estático entre as classes, isto é, o relacionamento que não mudacom o tempo. Por exemplo, em um sistema acadêmico, um aluno cursa váriasdisciplinas. O número de disciplinas e a disciplina que efetivamente está sendocursada pode alterar, mas o vínculo aluno-cursa-displinas permanece. Parailustrar o nosso estudo dos diagramas da UML utilizaremos exemplos sobremodelagem de aspectos realidade acadêmica. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  22. 22. Java na Prática 21 Uma classe é representada no diagrama de classes por meio de umretângulo, que pode ser dividido em até três seções horizontais, como mostradona 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çãointermediá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 umarepresentaçã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 osmétodos que tratam da alteração dos atributos e construtores. Se Assumi quetoda classe possui estes métodos. Portanto, podemos simplificar a representaçãoacima, omitindo a seção do métodos. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  23. 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 visibilidadedeles em relação a outras classes. As visibilidades possíveis, juntamente com ossí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 adeclaraçã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. 24. Java na Prática 23 As classes podem se relacionar de diversas formas: por associaçãocomum, por agregação e generalização. Abaixo é apresentada cada forma derelacionamento, juntamente com suas as notações. Associação comum A notação utilizada para associar duas classes é simplesmente uma linhaunindo as classes. A figura II.7 mostra a associação entre a classe dos alunos e aclasse das disciplinas. Figura II-7. Associação entre Aluno e Disciplina. A figura acima expressa que alunos se associam com disciplinas mas nãoindica se um aluno se relaciona com várias ou apenas uma disciplina. Estainformação é chamada de cardinalidade da relação e é expressa anotando-se ovalor 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 diagramacompleto é 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. 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 nadaimpede que mais de duas classes participem de uma associação. Por exemplo, afigura II-10 ilustra uma associação ternária que representa o fato de um alunocursar 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ãopertençam a nenhuma das classes envolvidas na associação mas sim à própriaassociação. Na associação entre alunos e disciplina o atributo nota, não pertencea aluno, tampouco à disciplina, uma vez que para saber uma nota é preciso saberquem é 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 umalinha tracejada. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  26. 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 pelocarburador, pistões, bloco, etc. Este tipo de associação é representada por umalinha 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 entresuperclasses e subclasses. Uma superclasse é uma generalização das suassubclasses, que herdam os atributos e métodos da primeira. A notação utilizadapara representar a generalização é uma linha com um triângulo na extremidadeda associação no lado da classe mais genérica. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  27. 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. 28. Java na Prática 27Capítulo III - Introdução àLinguagem Java Existe uma tradição entre os programadores que estabelece que ao secomeçar a aprender uma nova linguagem de programação, o primeiro programaa ser escrito deve ser um que imprima a frase “Olá mundo” em um dispositivode saída. Dizem que isto atrai a sorte e espanta os bugs. Independente da crençageral, existem algumas razões bastante justificáveis para se começar oaprendizado de uma linguagem executando logo um programa, mesmo sem termuita idéia do que se está fazendo. Primeiramente, existe o fator psicológico.Iniciar o aprendizado executando um programa sem erros, aumenta confiança doaluno e elimina temores de se estar aprendendo algo muito complexo. Existetambém o fato de que apesar de um programa muito simples dar uma visão umpouco limitada da linguagem, já é possível observar alguns elementosimportantes. Afinal trata-se de um programa completo. Portanto, para não fugir atradiçã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 apenasdois métodos. Isto é importante, porque não é possível fazer um programa Javasem recorrer às classes, uma vez que os procedimentos são definidos comométodos de classes. Isto não é verdade em linguagens como C++, o que diminuio seu “grau” de orientação a objetos. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  29. 29. Java na Prática 28 Os métodos com o nome main são métodos especiais e servem comoponto 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étodomain é sempre a mesma e a sua descrição em detalhes será vista na seçãoArgumentos da linha de comando. Podemos adiantar apenas que o qualificadorpublic estabelece que este método pode ser chamado por métodos ouprocedimentos externos à classe. O qualificador static significa que o métodopertence à classe e não às instâncias da classe, e deste modo pode ser invocadomesmo antes de ser criado algum objeto para a classe. void indica que o métodonão retornará valor algum. Já argumento String args[] é um array deStrings contendo os parâmetros passados na linha de comando. O corpo do método main() possui duas linhas. A primeira instrução criaum objeto da classe OlaMundo e o atribui à variável obj. A segunda linha invocao método exibeOla() do objeto recém criado. O método exibeOla() invoca ométodo println() do objeto out da classe System, que faz parte do pacote declasses fornecido com a linguagem. Este método exibe no dispositivo de saídapadrão a String que é passada como argumento. Se você olhar os programas “OlaMundo” mostrados em outros livrossobre Java irá notar que o programa apresentado aqui é um pouco maiscomplicado que o exibido nesses livros. Geralmente este programa inicial éapresentado apenas com um método: o método main(). A razão de termos usadouma abordagem diferente é que desejamos desenvolver um hábito saudável naprogramação em Java: procure usar o método main() apenas para criar osobjetos e deixe que os objetos executem a lógica do problema. Este programa deve ser salvo em um arquivo contendo O MESMONOME DA CLASSE e com as mesmas letras maiúsculas e minúsculas (éimportante frisar, uma vez que esquecer este detalhe é um erro muito comum), ecom 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ãopara compilar o programa basta digitar o comando: javac OlaMundo.java O código Java é traduzido (o termo mais comum é compilado) parainstruções de uma máquina virtual (bytecodes) para que possa ser executado deforma independente da plataforma (sistema operacional e hardware). O códigoem bytecodes é armazenado em um arquivo com o mesmo nome do original ecom a extensão “.class”. Assim após a execução do comando acima será Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  30. 30. Java na Prática 29gerado o arquivo OlaMundo.class. A invocação da máquina virtual paraexecutar o código em bytecodes é efetuada por meio do seguinte comando: java OlaMundo Neste ponto nota-se uma desagradável idiossincrasia do SDK. Paracompilar o programa para bytecode foi necessário explicitar a extensão doarquivo, 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áquinavirtual 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 classeOlaMundo para servir de ponto de entrada. Podem existir outros métodos main()em outras classes codificadas no mesmo arquivo de bytecodes, mas apenas ométodo main() da classe com o mesmo nome do arquivo servirá de ponto inicialde execução. Portanto, em nosso caso, o programa será executado produzindo asaída: Ola, Mundo!Agora que já cumprimos o ritual de iniciação na linguagem, podemos passar adescrever os detalhes da linguagem. Grande parte das descrições que seguemabaixo foram baseadas na especificação da linguagem registrada no livro TheJava Language Specification, segunda edição, por James Gosling e outros.Identificadores Todos os identificadores da linguagem devem iniciar com uma letra, ou ocaractere ´_`, ou o caractere ´$`. Deve-se evitar o uso do caractere ´$`, de modoque fique reservado para geração de código automático. Tratamos por letra todocaractere reconhecido pelo método Character.isJavaLetter. Isto inclui umaampla gama de caracteres do conjunto Unicode1, de modo que os programadorespodem usar identificadores adaptados a uma ampla gama de idiomas. Após o1 O conjunto de caracteres Unicode foi criado para substituir o conjunto ASCII. Ele usa 16 bitspara representar os caracteres, o que resulta em 65536 caracteres possíveis, em oposição aos 7bits do código ASCII (8 para o ASCII estendido), o que resulta em 128 caracteres possíveis (256para 8 bits). Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  31. 31. Java na Prática 30primeiro 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 oidentificador Aluno é distinto do identificador aluno. A tabela III-1 mostraalguns 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 comopalavras chave e, portanto, não podem ser usadas como identificadores:abstract continue goto package synchronizedassert2 default if private thisboolean do implements protected throwbreak double import public throwsbyte else instanceof return transientcase extends int short trycatch final interface static voidchar finally long strictfp3 volatileclass float native super whileconst for new switch Tabela III-2. Palavras reservadas da linguagem Java. As palavras chave const e goto, apesar de serem reservadas, não estãosendo 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. 32. Java na Prática 31Literais Literais são elementos do código que representam um valor de tipoprimitivo, tipo String ou null. Os literais podem ser numéricos, booleanos,caracteres ou cadeias de caracteres (Strings). Literais numéricos inclueminteiros, 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ígitoshexadecimais. Os dígitos hexadecimais com valores entre 10 e 15 sãorepresentados pela letras ´a` até ´f` ou ´A` até ´F`, nessa ordem. Um numeraloctal 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 decimaisde 0 até 2147483647 podem aparecer em qualquer lugar que um literal inteiropode aparecer, mas o literal 2147483648 pode aparecer somente como operandode uma negação unária. Os maiores literais hexadecimal e octal positivos inteiros são 0x7fffffff e017777777777, respectivamente, que correspondem ao valor decimal2147483647. Os maiores literais hexadecimal e octal negativos inteiros são0x80000000 e 020000000000, respectivamente, que representam o valordecimal -2147483648 (). Os literais hexadecimal e octal 0xffffffff e037777777777, representam o valor decimal -1. Abaixo estão listados algunsexemplos de literais inteiros: 0 -12 0372 0xCafe 1999 0x00FF00FF O maior literal decimal do tipo longo é o 9223372036854775808L. Osliterais decimais de 0L até 9223372036854775807L podem aparecer emqualquer lugar que um literal inteiro longo pode aparecer, porém o literal9223372036854775808L pode aparecer somente como operando de umanegação unária. Os maiores literais hexadecimal e octal positivos inteiros longos são0x7fffffffffffffffL e 0777777777777777777777L, respectivamente, quecorrespondem ao valor decimal 9223372036854775807L.Os maiores literais Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  33. 33. Java na Prática 32hexadecimal e octal negativos inteiros longos são 0x8000000000000000L e01000000000000000000000L, respectivamente, que representam o valordecimal -9223372036854775808L. Os literais hexadecimal e octal0xffffffffffffffffL e 01777777777777777777777L, representam o valor decimal -1. Abaixo estão listados alguns exemplos de literais inteiros longos:0L 0777L 0xC0B0L 0xCafe 1999 0x100000000LLiterais de Ponto Flutuante Um literal de ponto flutuante é composto por uma parte inteira seguidade um ponto decimal, uma parte fracionária, um expoente e um sufixodeterminando 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 parteinteira ou fracionária e o ponto decimal ou o expoente ou o sufixo indicando otipo 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 parabiná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 menorliteral positivo do tipo float diferente de zero é 1.40239846e-45f. O maiorliteral positivo do tipo double é 1.79769313486231570e+308. O menor literalpositivo do tipo double diferente de zero é 4.94065645841246544e-324. Um programa em Java pode representar quantidades infinitas semproduzir erros de compilação por meio da utilização de expressões constantestais como 1f/0f e -1d/0d ou pela utilização das constantes predefinidasPOSITIVE_INFINITY e NEGATIVE_INFINITY das classes Float e Double.Exemplos de literais do tipo float: 1e1f 2.f .3f 0f 3.14f 6.022137e+23fExemplos 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. 34. Java na Prática 33Literais Booleanos O tipo boolean possui dois valores, representados pelos literais true efalse.Literais de Caracteres Um literal do tipo char é expresso como um caractere ou uma sequênciade escape, envolvida por aspas simples. Os caracteres CR e LF nunca sãocaracteres de entrada, uma vez que são reconhecidos como terminadores delinha. 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 envolvidospor aspas duplas. Cada caractere pode ser representado por uma sequência deescapes. O tipo String não é um tipo primitivo e sim uma classe denominadaString. Portanto, um literal é na verdade uma instância da classe String. Uma String longa pode ser particionada em cadeias menores unidaspelo 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. 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ãográficos, assim como as aspas simples e duplas e a barra invertida. Exemplos desequê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. 36. Java na Prática 35Tipos de dados Os tipos de dados definem como devem ser interpretados os dadosarmazenados. São essenciais a toda linguagem de programação e devem sercuidadosamente selecionados para compor a linguagem, de modo a não limitar asua área de atuação. A maioria da linguagens modernas definem um conjunto detipos simples, um conjunto de tipos compostos, formados por tipos maisprimitivos e alguma forma de definição de novos tipos, de modo que possamodelar mais apropriadamente a realidade. A linguagem Java obedece estaregra, fornecendo um conjunto de tipos simples e um conjunto de tiposcompostos. 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ávele expressão possui um tipo determinado em tempo de compilação. Os tiposprimitivos disponíveis em Java não são classes. Esta é uma das razões porqueJava não é uma linguagem 100% orientada a objetos. No entanto, para cada tipoprimitivo existe uma classe correspondente onde são declarados um conjunto demétodos para a manipulação dos valores primitivos, focalizando principalmentena conversão de tipos. Estas classes estão agrupadas no pacote java.lang. Porexemplo, o tipo primitivo int é usado para expressar valores inteiros. A classecorrespondente ao tipo int é a Integer. Nela estão declaradas variáveispúblicas contendo o valor máximo e mínimo que uma variável do tipo inteiropode 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 emtipos mais primitivos. Os tipos de dados simples de Java podem ser divididos eminteiros, ponto flutuante, booleano e caractere. Para se definir uma variável deum determinado tipo basta preceder o nome da variável com o nome do tipodesejado, 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 decódigo abaixo: int var1; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  37. 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 adeclaração. Assim, para inicializarmos a variável var1 com o valor 1 nadeclaraçã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.booleanosboolean {true,false} Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  38. 38. Java na Prática 37Caracterechar 16 bitsTipos 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 duasclasses de objetos muito usadas em Java para criação de tipos compostos: osarrays (arranjos) e strings. Posteriormente abordaremos a declaração de objetosno caso geral e no Capítulo VI será apresentado o pacote de classes java.utilque contém várias classes para agrupamento de objetos.Arrays Um array é um objeto, e como tal herda todos os métodos da classeObject. Um array contém um certo número de variáveis chamadas decomponentes. 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 quepode referenciar um objeto. Estamos falando de ponteiros, o que pode parecercontraditó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 elesnão estão disponíveis como tipo da linguagem e nem é possível que oprogramador os manipule diretamente. Pode parecer pouco importante para o programador saber que a variávelnão armazena o objeto diretamente e sim uma referência a um objeto, uma vezque ele não pode manipular ponteiros. No entanto, acreditamos que estainformação é importante para que o leitor possa entender as etapas para a criaçãode objetos. A primeira etapa é a declaração da variável para referenciar o objetoe a segunda etapa é a criação do objeto propriamente dito. Para se declarar umavariável para referenciar objetos do tipo array é usada a seguinte sintaxe:tipo identificador[];tipo[] identificador;Exemplosint numeros[];char[] letras; Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  39. 39. Java na Prática 38long grade[][]; Note que não é definido o número de elementos do array. Isto faz partedo objeto. Note também que existem duas formas de declarações de referências aarrays. O número de “[]” indica o número de dimensões do array. A criação doobjeto é realizada por meio do operador new, seguido pelo tipo do array e pelonú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 definiros 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 oprimeiro 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 dotipo 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 davariável seguida por um expressão inteira não negativa envolvida peloscaracteres ‘[’ e ‘]’. A expressão inteira é chamada de índice e os valoresadmissíveis para a expressão vai de 0 a n-1, onde n é número de elementos doarray. 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çãoacessando a variável pública length do objeto, onde está armazenada acapacidade 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. 40. Java na Prática 39 O manipulação de cadeias de caracteres (strings) em Java é realizada poruma classe do pacote java.lang denominada String. Ou seja, não existe umtipo primitivo para tratar cadeias de caracteres. Para se declarar uma variável quefaz 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 pormeio 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 criadocontendo o valor “Pedro”. Já a variável x faz referencia ao mesmo objetoreferenciado 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 umobjeto String contendo o valor “Pedro”, distinto do objeto referenciado por x enome. 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 econstrutores para a manipulação e criação de Strings. A tabela abaixo mostraalguns dos mais utilizados.Construtor DescriçãoString(byte[] bytes, int offset, Constrói uma nova String convertendo o subarray deint num) bytes especificadoString(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 especificadoString(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 deint num) caracteres especificado. Alcione de P. Oliveira, Vinícius V. Maciel - UFV
  41. 41. Java na Prática 40 Tabela III-8. Principais construtores da classe String.Método DescriçãocharAt(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 deint 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 substringfromIndex) no string a partir do índice especificado.indexOf(int ch, int Retorna o índice da primeira ocorrência do caracterefromIndex) 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 caractereschar 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 caracteresvalueOf(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. 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 ecomo 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 serespecificadas explicitamente. A forma mais comum de se especificar umaconversã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 ficarbastante atento no que diz respeito a conversões, uma vez que pode acontecerperda de informação quando convertemos um tipo para outro que ocupa umespaço menor na memória. A tabela abaixo mostra as conversões entre tiposprimitivos 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

×