Apostila Java na Pratica

Prévia do material em texto

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