Java PDF

Linguagem de Programao I
UNIDADE 1 - PARADIGMA DE PROGRAMAO ORIENTADA A OBJETO......................................................................... 3

1.1 UM POUCO DE HISTRIA ................................................................................................................................................ 3
1.2 ORIENTAO A OBJETO CONCEITOS BSICOS ................................................................................................................... 3
1.3 ABSTRAO ................................................................................................................................................................. 4
1.4 PARA FINALIZAR ESSA SEO VAMOS FAZER UMA PEQUENA REVISO: ...................................................................................... 4
1.5 HISTRICO DA LINGUAGEM JAVA ..................................................................................................................................... 5
1.6 PRINCIPAL CARACTERSTICA ............................................................................................................................................ 5
1.7 COMPILADOR, CDIGO FONTE, JVM ............................................................................................................................... 7
UNIDADE 2 - PROGRAMAO ORIENTADA A OBJETOS ............................................................................................... 10
2.1 PRINCPIOS DA LINGUAGEM JAVA .................................................................................................................................. 10
2.2 CLASSES .................................................................................................................................................................... 10
2.3 OBJETOS ................................................................................................................................................................... 12
UNIDADE 3 - CLASSES EM JAVA ................................................................................................................................... 14
3.1 DEFINIO DE CLASSES EM JAVA .................................................................................................................................... 14
3.2 CONSTRUTORES ......................................................................................................................................................... 14
UNIDADE 4 - ATRIBUTOS............................................................................................................................................. 16
4.1 ATRIBUTOS ................................................................................................................................................................ 16
4.2 TIPOS PRIMITIVOS ...................................................................................................................................................... 16
4.3 CLASSES WRAPPERS ..................................................................................................................................................... 19
UNIDADE 5 - MTODOS .............................................................................................................................................. 23
5.1 MTODOS ................................................................................................................................................................. 23
5.2 PRIVATE .................................................................................................................................................................... 23
5.3 PUBLIC ...................................................................................................................................................................... 24
5.4 PROTECTED ................................................................................................................................................................ 24
5.5 ABSTRACT.................................................................................................................................................................. 24
5.6 FINAL ....................................................................................................................................................................... 25
5.7 STATIC ...................................................................................................................................................................... 27
5.8 DEFINIO DO CORPO DE MTODOS .............................................................................................................................. 28
UNIDADE 6 - MANIPULAO DE OBJETOS .................................................................................................................. 29
6.1 MANIPULAO DE OBJETOS ......................................................................................................................................... 29
6.2 THIS ......................................................................................................................................................................... 30
6.3 EXEMPLOS DE USO DE THIS ........................................................................................................................................... 31
6.4 REMOO DE OBJETOS ................................................................................................................................................ 31
6.5 A CLASSE OBJECT ....................................................................................................................................................... 32
UNIDADE 7 - HERANA ............................................................................................................................................... 34
7.1 HERANA .................................................................................................................................................................. 34
7.2 FORMAS DE HERANA ................................................................................................................................................. 34
7.3 CONTRAO .............................................................................................................................................................. 35
7.4 SINTAXE .................................................................................................................................................................... 35
7.5 CONSTRUO DE OBJETOS DERIVADOS ........................................................................................................................... 36
7.6 A PALAVRA-CHAVE SUPER ............................................................................................................................................ 36
7.7 RESTRIES DE ACESSO ................................................................................................................................................ 38
UNIDADE 8 - POLIMORFISMO ..................................................................................................................................... 40
8.1 POLIMORFISMO: ........................................................................................................................................................ 40
8.2 LIGAO TARDIA: ....................................................................................................................................................... 40
8.3 SOBRECARGA (OVERLOADING): ..................................................................................................................................... 40
8.4 POLIMORFISMO EM JAVA: ............................................................................................................................................ 41

8.5 UPCASTING: .............................................................................................................................................................. 43
8.6 USO DE MTODOS ABSTRATOS: ..................................................................................................................................... 44
8.7 POLIMORFISMO EM CONSTRUTORES: .............................................................................................................................. 44
UNIDADE 9 - INTERFACES ............................................................................................................................................ 46
9.1 INTERFACE: ............................................................................................................................................................... 46
9.2 DECLARAO DE INTERFACE: ......................................................................................................................................... 46
9.3 IMPLEMENTAO DE INTERFACES: ................................................................................................................................. 46
9.4 DEFINIO DE CONSTANTES: ........................................................................................................................................ 47
UNIDADE 10 - IDENTIFICADORES .............................................................................................................................. 48
10.1 IDENTIFICADORES ....................................................................................................................................................... 48
10.2 PALAVRAS RESERVADAS EM JAVA: ................................................................................................................................. 48
10.3 CONVENO PARA IDENTIFICADORES: ............................................................................................................................. 48
UNIDADE 11 - EXPRESSES ....................................................................................................................................... 50
11.1 EXPRESSES ARITMTICAS: ........................................................................................................................................... 50
11.2 EXPRESSES LGICAS INTEIRAS: .................................................................................................................................... 50
11.3 EXPRESSES LGICAS BOOLEANAS: ................................................................................................................................ 51
11.4 CONDIES: .............................................................................................................................................................. 52
11.5 RETORNO: ................................................................................................................................................................. 52
11.6 OPERAES SOBRE OBJETOS: ....................................................................................................................................... 53
UNIDADE 12 - FLUXO DE CONTROLE DE EXECUO .................................................................................................. 54
12.1 COMANDOS DE FLUXO DE CONTROLE DE EXECUO: ......................................................................................................... 54
12.2 ESCOLHA:.................................................................................................................................................................. 54
12.3 ITERAO: ................................................................................................................................................................. 55
UNIDADE 13 - ARRANJOS EM JAVA ........................................................................................................................... 57
13.1 ARRANJOS EM JAVA: ................................................................................................................................................... 57
UNIDADE 14 - STRINGS ............................................................................................................................................. 58
14.1 STRINGS: .................................................................................................................................................................. 58
14.2 STRINGBUFFER:.......................................................................................................................................................... 59
14.3 JAVA.UTIL.STRINGTOKENIZER: ....................................................................................................................................... 60
UNIDADE 15 - PACOTE .............................................................................................................................................. 62
15.1 PACOTE .................................................................................................................................................................... 62
UNIDADE 16 - NCLEO DE FUNCIONALIDADES ......................................................................................................... 63
16.1 NCLEO DE FUNCIONALIDADES ..................................................................................................................................... 63
16.2 JAVA.LANG: ............................................................................................................................................................... 63
16.3 SYSTEM .................................................................................................................................................................... 64
16.4 UTILITRIOS DE PROPSITO GENRICO: .......................................................................................................................... 65
16.5 DATE........................................................................................................................................................................ 65
16.6 RANDOM .................................................................................................................................................................. 65


3

Unidade 1 - Paradigma de Programao
Orientada a Objeto
Paradigma um conjunto de regras que estabelecem fronteiras e descrevem como
resolver os problemas dentro dessas fronteiras. Os paradigmas influenciam nossa percepo;
ajudam-nos a organizar e coordenar a maneira como olhamos para o mundo. (Definio literal)

1.1 Um pouco de histria
O conceito de programao orientada a objeto no algo novo. No final da dcada de 60,
a linguagem Simula67, desenvolvida na Noruega, introduzia conceitos hoje encontrados nas
linguagens orientadas a objetos. Em meados de 1970, o Centro de Pesquisa da Xerox (PARC)
desenvolveu a linguagem Smalltalk, a primeira totalmente orientada a objetos. No incio da dcada
de 80, a AT&T lanou a Linguagem C++, uma evoluo da linguagem de programao C em
direo orientao a objetos.
Atualmente, um grande nmero de linguagens incorpora caractersticas de orientao a objeto,
tais como Java, Object Pascal, Python , etc.

1.2 Orientao a objeto Conceitos bsicos
O paradigma de programao orientada a objeto baseado em alguns conceitos que
definem uma forma de criar programas para computadores. A filosofia principal desse paradigma
de programao solucionar um problema (via programao) atravs da representao
computacional dos objetos existentes nesse problema (objetos do mundo real), usando para isso
os conceitos mencionados acima. Com isso, essa maneira de se desenvolver programas fica mais
prxima das situaes, dos problemas como eles acontecem no mundo real. Ser um pouco difcil
entender todas as vantagens de OO (Orientao a Objetos). Agora, portanto, vamos mencionar
apenas duas:
- mais fcil conversar com o cliente que pediu o software se falarmos com objetos que
existem no mundo dele (o mundo do software fica mais perto do mundo real).
- O software feito com OO pode ser feito com maior qualidade e pode ser mais fcil de
escrever e, principalmente, alterar no futuro.
O nosso mundo est repleto de objetos, sejam eles concretos ou abstratos. Qualquer tipo
de objeto possui atributos (caractersticas) e comportamentos que so inerentes a esses
objetos.
Para usar objetos na programao, primeiro precisamos distinguir entre um objeto real e a
representao de um objeto.
No desenvolvimento de programas, sempre trabalhamos com representaes de objetos.
Essa representao precisa refletir os objetos reais, ou seja, objetos existentes no problema do
mundo real que queremos solucionar.

4

Por exemplo, um sistema de conta corrente no manipula diretamente os clientes, contas e
cheques (esses so os objetos reais do problema).
Em vez disso, o software deve criar representaes desses objetos, com os mesmos
atributos e comportamentos dos objetos do mundo real. Essa representao chamada de

1.3 Abstrao
Para entender isso, vamos voltar ao exemplo do sistema de conta de corrente.
No mundo real existem vrios objetos Cliente, vrios objetos Conta e vrios objetos
Agncia (pode ser somente um), ou seja, muito provavelmente no existir somente um cliente,
uma conta e uma agncia.
Todos os objetos cliente possuem o mesmo conjunto de atributos, por exemplo, todos os
objetos cliente possuem nome e endereo, assim como todos os objetos conta possuem um
nmero, um saldo, um histrico de transaes e todos os objetos agncia possui um nmero e um
nome. Assim como os atributos, todos os objetos de um mesmo tipo compartilham do mesmo
conjunto de comportamentos, por exemplo, todos os objetos Cliente fazem depsitos e saques.
Apesar de cada objeto ter o mesmo conjunto de atributos, cada objeto possui valores prprios para
cada atributo, ou seja, cada objeto nico.
Essa explicao para objetos do mundo real vale para quando trabalhamos com a
representao desses objetos no contexto de desenvolvimento desse sistema (programao).
Portanto, podemos perceber que o sistema de conta corrente (programa de conta corrente) ser
composto de vrios objetos, cada qual com um conjunto de atributos e comportamento em comum
(se forem do mesmo tipo) e com valores prprios nos seus atributos. A figura abaixo ilustra os
vrios objetos cliente, conta e agncia.

1.4 Para finalizar essa seo vamos fazer uma pequena
reviso:
Um programa orientado a objeto composto por vrios objetos do mesmo tipo e de outros
tipos que se relacionam. Chamamos esses objetos do mundo do software de representaes de
objetos.
Como num programa muito provavelmente existiro vrios objetos do mesmo tipo, devemos criar
uma estrutura ou template que represente os atributos e comportamentos desses objetos do
mesmo tipo, essa estrutura chamada de classe. Portanto classe uma estrutura a partir da qual
os objetos (do software) so criados.


5
1.5 Histrico da Linguagem Java
Em 1991, um pequeno grupo de funcionrios da Sun mudou-se para a San Hill Road, uma
empresa filial. O grupo estava iniciando um projeto denominado Projeto Green, que consistia na
criao de tecnologias modernas de software para empresas eletrnicas de consumo.
Logo o grupo percebeu que no poderia ficar preso a plataformas pois os clientes no
estavam interessados no tipo de processador que estavam utilizando e fazer uma verso do
projeto para cada tipo de sistema seria invivel. Desenvolveram ento o sistema operacional
GreenOS, com a linguagem de programao tambm criada por eles chamada na poca de Oak
(carvalho, em ingls); nome dado pelo chefe do projeto, que enquanto pensava numa estrutura de
diretrios para a linguagem observava pela janela um carvalho. Mas esse nome no pode ser
utilizado, pois j havia sido registrado; sendo assim, no demorou muito e o nome Java surgiu em
homenagem terra de origem do caf apreciado pelos programadores da equipe.
Em 1993, surgiu uma oportunidade para o grupo Green, agora incorporado como
FirstPerson a Time-Warner, uma empresa que estava solicitando propostas de sistemas
operacionais de decodificadores e tecnologias de vdeo sob demanda. Isso foi na mesma poca
em que o NCSA lanou o MOSAIC 1.0, o primeiro navegador grfico para Web. A FirstPerson
apostou nos testes de TV da Time-Warner, mas esta empresa preferiu optar pela tecnologia
oferecida pela Silicon Graphics.
Depois de mais um fracasso a FirtsPeron dissolveu-se e metade do pessoal foi trabalhar
para a Sun Interactive com servidores digitais de vdeo. Entretanto, a equipe restante continuou os
trabalhos do projeto na Sun.
Finalmente em maio de 1995 a Sun anunciou um ambiente denominado Java que obteve
sucesso graas a incorporao deste ambiente a browsers populares como o Netscape Navigator
e padres tridimensionais como o VRML (Virtual Reality Modeling Language Linguagem de
Modelagem para Realidade Virtual).
A Sun considera o sucesso do Java na Internet como sendo o primeiro passo para utiliz-lo
em decodificadores da televiso interativa em dispositivos portteis e outros produtos eletrnicos
de consumo exatamente como o Java tinha comeado em 1991. Sua natureza portvel (roda em
qualquer ambiente) e o projeto robusto permitem o desenvolvimento para mltiplas plataformas,
em ambientes to exigentes como os da eletrnica de consumo.

1.6 Principal Caracterstica
Independncia de Plataforma
A independncia de plataforma (portabilidade) a capacidade de o mesmo programa ser
executado em diferentes plataformas e sistemas operacionais.
Quando voc compila um programa em C ou na maioria das outras linguagens, o compilador
transforma seu arquivo-fonte em cdigo de mquina instrues especficas para o processador
que seu computador est executando. Se voc compilar seu cdigo em um sistema baseado em
plataforma Intel, o programa resultante ser executado em outros sistemas baseados na
plataforma Intel, mas no funcionar em computadores Macintosh, Commodore VIC-20 ou outras

6
mquinas. Se voc usar o mesmo programa em outras plataformas, deve transferir o seu cdigo
fonte para a nova plataforma e recompil-lo para produzir o cdigo de mquina especfico para
esse sistema. Em muitos casos , sero exigidas alteraes no cdigo fonte antes que ele seja
compilado na nova mquina, devido a diferenas em seus processadores e outros fatores.

Os programas Java atingem essa independncia atravs da utilizao de uma mquina virtual
(JVM Java Virtual Machine), uma espcie de computador dentro de outro. A mquina virtual
pega os programas Java compilados e converte suas instrues em comandos que um sistema
operacional possa manipular. O mesmo programa compilado, que existe em um formato chamado
de bytecode, pode ser executado em qualquer plataforma e sistema operacional que possua uma
JVM.


7
1.7 Compilador, Cdigo Fonte, JVM
Compilador Java javac
Um programa fonte em Java pode ser desenvolvido em qualquer editor que permita gravar textos
sem caracteres de formatao. Uma vez que o programa tenha sido salvo em um arquivo,
preciso compil-lo. Para compilar um programa Java, a ferramenta oferecida pelo kit de
desenvolvimento Java o compilador Java, javac.
Na forma mais bsica de execuo, o javac invocado da linha de comando tendo por argumento
o nome do arquivo com o cdigo Java a ser compilado. Arquivos com cdigo Java sempre utilizam
a extenso .java. Por exemplo, se o cdigo a ser compilado est em um arquivo de nome
Hello.java,
class Hello {
public static void main(String[] args) {
System.out.println("Oi!");
}
}
sua compilao d-se atravs do comando:

> javac Hello.java

O resultado dessa execuo, se o programa fonte estiver sem erros, ser a criao de um arquivo
Hello.class contendo o bytecode que poder ser executado em qualquer mquina.
Cdigo Fonte
Um arquivo contendo cdigo Java constitui uma unidade de compilao, podendo incluir
comentrios, declarao relacionadas a pacotes e pelo menos uma definio de classe ou
interface.
Comentrios em Java podem ser expressos em trs formatos distintos:
//

O restante da linha corrente um comentrio.
/* ... */

Comentrio no estilo C: todo o texto entre /* e */ um comentrio, podendo estender-se por
diversas linhas.
/** ... */

Comentrio no padro javadoc: o texto entre /** e */ ser utilizado para gerar a documentao do
cdigo em formato hipertexto.

8
Declaraes relacionadas a pacotes podem ser:
package nome.do.pacote;

Opcional, mas se presente deve ser o primeiro comando do arquivo fonte. Indica que as definies
que se seguem fazem parte do pacote especificado.
import nome.do.pacote.Classe;
import nome.do.pacote.*;

Indica que a classe especificada ou, no segundo caso, quaisquer classes do pacote especificado
sero utilizadas no cdigo fonte.
Bytecodes
Um dos grandes atrativos da plataforma tecnolgica Java a portabilidade do cdigo gerado. Esta
portabilidade atingida atravs da utilizao de bytecodes. Bytecode um formato de cdigo
intermedirio entre o cdigo fonte, o texto que o programador consegue manipular, e o cdigo de
mquina, que o computador consegue executar.
Na plataforma Java, o bytecode interpretado por uma mquina virtual Java (JVM). A
portabilidade do cdigo Java obtida medida que mquinas virtuais Java esto disponveis para
diferentes plataformas. Assim, o cdigo Java que foi compilado em uma mquina pode ser
executado em qualquer mquina virtual Java, independentemente de qual seja o sistema
operacional ou o processador que executa o cdigo:

Java Virtual Machine
A Mquina Virtual Java (JVM) uma mquina de computao abstrata e um ambiente de
execuo independente de plataforma. Programas escritos em Java e que utilizem as
funcionalidades definidas pelas APIs dos pacotes da plataforma Java executam nessa mquina
virtual.
Uma das preocupaes associadas a execues nessas mquinas virtuais oferecer uma
arquitetura de segurana para prevenir que applets e aplicaes distribudas executem fora de seu
ambiente seguro (sandbox) a no ser quando assim habilitados. Um framework de segurana
estabelecido atravs de funcionalidades dos pacotes java.security, java.security.acl,
java.security.cert, java.security.interfaces e java.security.spec.
Interpretador Java
Uma vez que um programa Java tenha sido compilado e esteja pronto para ser interpretado por
uma JVM, sua forma bsica de execuo atravs do interpretador Java. Por exemplo, se o
arquivo Hello.class contm o bytecode correspondente ao cdigo fonte do arquivo Hello.java, sua
execuo d-se atravs da linha de comando

9
> java Hello

Observe que a extenso .class no includa na linha de comando. O interpretador java realiza os
seguintes passos para executar o cdigo indicado:
D incio execuo de uma mquina virtual Java;
Carrega a classe indicada para a mquina virtual Java;
Executa o mtodo main() presente nessa classe.

Para que o interpretador possa localizar a classe para a mquina virtual, preciso que ela esteja
localizada em um diretrio conhecido da mquina virtual, indicado pela varivel CLASSPATH. Esta
deve ser definida com a lista de diretrios nos quais a JVM ir procurar pelos arquivos de classes.
Por exemplo, para que os arquivos no diretrio corrente (indicado por '.') sejam localizados, define-
se o CLASSPATH como:
> export CLASSPATH=$CLASSPATH:. (linux/bash)
> set CLASSPATH=%CLASSPATH%;. (dos)

10

Unidade 2 - Programao Orientada a Objetos
2.1 Princpios da Linguagem Java
Os princpios da programao orientada a objetos so ilustrados atravs de exemplos
na linguagem de programao Java. Aqueles interessados em outras linguagens de programao
como C++, Smalltalk, Python, Eiffel podem encontrar aqui referncias a estratgias de
programao orientada a objetos, mas sem os exemplos especficos nessas linguagens.

2.2 Classes
A definio de um modelo conceitual para o domnio da aplicao, contemplando as
classes relevantes e suas associaes, um dos principais resultados das etapas de anlise e
projeto orientado a objetos. A adoo de uma linguagem de modelagem, tal como o diagrama de
classes UML, permite expressar esse resultado de maneira organizada e padronizada.
Uma classe um gabarito para a definio de objetos. Atravs da definio de uma classe,
descreve-se que propriedades -- ou atributos -- o objeto ter.
Alm da especificao de atributos, a definio de uma classe descreve tambm qual o
comportamento de objetos da classe, ou seja, que funcionalidades podem ser aplicadas a objetos
da classe. Essas funcionalidades so descritas atravs de mtodos. Um mtodo nada mais que
o equivalente a um procedimento ou funo, com a restrio que ele manipula apenas suas
variveis locais e os atributos que foram definidos para um objeto desse tipo.
Uma vez que estejam definidas quais sero as classes que iro compor uma aplicao,
assim como qual deve ser sua estrutura interna e comportamento, possvel criar essas classes
em Java..
O que uma Classe?
Uma classe um gabarito para a definio de objetos. Atravs da definio de uma classe,
descreve-se que propriedades -- ou atributos -- o objeto ter.
Alm da especificao de atributos, a definio de uma classe descreve tambm qual o
comportamento de objetos da classe, ou seja, que funcionalidades podem ser aplicadas a objetos
da classe. Essas funcionalidades so descritas atravs de mtodos. Um mtodo nada mais que
o equivalente a um procedimento ou funo, com a restrio que ele manipula apenas suas
variveis locais e os atributos que foram definidos para a classe.
Em UML (Unified Modeling Language), a representao para uma classe no diagrama de
classes :

11

A especificao de uma classe composta por trs regies:
Nome da classe
Um identificador para a classe, que permite referenci-la posteriormente -- por exemplo, no
momento da criao de um objeto.

Atributos
O conjunto de propriedades da classe. Para cada propriedade, especifica-se:
nome: um identificador para o atributo.
tipo: o tipo do atributo (inteiro, real, carter, etc.)
valor_default: opcionalmente, pode-se especificar um valor inicial para o atributo.
visibilidade: opcionalmente, pode-se especificar o quo acessvel um atributo de um
objeto a partir de outros objetos. Valores possveis so:
- (privativo), nenhuma visibilidade externa;
+ (pblico), visibilidade externa total; e
# (protegido), visibilidade externa limitada.

Mtodos
O conjunto de funcionalidades da classe. Para cada mtodo, especifica-se sua assinatura,
composta por:
nome: um identificador para o mtodo.
tipo: quando o mtodo tem um valor de retorno, o tipo desse valor.
lista de argumentos: quando o mtodo recebe parmetros para sua execuo, o tipo e um
identificador para cada parmetro.
visibilidade: como para atributos, define o quo visvel um mtodo a partir de objetos de
outros classes.

As tcnicas de programao orientada a objetos recomendam que a estrutura de um objeto
e a implementao de seus mtodos devem ser to privativos como possvel. Normalmente, os
atributos de um objeto no devem ser visveis externamente. Da mesma forma, de um mtodo
deve ser suficiente conhecer apenas sua especificao, sem necessidade de saber detalhes de
como a funcionalidade que ele executa implementada.

12

2.3 Objetos
atravs de objetos que (praticamente) todo o processamento ocorre em aplicaes
desenvolvidas com linguagens de programao orientadas a objetos. O uso racional de objetos,
obedecendo aos bons princpios associados sua definio conforme estabelecido no paradigma
de desenvolvimento orientado a objetos, chave para o desenvolvimento de bons sistemas de
software.
Toda linguagem de programao orientada a objetos oferece mecanismos para definir os
tipos de objetos para cada aplicao atravs do conceito de classes. Objetos so instncias de
classes; essas instncias precisam ser criadas para que, atravs de sua manipulao, possam
realizar seu trabalho. Aps a concluso de suas atividades, objetos podem ser removidos.
Arranjos de tipos primitivos ou de objetos so criados e manipulados de forma anloga a
objetos.
O que um objeto?
Um objeto um elemento computacional que representa, no domnio da soluo, alguma
entidade (abstrata ou concreta) do domnio de interesse do problema sob anlise. Objetos
similares so agrupados em classes.
No paradigma de orientao a objetos, tudo pode ser potencialmente representado como
um objeto. Sob o ponto de vista da programao, um objeto no muito diferente de uma varivel
no paradigma de programao convencional. Por exemplo, quando define-se uma varivel do tipo
int em C ou em Java, essa varivel tem:
- um espao em memria para registrar o seu estado atual (um valor);
- um conjunto de operaes associadas que podem ser aplicadas a ela, atravs dos
operadores definidos na linguagem que podem ser aplicados a valores inteiros (soma, subtrao,
inverso de sinal, multiplicao, diviso inteira, resto da diviso inteira, incremento, decremento).
Da mesma forma, quando se cria um objeto, esse objeto adquire um espao em memria
para armazenar seu estado (os valores de seu conjunto de atributos, definidos pela classe) e um
conjunto de operaes que podem ser aplicadas ao objeto (o conjunto de mtodos definidos pela
classe).
Um programa orientado a objetos composto por um conjunto de objetos que interagem
atravs de "trocas de mensagens". Na prtica, essa troca de mensagem traduz-se na invocao
de mtodos entre objetos.
Propriedades de objetos
Quando um objeto for ser utilizado em alguma aplicao (por outro objeto, normalmente), a
nica informao necessria que deve ser conhecida "o que podemos fazer com ele?", ou seja,
qual o conjunto de operaes associadas quele objeto. As tcnicas de programao orientada a
objetos recomendam que a estrutura interna de um objeto e a implementao de seus mtodos
devem ser to privativos como possvel.

13
H dois conceitos bsicos associados a essa viso de um objeto. O primeiro est
associado ao fato de que cada objeto uma unidade que contm, internamente, toda a informao
necessria para sua manipulao. Este o princpio da encapsulao -- cada componente de um
programa deve agregar toda a informao relevante para sua manipulao como uma unidade
(uma cpsula).
O segundo conceito fundamental associado a um bom objeto o ocultamento da
informao. Em outras palavras, quem usa o objeto no precisa nem deve conhecer como o
objeto mantm sua informao ou como uma operao implementada -- cada componente de
um programa deve manter oculta, sob sua guarda, esses aspectos relativos a decises de projeto.
Na orientao a objetos, cada objeto deve ser manipulado exclusivamente atravs dos
mtodos pblicos do objeto, dos quais apenas a assinatura deve ser revelada. O conjunto de
assinaturas desses mtodos constitui a interface operacional da classe. O programador trabalha
em um nvel alto de abstrao, sem preocupao com os detalhes internos da classe,
simplificando a construo de programas que incorporam funcionalidades complexas, tais como
interfaces grficas e aplicaes distribudas.


14

Unidade 3 - Classes em Java
3.1 Definio de Classes em Java
Em Java, classes so definidas atravs do uso da palavra-chave class. Para definir uma
classe, utiliza-se a construo:

[modif] class NomeDaClasse {
// corpo da classe...
}

A primeira linha um comando que inicia a declarao da classe. Aps a palavra-chave
class, segue-se o nome da classe, que deve ser um identificador vlido para a linguagem. O
modificador modif opcional; se presente, pode ser uma combinao de public e abstract ou final.
A definio da classe propriamente dita est entre as chaves { e }, que delimitam blocos na
linguagem Java. Este corpo da classe usualmente obedece seguinte seqncia de definio:
As variveis de classe, iniciando pelas public, seguidos pelas protected, pelas com
visibilidade padro (sem modificador) e finalmente pelas private.
Os atributos (ou variveis de instncia) dos objetos dessa classe, seguindo a mesma
ordenao definida para as variveis de classe.
Os construtores de objetos dessa classe.
Os mtodos da classe, geralmente agrupados por funcionalidade.
Toda classe pode tambm ter um mtodo main associado, que ser utilizado pelo
interpretador Java para dar incio execuo de uma aplicao.
Java tambm oferece outra estrutura, denominada interface, com sintaxe similar de
classes mas contendo apenas a especificao da funcionalidade que uma classe deve conter, sem
determinar como essa funcionalidade deve ser implementada.
Propriedades de uma classe (meta-informao) podem ser obtidas atravs das
funcionalidades oferecidas na classe java.lang.Class.

3.2 Construtores
Um construtor um (pseudo-)mtodo especial, definido para cada classe. O corpo desse
mtodo determina as atividades associadas inicializao de cada objeto criado. Assim, o
construtor apenas invocado no momento da criao do objeto atravs do operador new.
A assinatura de um construtor diferencia-se das assinaturas dos outros mtodos por no
ter nenhum tipo de retorno (nem mesmo void). Alm disto, o nome do construtor deve ser o prprio
nome da classe.

15
O construtor pode receber argumentos, como qualquer mtodo. Usando o mecanismo de
sobrecarga, mais de um construtor pode ser definido para uma classe.
Toda classe tem pelo menos um construtor sempre definido. Se nenhum construtor for
explicitamente definido pelo programador da classe, um construtor default, que no recebe
argumentos, criado pelo compilador Java. No entanto, se o programador da classe criar pelo
menos um mtodo construtor, o construtor default no ser criado automaticamente -- se ele o
desejar, dever criar um construtor sem argumentos explicitamente.
No momento em que um construtor invocado, a seguinte seqncia de aes
executada para a criao de um objeto:
O espao para o objeto alocado e seu contedo inicializado (bitwise) com zeros.
O construtor da classe base invocado.
Os membros da classe so inicializados para o objeto, seguindo a ordem em que foram
declarados na classe.
O restante do corpo do construtor executado.
Seguir essa seqncia uma necessidade de forma a garantir que, quando o corpo de um
construtor esteja sendo executado, o objeto j ter disposio as funcionalidades mnimas
necessrias, quais sejam aquelas definidas por seus ancestrais. O primeiro passo garante que
nenhum campo do objeto ter um valor arbitrrio, que possa tornar erros de no inicializao
difceis de detectar.

16
Unidade 4 - Atributos
4.1 Atributos
A definio de atributos de uma classe Java reflete de forma quase direta a informao que
estaria contida na representao da classe em um diagrama UML.
Para tanto, a sintaxe utilizada para definir um atributo de um objeto :

[modificador] tipo nome [ = default];
onde
onde
modificador (opcional), uma combinao de
public, protected ou private;
final; e
static.
tipo deve ser um dos tipos primitivos da linguagem Java ou o nome de uma classe;
nome deve ser um identificador vlido.
default (opcional) a especificao de um valor inicial para a varivel

4.2 Tipos Primitivos
Em Java, so oferecidos tipos literais primitivos (no objetos) para representar valores:
booleanos
caracteres
numricos inteiros
numricos em ponto flutuante
Booleanos
Variveis do tipo boolean podem assumir os valores true ou false.
O valor default para um atributo booleano de uma classe, se no especificado, false.
Uma varivel do tipo boolean ocupa 1 bit de armazenamento.
Variveis booleanas e variveis inteiras, ao contrrio do que ocorre em C e C++, no so
compatveis em Java. Assim, no faz sentido atribuir uma varivel booleana a uma varivel inteira
ou usar uma valor inteiro como uma condio de um teste.

17
Exemplo de declarao e uso:
boolean deuCerto;
deuCerto = true;

Combinando definio e inicializao,
boolean deuCerto = true;
Caracteres
Uma varivel do tipo char contm um carter Unicode, ocupando 16 bits de
armazenamento em memria. O valor default de um atributo de classe do tipo char, se no
especificado, o carter NUL (cdigo hexadecimal 0000).
Um valor literal do tipo carter representado entre aspas simples (apstrofes), como em:
char umCaracter = 'A';
Nesse caso, a varivel ou atributo umCaracter recebe o carter A, cdigo hexadecimal
0041 ou 65 decimal.
Valores literais de caracteres podem tambm ser representados por seqncias de escape,
como em '\n' (o carter newline).
Unicode
Unicode um padro internacional para a representao unificada de caracteres de
diversas linguagens. Citando as palavras do consrcio Unicode:
Caracteres Unicode so codificados em dois bytes, ao invs de um nico byte como no
padro ASCII adotado em outras linguagens de programao. Dessa forma, possvel representar
um nmero muito maior de caracteres, permitindo abrigar diversas linguagens.
No entanto, para os usurios que utilizam caracteres do alfabeto latino, no h diferena
perceptvel. Os caracteres com valores de cdigos hexadecimais entre 0000 (sendo 0020, ou 32
decimal, o primeiro carter no de controle) e 007F (127 decimal) correspondem codificao do
alfabeto Basic Latin (equivalente a ASCII), que est contida em Unicode. Da mesma forma,
caracteres com valores de cdigos hexadecimais entre 0080 (sendo 00A0, ou 160 decimal, o
primeiro carter no de controle) e 00FF (255 decimal) correspondem codificao do alfabeto
Latin-1 Supplement. Juntos, esses dois alfabetos constituem a codificao ISO 8859-1 (Latin-1),
contida em Unicode:
Seqncias de Escape
A lista de seqncias de escape reconhecidas em Java :

Seqncia Carter
\b backspace
\t tabulao horizontal
\n newline
\f form feed
\r carriage return

18
\" aspas
\' aspas simples
\\ contrabarra
\xxx
o carter com cdigo de valor octal xxx, que pode
assumir valores entre 000 e 377
\uxxxx
o carter Unicode com cdigo de valor
hexadecimal xxxx, onde xxxx pode assumir valores
entre 0000 e ffff
Seqncias de escape Unicode (\u) so processadas antes das anteriores, podendo
aparecer no apenas em variveis caracteres ou strings (como as outras seqncias) mas
tambm em identificadores da linguagem Java.
Inteiros
Valores numricos inteiros em Java podem ser representados por variveis do tipo byte,
short, int ou long. Todos os tipos contm valores inteiros com sinal, com representao interna em
complemento de dois. O valor default para atributos desses tipos 0.
Variveis do tipo byte ocupam 8 bits de armazenamento interno. Com esse nmero de bits,
possvel representar valores na faixa de -128 a +127.
Variveis do tipo short ocupam 16 bits, podendo assumir valores na faixa de -32.768 a
+32.767.
Variveis do tipo int ocupam 32 bits, podendo assumir valores na faixa de -2.147.483.648 a
+2.147.483.647.
Variveis do tipo long ocupam 64 bits, podendo assumir valores na faixa de -
9.223.372.036.854.775.808 a +9.223.372.036.854.775.807.
Constantes literais do tipo long podem ser identificadas em cdigo Java atravs do sufixo l
ou L, como em:
long valorQuePodeCrescer = 100L;
Ao contrrio do que ocorre em C, no h valores inteiros sem sinal (unsigned) em Java.
Combinaes da forma long int ou short int so invlidas em Java.
Reais
Valores reais, com representao em ponto flutuante, podem ser representados por
variveis de tipo float ou double. Em qualquer situao, a representao interna desses valores
segue o padro de representao IEEE 754, sendo 0.0 o valor default para tais atributos.
Variveis do tipo float ocupam 32 bits, podendo assumir valores na faixa de 1.40239846E-
45 a 3.40282347E+38 (com nove dgitos significativos de preciso).
Variveis do tipo double ocupam 64 bits, podendo assumir valores na faixa de
4.94065645841246544E-324 a 1.79769313486231570E+308 (com 18 dgitos significativos de
preciso).
Constantes literais do tipo float podem ser identificadas no cdigo Java pelo sufixo f ou F;
do tipo double, pelo sufixo d ou D.

19

4.3 Classes wrappers
Alm dos tipos primitivos da linguagem Java, h classes pr-definidas em Java que
oferecem uma srie de funcionalidades e facilidades para a manipulao desses tipos:

classe Boolean;
classe Character;
classes para valores numricos inteiros; e
classes para valores numricos reais.

Strings no so tipos primitivos em Java, nem tampouco so seqncias de caracteres
como em C. So objetos da classe String, tambm pr-definida em Java e que oferece diversas
facilidades para a manipulao de strings.
classe Boolean
A classe java.lang.Boolean oferece facilidades para a manipulao de valores do tipo
primitivo boolean.
Por exemplo, o mtodo valueOf() permite converter uma string para um valor booleano. Se
o argumento do mtodo a string "true" (independente de estar em letras maisculas ou
minsculas), esse mtodo retorna o valor booleano verdadeiro (true):

Examplo: Boolean.valueOf("True") returns true.
Examplo: Boolean.valueOf("yes") returns false.
Classe Character
A classe java.lang.Character oferece diversas facilidades para a manipulao de valores do
tipo carter. Por exemplo, dado que uma varivel foi definida como

char umCaracter = 'a';
as seguintes expresses retornariam o valor booleano true:
Character.isLetter(umCaracter);
Character.isLetterOrDigit(umCaracter);
Character.isLowerCase(umCaracter);
enquanto que as expresses a seguir retornariam false:
Character.isDigit(umCaracter);
Character.isISOControl(umCaracter);
Character.isSpaceChar(umCaracter);
Character.isWhitespace(umCaracter);
Character.isUpperCase(umCaracter);


20
H tambm funcionalidades para converso entre o valor de um dgito em uma dada base
e sua representao como carter:

int Character.digit(char c, int radix);
char Character.forDigit(int digit, int radix);
e para a converso entre letras minsculas e maisculas:
char Character.toLowerCase(char c);
char Character.toUpperCase(char c);

Classes para manipular valores numricos inteiros
Para cada tipo numrico inteiro, Java define uma classe correspondente com facilidades
para manipulao de seus valores. Assim, so definidas as classes java.lang.Byte, java.lang.Short,
java.lang.Integer e java.lang.Long.
Em cada uma dessas classes so definidas duas constantes, que especificam qual os
limites de valores representveis em uma varivel do tipo correspondente:

Byte.MIN_VALUE
Byte.MAX_VALUE

Short.MIN_VALUE
Short.MAX_VALUE

Integer.MIN_VALUE
Integer.MAX_VALUE

Long.MIN_VALUE
Long.MAX_VALUE

Cada classe oferece tambm funcionalidades para converter uma representao de um
valor da forma string para a forma numrica:

byte Byte.parseByte(String s);
byte Byte.parseByte(String s, int radix);
String Byte.toString(byte b);

short Short.parseShort(String s);
short Short.parseShort(String s, int radix);
String Short.toString(short s);

int Integer.parseInt(String s);
int Integer.parseInt(String s, int radix);
String Integer.toString(int i);
String Integer.toString(int i, int radix);

long Long.parseLong(String s);
long Long.parseLong(String s, int radix);
String Long.toString(long l);
String Long.toString(long l, int radix);

21
Classes para manipular valores numricos reais
Java oferece duas classes com facilidades para manipular valores numricos reais,
java.lang.Float e java.lang.Double.

Para cada uma das classes, so definidas constantes que representam os mnimo e
mximo valores representveis, assim como as representaes internas para os valores infinito
negativo, infinito positivo e a representao para Not A Number:

Float.MIN_VALUE
Float.MAX_VALUE
Float.NEGATIVE_INFINITY
Float.POSITIVE_INFINITY
Float.NaN

Double.MIN_VALUE
Double.MAX_VALUE
Double.NEGATIVE_INFINITY
Double.POSITIVE_INFINITY
Double.NaN

H funcionalidades para testar se o valor de uma varivel corresponde a uma das
situaes especiais de representao:

boolean Float.isInfinite(float v);
boolean Float.isNaN(float v);

boolean Double.isInfinite(double v);
boolean Double.isNaN(double v);

H funcionalidades para a converso entre o valor de uma varivel e sua representao
como string:

String Float.toString(float f);
float Float.parseFloat(String s);

String Double.toString(double d);
double Double.parseDouble(String s);

H tambm funcionalidades para converter entre as representaes binrias (internas) de
um nmero real e seu valor:

int Float.floatToIntBits(float f);
float Float.intBitsToFloat(int bits);

long Double.doubleToLongBits(double d);
double Double.longBitsToDouble(long bits);
Classe String

22
Ao contrrio do que ocorre em C e C++, strings em Java no so tratadas como
seqncias de caracteres terminadas por NUL. So objetos, instncias da classe java.lang.String.
Uma string pode ser criada como em:

String s = "abc";

O operador '+' pode ser utilizado concatenar strings:

System.out.println("String s: " + s);

possvel concatenar valores de outros tipos a strings:

int umInteiro;
...
System.out.println("Valor: " + umInteiro);
onde implicitamente ocorre uma converso da forma

System.out.println("Valor: " + Integer.toString(umInteiro));

A classe String define uma srie de funcionalidades para manipular strings, tais como:

Obter o nmero de caracteres em uma string:
int length();

Concatenar strings:
String concat(String outro);

Comparar strings:
boolean equals(String outro);
boolean equalsIgnoreCase(String outro);
int compareTo(String outro);

Extrair caracteres e substrings:
int charAt(int posio);
String substring(int pos_inicial);
String substring(int pos_inicial, int pos_final);

Localizar substrings:
int indexOf(String substring);
int indexOf(String substring, int pos_inicial);
int lastIndexOf(String substring);
int lastindexOf(String substring, int pos_inicial);
boolean startsWith(String prefixo);
boolean endsWith(String sufixo);


23
Unidade 5 - Mtodos
5.1 Mtodos
A forma genrica para a definio de um mtodo em uma classe

[modificador] tipo nome(argumentos) {
corpo do mtodo
}
onde
modificador (opcional), uma combinao de:
public, protected ou private;
abstract ou final; e
static.
tipo um indicador do valor de retorno, sendo void se o mtodo no tiver um valor de
retorno;
nome do mtodo deve ser um identificador vlido
argumentos so representados por uma lista de parmetros separados por vrgulas, onde
cada parmetro obedece forma tipo nome.

Mtodos so essencialmente procedimentos que podem manipular atributos de objetos
para os quais o mtodo foi definido. Alm dos atributos de objetos, mtodos podem definir e
manipular variveis locais; tambm podem receber parmetros por valor atravs da lista de
argumentos.
Uma boa prtica de programao manter a funcionalidade de um mtodo simples,
desempenhando uma nica tarefa. O nome do mtodo deve refletir de modo adequado a tarefa
realizada. Se a funcionalidade do mtodo for simples, ser fcil encontrar um nome adequado para
o mtodo.
Como ocorre para a definio de atributos, a definio de mtodos reflete de forma quase
direta a informao que estaria presente em um diagrama de classes UML, a no ser por uma
diferena vital: o corpo do mtodo.
Mtodos de mesmo nome podem co-existir em uma mesma classe desde que a lista de
argumentos seja distinta, usando o mecanismo de sobrecarga..

5.2 private
A palavra-chave private restringe a visibilidade do membro modificado, mtodo ou atributo,
exclusivamente a objetos da prpria classe que contm sua definio.

24
5.3 public
Em Java, a visibilidade padro de classes, atributos e mtodos est restrita a todos os
membros que fazem parte de um mesmo pacote. A palavra-chave public modifica essa visibilidade
de forma a ampli-la, deixando-a sem restries.
Uma classe definida como pblica pode ser utilizada por qualquer objeto de qualquer
pacote. Em Java, uma unidade de compilao (um arquivo fonte com extenso .java) pode ter no
mximo uma classe pblica, cujo nome deve ser o mesmo do arquivo (sem a extenso). As
demais classes na unidade de compilao, no pblicas, so consideradas classes de suporte
para a classe pblica e tm a visibilidade padro.
Um atributo pblico de uma classe pode ser diretamente acessado e manipulado por
objetos de outras classes.
Um mtodo pblico de uma classe pode ser aplicado a um objeto dessa classe a partir de
qualquer outro objeto de outra classe. O conjunto de mtodos pblicos de uma classe determina o
que pode ser feito com objetos da classe, ou seja, determina o seu comportamento.

5.4 protected
A palavra-chave protected restringe a visibilidade do membro modificado, atributo ou
mtodo, apenas prpria classe e quelas derivada desta.

5.5 abstract
Uma classe abstrata no pode ser instanciada, ou seja, no h objetos que possam ser
construdos diretamente de sua definio. Por exemplo, a compilao do seguinte trecho de cdigo

abstract class AbsClass {
AbsClass obj = new AbsClass();
}
}
geraria a seguinte mensagem de erro:

AbsClass.java:3: class AbsClass is an abstract class.
It can't be instantiated.
AbsClass obj = new AbsClass();
^
1 error
Classes abstratas correpondem a especificaes genricas, que devero ser concretizadas
em classes derivadas.
Mtodo abstrato

25
Uma classe abstrata pode conter um ou mais mtodos abstratos. Um mtodo abstrato
no cria uma definio, mas apenas uma declarao de um mtodo que dever ser implementado
em uma classe derivada. Se esse mtodo no for implementado na classe derivada, esta
permanece como uma classe abstrata mesmo que no tenha sido assim declarada explicitamente.
Por exemplo, a compilao de
abstract void meth();
}
class DerClass extends AbsClass {
DerClass obj = new DerClass();
}
}
gera dois erros:
AbsClass.java:5: class DerClass must be declared abstract.
It does not define void meth() from class AbsClass.
^
AbsClass.java:7: class DerClass is an abstract class.
It can't be instantiated.
^
2 errors
No entanto, se for includa uma implementao de meth() na classe derivada:
abstract void meth();
}
void meth() { }
}
}
ento nenhum erro de compilao ocorre.
5.6 final
A palavra chave final pode ser utilizada como uma indicao de algo que no deve ser
modificado ao longo do restante da hierarquia de descendentes de uma classe. Pode ser
associada a atributos, a mtodos e a classes.
Classe final
Uma classe definida como final no pode ser estendida. Assim, a compilao do arquivo
Reeleicao.java
final class Mandato {
}

public class Reeleicao extends Mandato {
}
ocasionaria um erro de compilao:

26
caolho:Exemplos[39] javac Reeleicao.java
Reeleicao.java:4: Can't subclass final classes: class Mandato
public class Reeleicao extends Mandato {
^
1 error
Atributo final
Um atributo final pode indicar um valor constante, que no deve ser alterado pela
aplicao. Apenas valores de tipos primitivos podem ser utilizados para definir constantes. O valor
do atributo deve ser definido no momento da declarao, pois no permitida nenhuma atribuio
em outro momento.
A utilizao de final para uma referncia a objetos permitida. Como no caso de
constantes, a definio do valor (ou seja, a criao do objeto) tambm deve ser especificada no
momento da declarao. No entanto, preciso ressaltar que o contedo do objeto em geral pode
ser modificado -- apenas a referncia fixa. O mesmo vlido para arranjos.
A partir de Java 1.1, possvel ter atributos de uma classe que sejam final mas no
recebem valor na declarao, mas sim nos construtores da classe. (A inicializao deve
obrigatoriamente ocorrer em uma das duas formas.) So os chamados blank finals, que
introduzem um maior grau de flexibilidade na definio de constantes para objetos de uma classe,
uma vez que essas podem depender de parmetros passados para o construtor.
Argumentos de um mtodo que no devem ser modificados podem ser declarados como
final, tambm, na prpria lista de parmetros.
Mtodo final
Um mtodo que definido como final em uma classe no pode ser redefinido em classes
derivadas. Considere o seguinte exemplo j visto anteriormente:
1:class ComFinal {
2: final int f() {
3: return 1;
4: }
5:}
6:
7:public class ExtComFinal extends ComFinal {
8: int f() {
9: return 0;
10: }
11:}
A tentativa de compilao dessa unidade geraria a seguinte mensagem de erro
[ricarte@mucuripe work]$ javac ExtComFinal.java
ExtComFinal.java:8: The method int f() declared in class ExtComFinal
cannot override the final method of the same signature declared in
class ComFinal. Final methods cannot be overridden.
int f() {
^
1 error


27
5.7 static
Usualmente, mtodos definidos em uma classe so aplicados a objetos daquela classe. H
no entanto situaes nas quais um mtodo pode fazer uso dos recursos de uma classe para
realizar sua tarefa sem necessariamente ter de estar associado a um objeto individualmente.
Para lidar com tais situaes, Java define os mtodos da classe, cuja declarao deve
conter o modificador static. Um mtodo esttico pode ser aplicado classe e no necessariamente
a um objeto.
Variveis de classe static
Cada objeto definido a partir de uma classe ter sua cpia separada dos atributos definidos
para a classe. No entanto, h situaes em que interessante que todos os objetos compartilhem
a mesma varivel, similarmente ao que ocorre com variveis globais em linguagens de
programao tradicional. O mecanismo para realizar esse compartilhamento a definio de
variveis de classe.
Uma varivel de classe tem sua declarao precedida pela palavra-chave static.
Vrias constantes so definidas em Java como public static final. Por exemplo, a classe
Math de Java define as constantes E (2.71828...) e PI (3.14159...). Para ter acesso a esses
valores, basta preced-los com o nome da classe e um ponto, como em
double pi2 = Math.PI/2;
Outro exemplo de varivel public static final a varivel out da classe System. Essa
varivel, System.out, est associada a um objeto que representa a sada padro (o monitor,
tipicamente), sendo utilizada sempre que se deseja enviar um valor para essa sada.
Exemplo System.out
A varivel out est associada apresentao de caracteres na sada padro, ou seja, na
tela do monitor. Na documentao da API Java encontra-se:
out
public static final PrintStream out

Uma simples anlise dessa declarao mostra que:
out uma varivel de classe e, portanto, pode ser acessada na forma System.out;
essa varivel pblica;
a varivel final; e
a varivel do tipo PrintStream.
Exemplos de mtodos estticos em Java incluem os mtodos para manipulao de tipos
primitivos definidos nas classes java.lang.Character, java.lang.Integer e java.lang.Double, assim
como todos os mtodos definidos para a classe java.lang.Math. Por exemplo, para atribuir a raiz
quadrada de 2 a uma varivel sqr2, a expresso
double sqr2 = Math.sqrt(2.0);
poderia ser utilizada.

28

5.8 Definio do Corpo de Mtodos
O corpo de um mtodo formado por declaraes de variveis locais e comandos da
linguagem de programao.
A sintaxe de declarao de variveis locais em Java similar quela de declarao de
atributos de objetos, sem a opo dos modificadores de visibilidade -- variveis locais tm
visibilidade restrita ao mtodo, exclusivamente. Assim, uma varivel declarada em um mtodo tem
a forma
onde
o modificador opcional pode ser exclusivamente final;
tipo deve ser um dos tipos primitivos da linguagem Java ou o nome de uma classe;
nome deve ser um identificador vlido.
default (opcional) a especificao de um valor inicial para a varivel.
Embora no seja obrigatrio, uma boa prtica de programao manter todas as
declaraes de variveis no incio do mtodo. Uma exceo aceita refere-se a blocos delimitados
por iterao com for, onde a forma
for(int i=0; i < maximo; ++i) { ... }
aceita. Neste caso, o escopo da varivel i est restrito ao bloco da iterao.
Comandos podem representar uma expresso (uma operao a ser realizada) ou um
comando de controle de fluxo de execuo.

29

Unidade 6 - Manipulao de Objetos
6.1 Manipulao de Objetos
Quando declara-se uma varivel cujo tipo o nome de uma classe, como em

String nome;

no est se criando um objeto dessa classe, mas simplesmente uma referncia para um
objeto da classe String, a qual inicialmente no faz referncia a nenhum objeto vlido:

Quando um objeto dessa classe criado, obtm-se uma referncia vlida, que
armazenada na varivel cujo tipo o nome da classe do objeto. Por exemplo, quando cria-se uma
string como em

nome = new String("POO/Java");
nome uma varivel que armazena uma referncia para um objeto especfico da classe
String -- o objeto cujo contedo "POO/Java":

importante ressaltar que a varivel nome mantm apenas a referncia para o objeto e
no o objeto em si. Assim, uma atribuio como

String outroNome = nome;
no cria outro objeto, mas simplesmente uma outra referncia para o mesmo objeto:

30

O nico modo de aplicar os mtodos a um objeto atravs de uma referncia ao
objeto. Seguindo com o mesmo exemplo, para criar um novo objeto como mesmo contedo do
objeto existente, o mtodo clone() pode ser aplicado a este:

String outraString = nome.clone();

Em Java, a palavra-chave this utilizada por um objeto para fazer a referncia a si prprio.

6.2 this
Quando um mtodo aplicado a um objeto, de algum modo deve ser sinalizado ao mtodo
a qual objeto a invocao est referindo-se. Por exemplo,

String s1 = "java";
String s2 = "linguagem de programao orientada a objetos";
int x1 = s1.length(); // 4
int x2 = s2.length(); // 44
Nesse exemplo, o mtodo aplicado s duas strings o mesmo -- length(). Como o mtodo
sabe qual o objeto que ele deve "olhar" para saber o que fazer?


31
Por trs da resposta a essa pergunta est a presena de um "parmetro secreto", que
passado a todo mtodo, que uma referncia ao objeto que est realizando a invocao. Em
termos de uma linguagem procedimental, isso seria o equivalente a ter para as duas ltimas linhas
do exemplo acima
:
int x1 = length(s1);
int x2 = length(s2);

Se necessrio, o prprio mtodo pode ter acesso a essa referncia em seu cdigo. Essa
referncia passada atravs da palavra-chave this, reservada para esse propsito.

6.3 Exemplos de Uso de this
A palavra-chave this utilizada principalmente em dois contextos:
- Diferenciar atributos de objetos de parmetros ou variveis locais de mesmo nome;
- Acessar o mtodo construtor a partir de outros construtores.

Esse exemplo ilustra esses dois usos

class ThisSample {
int x;
int y;

// exemplo do primeiro caso:
public ThisSample(int x, int y) {
this.x = x;
this.y = y;
}

// exemplo do segundo caso:
public ThisSample( ) {
this(1, 1);
}
}
6.4 Remoo de objetos
Em linguagens de programao orientadas a objetos, a criao de objetos um processo
que determina a ocupao dinmica de muitos pequenos segmentos de memria. Se esse espao
no fosse devolvido para reutilizao pelo sistema, a dimenso de aplicaes desenvolvidas com
linguagens de programao orientadas a objetos estaria muito limitada.

32
As duas abordagens possveis so dedicar essa tarefa ao programador ou deixar que o
sistema seja o responsvel por esta retomada de recursos. O problema da primeira abordagem
que o programador pode no considerar todas as possibilidades, ocasionando problemas como
"vazamento de memria" (memory leak). Na segunda abordagem, recursos adicionais do sistema
so necessrios para a manuteno da informao necessria para saber quando um recurso
pode ser retomado e para a execuo do processo que retoma os recursos.
C++ uma linguagem que adota a primeira estratgia. A remoo de objetos efetivada
explicitamente pelo programador (atravs do operador delete), que pode tambm especificar o
procedimento que deve ser executado para a liberao de outros recursos alocados pelo objeto
atravs de um mtodo destructor.
Java, assim como Smalltalk e lisp, adota a abordagem de ter um garbage collector
verificando que objetos no tm nenhuma referncia vlida, retomando o espao dispensado para
cada um desses objetos. Dessa forma, o programador no precisa se preocupar com a remoo
explcita de objetos.
Adicionalmente, pode ser necessrio liberar outros recursos que tenham sido alocados
para o objeto. O mtodo finalize() especifica o que deve ser feito antes do espao do objeto ser
retomado pelo garbage collector.
Esse mtodo definido na classe Object como protected. Portanto, se for necessrio
redefini-lo o programador deve tambm declar-lo como protected.
preciso observar que o uso de finalize() ocorre atravs da redefinio de mtodos. Assim,
ao contrrio do que acontece com construtores (onde o mtodo correspondente na superclasse
automaticamente invocado), o mtodo finalizador da superclasse deve ser invocado explicitamente
(super.finalize()) ao final do corpo do finalizador local.
Uma observao adicional com relao a garbage collectors que programadores no tm
como atuar explicitamente sobre esse processo.

No entanto, o programador pode:
- remover explicitamente a referncia a um objeto para sinalizar ao GC que o objeto no
mais necessrio e pode ser removido;
- sugerir ao (mas no forar que o) sistema que execute o garbage collector atravs da invocao
ao mtodo gc() da classe java.lang.System:
public static void gc()
- sugerir que o sistema exexute os mtodos finalize() de objetos descartados atravs do
mtodo runFinalization da classe java.lang.System:
6.5 A Classe Object
A classe java.lang.Object a raiz a partir da qual todas as classes so definidas. Desse
modo, as definies dessa classe esto disponveis para objetos de todas as demais classes.
O mtodo equals, que permite comparar objetos por seus contedos, um dos mtodos definido
nessa classe:

33
public boolean equals(Object obj)

O mtodo clone() permite criar duplicatas de um objeto

O mtodo toString() permite converter uma representao interna do objeto em uma string que pode ser
apresentada ao usurio:

A partir do objeto retornado, da classe java.lang.Class, possvel obter o nome da classe usando o
mtodo da classe Class getName(), que retorna uma string com o nome da classe.

34
Unidade 7 - Herana
7.1 Herana
Um dos grandes diferenciais da programao orientada a objetos em relao a outros
paradigmas de programao est no conceito de herana, mecanismo atravs do qual definies
existentes podem ser facilmente estendidas. Juntamente com a herana deve ser enfatizada a
importncia do polimorfismo, que permite selecionar funcionalidades que um programa ir utilizar
de forma dinmica, durante sua execuo.
O conceito de encapsular estrutura e comportamento em um tipo no exclusivo da
orientao a objetos; particularmente, a programao por tipos abstratos de dados segue esse
mesmo conceito. O que torna a orientao a objetos nica o conceito de herana.
Herana um mecanismo que permite que caractersticas comuns a diversas classes
sejam fatoradas em uma classe base, ou superclasse. A partir de uma classe base, outras
classes podem ser especificadas. Cada classe derivada ou subclasse apresenta as
caractersticas (estrutura e mtodos) da classe base e acrescenta a elas o que for definido de
particularidade para ela.
Sendo uma linguagem de programao orientada a objetos, Java oferece mecanismos
para definir classes derivadas a partir de classes existentes. fundamental que se tenha uma boa
compreenso sobre como objetos de classes derivadas so criados e manipulados, assim como
das restries de acesso que podem se aplicar a membros de classes derivadas. Tambm
importante para uma completa compreenso da utilizao desse mecanismo em Java a
compreenso de como relacionam-se interfaces e herana.
Herana sempre utilizada em Java, mesmo que no explicitamente. Quando uma classe
criada e no h nenhuma referncia sua superclasse, implicitamente a classe criada
derivada diretamente da classe Object. por esse motivo que todos os objetos podem invocar os
mtodos da classe Object, tais como equals() e toString().

7.2 Formas de Herana
H vrias formas de relacionamentos em herana:
Extenso: subclasse estende a superclasse, acrescentando novos membros (atributos
e/ou mtodos). A superclasse permanece inalterada, motivo pelo qual este tipo de relacionamento
normalmente referenciado como herana estrita.
Especificao: a superclasse especifica o que uma subclasse deve oferecer, mas no
implementa nenhuma funcionalidade. Diz-se que apenas a interface (conjunto de especificao
dos mtodos pblicos) da superclasse herdada pela subclasse.
Combinao de extenso e especificao: a subclasse herda a interface e uma
implementao padro de (pelo menos alguns de) mtodos da superclasse. A subclasse pode
ento redefinir mtodos para especializar o comportamento em relao ao que oferecido pela
superclasse, ou ter que oferecer alguma implementao para mtodos que a superclasse tenha

35
declarado mas no implementado. Normalmente, este tipo de relacionamento denominado
herana polimrfica.
A ltima forma , sem dvida, a que mais ocorre na programao orientada a objetos.
Algumas modelagens introduzem uma forma de herana conhecida como contrao, que deve ser
evitada.

7.3 Contrao
Contrao uma uma variante de herana onde a subclasse elimina mtodos da
superclasse com o objetivo de criar uma "classe mais simples". A eliminao pode ocorrer pela
redefinio de mtodos com corpo vazio. O problema com este mecanismo que ele viola o
princpio da substituio, pois a subclasse j no pode mais ser utilizada em todos os pontos onde
a superclasse poderia ser utilizada.
Se a contrao parece ser uma soluo adequada em uma hierarquia de classes,
provavelmente a hierarquia deve ser re-analisada para deteco de inconsistncias (problema
pssaros-pinguins). De modo geral, o mecanismo de contrao deve ser evitado.

7.4 Sintaxe
A forma bsica de herana em Java a extenso simples entre uma superclasse e sua
classe derivada. Para tanto, utiliza-se na definio da classe derivada a palavra-chave extends
seguida pelo nome da superclasse.
Assim, definir uma classe Ponto2D como em
class Ponto2D {
// ...
}
equivalente a
class Ponto2D extends Object {
// ...
}
O exemplo completo ilustra como uma classe Ponto2D pode ser utilizada como base para a
definio de outra classe derivada Ponto3D atravs do mecanismo de extenso simples.

class Ponto2D {
private int x;
private int y;

public Ponto2D(int x, int y) {
this.x = x;
this.y = y;
}

public Ponto2D( ) {
this(0,0);

36
}

public double distancia(Ponto2D p) {
double distX = p.x - x;
double distY = p.y - y;

return(Math.sqrt(distX*distX + distY*distY));
}
}

class Ponto3D extends Ponto2D {
private int z;

public Ponto3D(int x, int y, int z) {
super(x, y);
this.z = z;
}

public Ponto3D( ) {
z = 0;
}

Ponto2D ref2 = new Ponto2D();
Ponto2D p2 = new Ponto2D(1,1);
System.out.println("Distancia2: " + p2.distancia(ref2));
Ponto3D p3 = new Ponto3D(1,2,3);
}
}

7.5 Construo de Objetos Derivados
Durante a construo de um objeto de uma classe derivada, o construtor de sua
superclasse executado (implicitamente ou explicitamente) antes de executar o corpo de seu
construtor.
Assim, ao se construir um objeto de uma classe derivada, o mtodo construtor da
superclasse ser inicialmente invocado. Este, por sua vez, invocar o construtor de sua
superclasse, at que o construtor da classe raiz de toda a hierarquia de objetos -- a classe Object -
- seja invocado. Como Object no tem uma superclasse, seu construtor executado e a execuo
retorna para o construtor de sua classe derivada. Ento executa-se o restante do construtor de sua
classe derivada e a execuo retorna para o construtor de sua classe derivada e assim
sucessivamente, at que finalmente o restante do construtor da classe para a qual foi solicitada a
criao de um objeto seja executada.
Construtores da superclasse podem ser explicitamente invocados usando a palavra-chave
super
7.6 A Palavra-Chave super

37
Java no oferece o mecanismo de herana mltipla, ou seja, no possvel criar uma
classe derivada com mais de uma classe base. Por esse motivo, simples fazer uma referncia da
classe derivada para sua superclasse; o mecanismo para tal o uso da palavra-chave super.
Construtores da superclasse podem ser explicitamente invocados usando o mtodo
super(). No exemplo do Ponto3D, isso feito para o construtor da classe derivada com
argumentos:

super(x, y);
this.z = z;
}
A expresso super(x, y); na primeira linha do construtor est invocando o construtor da
classe base, Ponto2D, que recebe dois argumentos. O efeito dessa invocao iniciar os valores
dos atributos x e y do objeto com os valores dos parmetros x e y recebidos pelo mtodo
construtor.
A invocao do mtodo super(), se presente, deve estar na primeira linha. Implicitamente, o
compilador faz a invocao do construtor super() default (sem argumentos) para cada construtor
definido. Por esse motivo, o segundo construtor da classe Ponto3D no faz a invocao desse
mtodo explicitamente. Assim,

public Ponto3D( ) {
z = 0;
}

equivale a

public Ponto3D( ) {
super();
z = 0;
}

Esse um dos motivos pelo qual sempre interessante ter o construtor default definido.
Entretanto, a invocao direta pode ser interessante quando se deseja invocar algum construtor
que no o default, como no exemplo anterior.
Outro uso dessa palavra-chave como prefixo para referenciar mtodos da superclasse.

class Ponto2D {
private int x;
private int y;

public Ponto2D(int x, int y) {
this.x = x;
this.y = y;
}

public Ponto2D( ) {
this(0,0);
}

38


return(Math.sqrt(distX*distX + distY*distY));
}
}

class Ponto3D extends Ponto2D {
private int z;

super(x, y);
this.z = z;
}

public Ponto3D( ) {
z = 0;
}

Ponto2D ref2 = new Ponto2D();
Ponto2D p2 = new Ponto2D(1,1);
Ponto3D p3 = new Ponto3D(1,2,3);
}
}
7.7 Restries de acesso
O exemplo da classe Ponto3D ilustra a forma bsica de herana -- uma vez que uma
classe tenha sido definida como derivada de outra, ela preserva da superclasse os atributos (no
caso, os valores das coordenadas x e y) e seus mtodos (no caso, o mtodo distancia(Ponto2D)
aplicado a um Ponto3D).
No entanto, deve ser observado que nenhum mtodo definido para a classe Ponto3D pode
ter acesso aos atributos x e y, pois esses so declarados como private da classe Ponto2D. De
fato, caso tente-se definir naquela classe um mtodo para calcular a distancia entre dois pontos no
espao, tal como:

double distZ = p.z - z;
return(Math.sqrt(distX*distX + distY*distY + distZ*distZ));
}

os seguintes erros seriam detectados pelo compilador Java:

Ponto3Derr.java:35: No variable x defined in class Ponto3D.

39
^
Ponto3Derr.java:35: Undefined variable: x
^
Ponto3Derr.java:36: No variable y defined in class Ponto3D.
^
Ponto3Derr.java:36: Undefined variable: y
^
ou seja, mesmo embora a classe Ponto3D tenha os atributos x e y, mtodos dessa classe
no podem manipul-los diretamente.

Uma alternativa para permitir que classes derivadas possam manipular atributos da
superclasse declarar tais atributos como protected ao invs de private. Assim, objetos de classes
derivadas tm acesso tanto de leitura como de escrita para esses atributos.
Caso deseje-se dar acesso apenas de leitura a esses atributos, uma outra alternativa
usar um mtodo acessor para cada atributo, ou seja, um mtodo que simplesmente retorna o
valor do atributo. Nesse exemplo, a classe Ponto2D definiria dois mtodos,
public int getX() {
return x;
}

public int getY() {
return y;
}
que permitem que qualquer objeto de qualquer classe consiga ler os valores de x e y -- mas
no alter-los. Assim, a classe Ponto3D poderia definir o mtodo para a distncia no espao como
double distX = p.getX() - this.getX();
double distY = p.getY() - this.getY();
double distZ = p.z - z;
return(Math.sqrt(distX*distX + distY*distY + distZ*distZ));
}
que compilaria e executaria sem erros.

Pode-se tambm permitir acesso de apenas leitura somente para as classes derivadas --
nesse caso, os mtodos acessores seriam declarados como protected, como em

protected int getX() {
return x;
}

protected int getY() {
return y;
}

O mtodo distancia(Ponto3D) no precisaria sofrer nenhuma modificao, mas outras
classes no-derivadas de Ponto2D no teriam mais como invocar esses mtodos acessores.

40

Unidade 8 - Polimorfismo
8.1 Polimorfismo:
Polimorfismo o princpio pelo qual duas ou mais classes derivadas de uma mesma
superclasse podem invocar mtodos que tm a mesma identificao (assinatura) mas
comportamentos distintos, especializados para cada classe derivada, usando para tanto uma
referncia a um objeto do tipo da superclasse. A deciso sobre qual o mtodo que deve ser
selecionado, de acordo com o tipo da classe derivada, tomada em tempo de execuo, atravs
do mecanismo de ligao tardia.
8.2 Ligao Tardia:
Quando o mtodo a ser invocado definido durante a compilao do programa, o
mecanismo de ligao prematura (early binding) utilizado.
Para a utilizao de polimorfismo, a linguagem de programao orientada a objetos deve
suportar o conceito de ligao tardia (late binding), onde a definio do mtodo que ser
efetivamente invocado s ocorre durante a execuo do programa. O mecanismo de ligao tardia
tambm conhecido pelos termos dynamic binding ou run-time binding.
Em Java, todas as determinaes de mtodos a executar ocorrem atravs de ligao tardia
exceto em dois casos:
- mtodos declarados como final no podem ser redefinidos e portanto no so passveis
de invocao polimrfica da parte de seus descendentes;
- e mtodos declarados como private so implicitamente finais.

No caso de polimorfismo, necessrio que os mtodos tenham exatamente a mesma
identificao, sendo utilizado o mecanismo de redefinio de mtodos (overriding). Esse
mecanismo de redefinio muito diferente do mecanismo de sobrecarga de mtodos
(overloading)..
8.3 Sobrecarga (overloading):
Na programao orientada a objetos, um mtodo aplicado a um objeto selecionado para
execuo com base na classe a que ele pertence, no nome do mtodo e nos tipos de seus
parmetros. O nome do mtodo com a lista de tipos de parmetros constituem a assinatura do
mtodo.
Atravs do mecanismo de sobrecarga, dois mtodos de uma classe podem ter o mesmo
nome, desde que suas assinaturas sejam diferentes. Tal situao no gera conflito pois o
compilador capaz de detectar qual mtodo deve ser escolhido a partir da anlise dos argumentos
do mtodo.

41
Um exemplo do uso de sobrecarga em Java encontrado nos mtodos abs(), max() e
min() da classe java.lang.Math, que tm implementaes alternativas para quatro tipos de
argumentos distintos.
O uso de polimorfismo em Java ilustrado atravs de um exemplo. Atravs desse exemplo
introduzem-se os conceitos relacionados de upcasting e a motivao para a definio de mtodos
abstratos.
8.4 Polimorfismo em Java:
Considere uma classe Veculo com duas classes derivadas, Automvel e Bicicleta:

Essas classes tm trs mtodos, definidos para veculos de forma geral e redefinidos mais
especificamente para automveis e bicicletas:
checkList(), para verificar o que precisa ser analisado no veculo;
adjust(), para realizar os reparos e a manuteno necessria; e
cleanup(), para realizar procedimentos de limpeza do veculo.

A aplicao Oficina define um objeto que recebe objetos da classe Veculo. Para cada
veculo recebido, a oficina executa na seqncia os trs mtodos da classe Veculo. No entanto,
no h como saber no momento da programao se a Oficina estar recebendo um automvel ou
uma bicicleta -- assim, o momento de deciso sobre qual mtodo ser aplicado s ocorrer
durante a execuo do programa.
import java.util.*;
class Veiculo {
public Veiculo() {
System.out.print("Veiculo ");
}
public void checkList() {
System.out.println("Veiculo.checkList");
}
public void adjust() {
System.out.println("Veiculo.adjust");

42
}
public void cleanup() {
System.out.println("Veiculo.cleanup");
}
}

class Automovel extends Veiculo {
public Automovel() {
System.out.println("Automovel");
}
System.out.println("Automovel.checkList");
}
System.out.println("Automovel.adjust");
}
System.out.println("Automovel.cleanup");
}
}

class Bicicleta extends Veiculo {
public Bicicleta() {
System.out.println("Bicicleta");
}
System.out.println("Bicicleta.checkList");
}
System.out.println("Bicicleta.adjust");
}
System.out.println("Bicicleta.cleanup");
}
}
public class Oficina {
Random r = new Random();

public Veiculo proximo() {
Veiculo v;
int code = r.nextInt();
if (code%2 == 0)
v = new Automovel();
else
v = new Bicicleta();

return v;
}

public void manter(Veiculo v) {
v.checkList();
v.adjust();
v.cleanup();
}


43
Oficina o = new Oficina();
Veiculo v;

for (int i=0; i<4; ++i) {
v = o.proximo();
o.manter(v);
}
}
}
Este trecho de cdigo ilustra a utilizao da classe Oficina, considerando que os mtodos
acima foram definidos para Veculo e para todas as suas classes derivadas. Um possvel resultado
da interpretao dessa aplicao :

Veiculo Bicicleta
Bicicleta.checkList
Bicicleta.adjust
Bicicleta.cleanup
Veiculo Bicicleta
Bicicleta.checkList
Bicicleta.adjust
Bicicleta.cleanup
Veiculo Automovel
Automovel.checkList
Automovel.adjust
Automovel.cleanup
Veiculo Automovel
Automovel.checkList
Automovel.adjust
Automovel.cleanup

Alguns pontos a destacar com relao a esse exemplo:
8.5 Upcasting:
O mtodo Oficina.proximo() realiza uma atribuio de um objeto Automvel varivel
(referncia para objeto Veiculo) v quando o valor do nmero aleatrio gerado par (o resto da
diviso inteira por 2 igual a 0). Essa atribuio de um objeto de uma classe mais especializada
para uma referncia de uma classe ancestral denominada upcast. Esse mesmo tipo de
atribuio realizado de Bicicleta para veculo quando o nmero aleatrio gerado mpar.
Recuperando informao sobre um tipo
O uso de polimorfismo est intimamente relacionado ao mecanismo de upcast, onde parte
da informao sobre um objeto torna-se inacessvel - ou seja, informao momentaneamente
perdida. Esse processo seguro do ponto de vista da orientao a objetos pois a interface da
classe base nunca maior que a interface da classe derivada.
H situaes onde interessante recuperar a referncia para o tipo original de um objeto,
de modo a obter acesso sua funcionalidade completa. Para tanto, o mecanismo de downcast
precisa ser utilizado:


44
Ref_orig = (Tipo_orig) Ref_upcast;
O problema com downcasting que preciso verificar se o objeto que est tendo sua
referncia convertida realmente do tipo especificado, ou caso contrrio seria impossvel garantir
sua manipulao correta aps a converso.
Em Java, todas as operaes de downcasting so verificadas atravs do mecanismo de
Run-Time Type Identification (RTTI) suportado pela linguagem. Lembre-se que possvel, para
qualquer objeto, obter a indicao de a qual classe ele pertence atravs do mtodo getClass().
8.6 Uso de mtodos abstratos:
Apesar de mtodos da classe Veculo terem sido definidos, estes nunca so invocados
nesse exemplo. (Se fossem, algo estaria errado.) Isso ilustra uma situao onde mtodos
abstratos poderiam ser utilizados, pois a definio do corpo desses mtodos de fato irrelevante.
Ainda mais, se uma classe como essa s contm mtodos abstratos, ela poderia ser
implementada como uma interface Java.
importante observar que, quando polimorfismo est sendo utilizado, o comportamento
que ser adotado por um mtodo s ser definido durante a execuo. Embora em geral esse seja
um mecanismo que facilite o desenvolvimento e a compreenso do cdigo orientado a objetos, h
algumas situaes onde o resultado da execuo pode ser no-intuitivo, como ilustra esse
exemplo que usa polimorfismo em construtores.
8.7 Polimorfismo em construtores:
A invocao de mtodos com ligao tardia abre uma possibilidade de invocar construtores
cujo comportamento poderia ser diferenciado polimorficamente. A ttulo de exemplo, considere o
seguinte cdigo:

abstract class Base {
abstract void m();
public Base() {
System.out.println("Base: inicio construcao");
m();
System.out.println("Base: fim construcao");
}
}

public class Derivada extends Base {
int valor = 1;
void m() {
System.out.println("Derivada.m: " + valor);
}
public Derivada(int v) {
System.out.println("Derivada: inicio construcao");
valor = v;
System.out.println("Derivada: fim construcao");
}

new Derivada(10);

45
}
}
envolvendo uma classe Derivada e uma classe Base cujo construtor invoca um mtodo
implementado na classe derivada e apresenta o seguinte resultado.

Base: inicio construcao
Derivada.m: 0
Base: fim construcao
Derivada: inicio construcao
Derivada: fim construcao

O resultado dessa execuo pode ser explicado pela seqncia de aes que obedecida
para a construo de um objeto a partir do momento no qual seu construtor invocado. O
comportamento apresentado nesse exemplo pode ser diferente daquele intuitivamente esperado
por um programador que esteja analisando um cdigo onde esta situao. Em um programa de
maior porte, pode levar a situaes de erro de difcil deteco.
A recomendao que se faz com relao utilizao de mtodos no corpo de construtores

No invoque mtodos no corpo de construtores a menos que isto seja seguro.
Mtodos seguros para invocao a partir de construtores so aqueles que no podem ser
redefinidos.

46
Unidade 9 - Interfaces
9.1 Interface:
Uma interface Java uma classe abstrata para a qual todos os mtodos so implicitamente
abstract e public, e todos os atributos so implicitamente static e final. Em outros termos, uma
interface Java implementa uma "classe abstrata pura".
A sintaxe para a declarao de uma interface similar quela para a definio de classes,
porm seu corpo define apenas assinaturas de mtodos e constantes.
Uma interface estabelece uma espcie de contrato que obedecido por uma classe.
Quando uma classe implementa uma interface, garante-se que todas as funcionalidades
especificadas pela interface sero oferecidas pela classe.
9.2 Declarao de interface:
A sintaxe para a definio de uma interface Java equivale quela da definio de uma
classe, apenas usando a palavra chave interface ao invs da palavra chave class.
Por exemplo, para definir uma Interface1 que declara um mtodo void met1() a sintaxe :

interface Interface1 {
void met1();
}

A diferena entre uma classe abstrata e uma interface Java que a interface
obrigatoriamente no tem um "corpo" associado. Para que uma classe seja abstrata basta que ela
seja assim declarada, mas a classe pode incluir atributos de objetos e definio de mtodos,
pblicos ou no. Na interface, apenas mtodos pblicos podem ser declarados -- mas no
definidos. Da mesma forma, no possvel definir atributos -- apenas constantes pblicas.
Enquanto uma classe abstrata "estendida" (palavra chave extends) por classes
derivadas, uma interface Java "implementada" (palavra chave implements) por outras classes.
9.3 Implementao de Interfaces:
Uma vez que interfaces estejam definidas, como so usadas?
Interfaces so especificaes que so ou sero implementadas atravs de classes Java.
Por exemplo, uma interface Abc definida como

interface Abc {
void a(int i);
int b(String s);
String c();
}

47

Indica que qualquer classe implementando essa especificao oferece pelo menos os trs
mtodos, exatamente com as assinaturas descritas. No necessrio saber como os mtodos
esto sendo implementados.
Uma classe Xyz que implementa a especificao de uma interface Abc declarada com a
sintaxe:

class Xyz implements Abc {
// declaraes, outros mtodos
void a(int valor) {
...
}

int b(String nome) {
...
}

String c( ) {
...
}
}
na classe que o corpo de cada um dos mtodos da interface efetivamente especificado,
determinando como ocorre a implementao.
9.4 Definio de Constantes:
Outro uso de interfaces Java para a definio de constantes que devem ser
compartilhadas por diversas classes. Neste caso, a recomendao implementar interfaces sem
mtodos, pois as classes que implementarem tais interfaces no precisam tipicamente redefinir
nenhum mtodo:

interface Coins {
int
PENNY = 1,
NICKEL = 5,
DIME = 10,
QUARTER = 25,
DOLAR = 100;
}

class CokeMachine implements Coins {
int price = 3*QUARTER;
// ...
}

48

Unidade 10 - Identificadores
10.1 Identificadores
Nomes de classes, variveis e mtodos devem ser identificadores vlidos da linguagem.
Esses identificadores so seqncias de caracteres Unicode.
As regras para a definio de identificadores so:

- Um nome pode ser composto por letras (minsculas e/ou maisculas), dgitos e os
smbolos _ e $.
- Um nome no pode ser iniciado por um dgito (0 a 9).
- Letras maisculas so diferenciadas de letras minsculas.
- Uma palavra-chave da linguagem Java no pode ser um identificador.

Alm dessas regras obrigatrias, o uso da conveno padro para identificadores Java
torna a codificao mais uniforme e pode facilitar o entendimento de um cdigo.

10.2 Palavras Reservadas em Java:
As palavras a seguir so de uso reservado em Java e no podem ser utilizadas como
nomes de identificadores:

abstract double int static
boolean else interface super
break extends long switch
byte final native synchronized
case finally new this
catch float null throw
char for package throws
class goto private transient
const if protected try
continue implements public void
default import return volatile
do instanceof short while

10.3 Conveno para identificadores:

49
Embora no seja obrigatrio, o conhecimento e uso da seguinte conveno padro para
atribuir nomes em Java pode facilitar bastante a manuteno de um programa:
- Nomes de classes so iniciados por letras maisculas.
- Nomes de mtodos, atributos e variveis so iniciados por letras minsculas.
- Em nomes compostos, cada palavra do nome iniciada por letra maiscula -- as palavras
no so separadas por nenhum smbolo.
- Detalhes sobre as convenes de codificao sugeridas pelos projetistas da linguagem
Java podem ser encontrados no documento Code Conventions for the JavaTM Programming
Language


50

Unidade 11 - Expresses
public static void gc()11.1 Expresses:
Expresses em Java so terminadas por ";", podendo incluir expresses do tipo

operao aritmtica,
operao lgica inteira,
operao lgica booleana,
condies,
atribuio,
retorno, e
operaes sobre objetos.

11.1 Expresses Aritmticas:
Expresses aritmticas envolvem atributos, variveis e/ou constantes numricas (inteiras
ou reais). Os operadores aritmticos definidos em Java incluem

soma (+);
subtrao (-);
multiplicao (*);
diviso (/);
resto da diviso (%), apenas para operandos inteiros;

incremento (++), operador unrio definido apenas para operandos inteiros, podendo ocorrer
antes da varivel (pr-incremento) ou aps a varivel (ps-incremento); e

decremento (--), operador unrio definido apenas para operandos inteiros, podendo ocorrer
antes da varivel (pr-decremento) ou aps a varivel (ps-decremento).

11.2 Expresses Lgicas Inteiras:

51
Operaes lgicas sobre valores inteiros atuam sobre a representao binria do valor
armazenado, operando internamente bit a bit. Operadores desse tipo so:

- complemento (~), operador unrio que reverte os valores dos bits na representao
interna;
- OR bit-a-bit (|), operador binrio que resulta em um bit 1 se pelo menos um dos bits na
posio era 1;
- AND bit-a-bit (&), operador binrio que resulta em um bit 0 se pelo menos um dos bits na
posio era 0;
- XOR bit-a-bit (^), operador binrio que resulta em um bit 1 se os bits na posio eram
diferentes;
- deslocamento esquerda (<<), operador binrio que recebe a varivel cujo contedo ser
deslocado e um segundo operando que especifica o nmero de posies a deslocar esquerda;
- deslocamento direita com extenso de sinal (>>), operador binrio que recebe a varivel
cujo contedo ser deslocado e um segundo operando que especifica o nmero de posies a
deslocar direita. Os bits inseridos esquerda tero o mesmo valor do bit mais significativo da
representao interna;
- deslocamento direita com extenso 0 (>>>), operador binrio que recebe a varivel cujo
contedo ser deslocado e um segundo operando que especifica o nmero de posies a deslocar
direita. Os bits inseridos esquerda tero o valor 0..

Por exemplo, queremos resolver o seguinte problema: Calcular a mdia de todos os alunos
que cursaram uma disciplina X, a partir da leitura das notas da 1 e 2 prova, passando por um
clculo de mdia aritmtica. Aps a mdia calculada, devemos anunciar se o aluno foi aprovado
ou reprovado por nota. Somente esto aprovados os alunos com mdia maior ou igual 5,0.

11.3 Expresses Lgicas Booleanas:
As operaes lgicas booleanas operam sobre valores booleanos. Operadores booleanos
incluem:
- complemento lgico (!), operador unrio que retorna true se o argumento false ou
retorna false se o argumento true;
- OR lgico booleano (|), operador binrio que retorna true se pelo menos um dos dois
argumentos true;
- OR lgico condicional (||), operador binrio que retorna true se pelo menos um dos dois
argumentos true. Se o primeiro argumento j true, o segundo argumento no nem avaliado;
- AND lgico booleano (&), operador binrio que retorna false se pelo menos um dos dois
argumentos false;
- AND lgico condicional (&&), operador binrio que retorna false se pelo menos um dos
dois argumentos false. Se o primeiro argumento j false, o segundo argumento no nem
avaliado;

52
- XOR booleano (^), operador binrio que retorna true quando os dois argumentos tm
valores lgicos distintos.

11.4 Condies:
Condies permitem realizar testes baseados nas comparaes entre valores numricos.
Operadores condicionais incluem:

- maior (>), retorna true se o primeiro valor for exclusivamente maior que o segundo;
- maior ou igual (>=), retorna true se o primeiro valor for maior que ou igual ao segundo;
- menor (<), retorna true se o primeiro valor for exclusivamente menor que o segundo;
- menor ou igual (<=), retorna true se o primeiro valor for menor que ou igual ao segundo;
- igual (==), retorna true se o primeiro valor for igual ao segundo;
- diferente (!=), retorna true se o primeiro valor no for igual ao segundo.

Assim como C e C++, Java oferece o operador condicional ternrio, ?:. Na expresso b ?
s1 : s2, b booleano (varivel ou expresso). O resultado da expresso ser o resultado da
expresso (ou varivel) s1 se b for verdadeiro, ou o resultado da expresso (ou varivel) s2 se b
for falso.
11.6 Atribuio:
O operador binrio = atribui o valor da expresso do lado direito varivel esquerdado
operador. Os tipos da expresso e da varivel devem ser compatveis.
O operador de atribuio pode ser combinado com operadores aritmticos e lgicos, como
em C e C++. Assim, a expresso

a += b
equivale a
a = a + b

11.5 Retorno:
Mtodos em Java tm sua execuo encerrada de duas maneiras possveis. A primeira
vlida quando um mtodo no tem um valor de retorno (o tipo de retorno void): a execuo
encerrada quando o bloco do corpo do mtodo chega ao final. A segunda alternativa encerra a
execuo do mtodo atravs do comando return:


53
return;
sem valor de retorno.

return expresso;
o valor de retorno o resultado da expresso.

11.6 Operaes Sobre Objetos:
Criao de objeto
Dada uma classe Cls, possvel (em princpio) criar um objeto dessa classe usando o
operador new:

Cls obj = new Cls();
A "funo" direita do operador new um construtor da classe Cls.
Aplicao de mtodos
A classe pode definir mtodos que podem ser aplicados aos seus objetos. A aplicao de
um mtodo meth(), definido em uma classe Cls, a um objeto obj, construdo a partir da
especificao de Cls, se d atravs da construo

obj.meth()
assumindo que a assinatura de meth determinasse que nenhum argumento passado para
o mtodo.

Tomando como exemplo a varivel System.out, o envio de dados para a tela se d atravs
da aplicao do mtodo print (ou println(), para impresso seguida de muana de linha) tendo
como argumento a varivel ou string que se deseja imprimir, como em

System.out.println("Hello");
Verificao de tipo
Dado um objeto obj e uma classe Cls, possvel verificar dinamicamente (durante a
execuo do mtodo) se o objeto pertence ou no classe.
O operador instanceof retorna true se o objeto esquerda do operador da classe
especificada direita do operador. Assim,

obj instanceof Cls
retornaria true.

54

Unidade 12 - Fluxo de Controle de Execuo
12.1 Comandos de Fluxo de Controle de Execuo:
A ordem de execuo normal de comandos em um mtodo Java seqencial. Comandos
de fluxo de controle permitem modificar essa ordem natural de execuo atravs dos mecanismos
de escolha ou de iterao.
12.2 Escolha:
if
A estrutura if permite especificar um comando (ou bloco de comandos) que deve apenas
ser executado quando uma determinada condio for satisfeita:

if (condio) {
bloco_comandos
}

Quando o bloco de comandos composto por uma nica expresso, as chaves que
delimitam o corpo do bloco podem ser omitidas:

if (condio)
expresso;

Embora a indentao do cdigo no seja mandatria, uma recomendao de boa prtica
de programao.
if else
if ... else permite expressar duas alternativas de execuo, uma para o caso da condio ser
verdadeira e outra para o caso da condio ser falsa
:
if (condio) {
bloco_comandos_caso_verdade
}
else {
bloco_comandos_caso_falso
}
switch

55
switch ... case tambm um comando que expressa alternativas de execuo, mas onde as
condies esto restritas comparao de uma varivel inteira com valores constantes:

switch (varivel) {
case valor1:
bloco_comandos
break;
case valor2:
bloco_comandos
break;
...
case valorn:
bloco_comandos
break;
default:
bloco_comandos
}

12.3 Iterao:
while
while permite expressar iteraes que devem ser executadas se e enquanto uma condio for
verdadeira:

while (condio) {
bloco_comandos
}
do while
do ... while tambm permite expressar iteraes, mas neste caso pelo menos uma execuo
do bloco de comandos garantida:

do {
bloco_comandos
} while (condio);
for
O comando for permite expressar iteraes combinando uma expresso de inicializao, um
teste de condio e uma expresso de incremento:

for (inicializao; condio; incremento) {
bloco_comandos
}


56
Embora Java no suporte o operador "," de C/C++, no comando for mltiplas expresses de
inicializao e de incremento podem ser separadas por vrgulas.
break
continue e break so comandos que permitem expressar a quebra de um fluxo de execuo.
break j foi utilizado juntamente com switch para delimitar bloco de comandos de cada case. No
corpo de uma iterao, a ocorrncia do comando break interrompe a iterao, passando o controle para o
prximo comando aps o comando de iterao.
continue tambm interrompe a execuo da iterao, mas apenas da iterao corrente. Aps um
continue, a condio de iterao reavaliada e, se for verdadeira, o comando de iterao continua
executando.
Em situaes onde h diversos comandos de iterao aninhados, os comandos break e
continue transferem o comando de execuo para o ponto imediatamente aps o bloco onde ocorrem.
Se for necessrio especificar transferncia para o fim de outro bloco de iterao, os comandos break e
continue rotulados podem ser utilizados:
label: {
for (...; ...; ...) {
...
while (...) {
...
if (...)
break label;
...
}
...
}
...
}


57
Unidade 13 - Arranjos em Java
13.1 Arranjos em Java:
Arranjos podem ser definidos para literais ou para objetos
Assim como objetos, so criados com o comando new:

Criar referncia para um arranjo de inteiros
int array1[];

Criar espao para armazenar 100 inteiros em um arranjo array1:
array1 = new int[100];

Combinando declarao e criao de espao:
int array1[] = new int[100];

Arranjos podem ser criados com a especificao de algum contedo:
int array2[] = {2, 4, 5, 7, 9, 11, 13};

O acesso a elementos individuais de um arranjo especificado atravs de um ndice inteiro. O
elemento inicial, assim como em C e C++, tem ndice 0. Assim, do exemplo acima,

int x = array2[3];
faz com que a varivel x receba o valor 7, o contedo da quarta posio.

O acesso a elementos do arranjo alm do ltimo ndice permitido -- por exemplo, a array2[7] -
- gera um erro em tempo de execuo (uma exceo).
A dimenso de um arranjo pode ser obtida atravs do campo length presente em todos os
arranjos. Assim, a expresso

int y = array2.length;
Faz com que y receba o valor 7, o nmero de elementos no arranjo..

58

Unidade 14 - Strings
14.1 Strings:
A classe java.lang.String uma seqncia de caracteres imutvel.
Representa uma cadeia de caracteres Unicode
Otimizada para ser lida, mas no alterada
Nenhum mtodo de String modifica o objeto armazenado
H duas formas de criar Strings
Atravs de construtores, metodos, fontes externas, etc:

String s1 = new String("Texto");
String s2 = objeto.getText(); // mtodo de API
String s3 = coisa.toString();
Atravs de atribuio de um literal
String s3 = "Texto";

Strings criados atravs de literais so automaticamente armazenadas em um pool para possvel reuso;
Mesmo objeto reutilizado: comparao de Strings iguais criados atravs de literais revelam que
se tratam do mesmo objeto;
Pool de strings
Como Strings so objetos imutveis, podem ser reusados
Strings iguais criados atravs de literais so o mesmo objeto
String um = "Um";
String dois = "Um";
if (um == dois)
System.out.println("um e dois so um!");
Mas Strings criados de outras formas no so
String tres = new String("Um");
if (um != tres)
System.out.println("um nao trs!");
Todos os blocos
de texto abaixo
so impressos


59
Literais so automaticamente guardados no pool. Outros Strings podem ser acrescentados no pool usando
intern():
quatro = tres.intern();
if (um == quatro)
System.out.println("quatro um!");
Principais Mtodos de String
Mtodos que criam novos Strings:
String concat(String s): retorna a concatenao do String atual com outro passado como
parmetro
String replace(char old, char new): troca todas as ocorrncias de um caractere por outro
String substring(int start, int end): retorna parte do String incluindo a posio inicial e exclundo a
final
String toUpperCase() e String toLowerCase(): retorna o String em caixa alta e caixa baixa

respectivamente

Mtodos para pesquisa
boolean endsWith(String) e startsWith(String)
int indexOf(String), int indexOf(String, int offset): retorna posio
char charAt(int posio): retorna caractere em posio
Outros mtodos
char[] toCharArray(): retorna o vetor de char correspondente ao String
int length(): retorna o comprimento do String

14.2 StringBuffer:
A classe StringBuffer uma seqncia de caracteres mutvel
Representa uma cadeia de caracteres Unicode
Otimizada para ser alterada, mas no lida
StringBuffers podem ser criados atravs de seus construtores
StringBuffer buffer1 = new StringBuffer();
StringBuffer buffer2 = new StringBuffer("Texto inicial");
StringBuffer buffer3 = new StringBuffer(40);
Mtodos de StringBuffer operam sobre o prprio objeto

60
StringBuffer append(String s): adiciona texto no final
StringBuffer insert(int posio, String s): insere na posio
void setCharAt(int posio, char c): substitui na posio
String toString(): transforma o buffer em String para que possa ser lido
Exemplo:
StringBuffer buffer = new StringBuffer("H");
buffer.append("e").append("l").append("l").append("o");
System.out.println(buffer.toString());
Quando usar String e StringBuffer
Use String para manipular com valores constantes
Textos carregados de fora da aplicao
Valores literais
Textos em geral que no sero modificados intensivamente
Use StringBuffer para alterar textos
Acrescentar, concatenar, inserir, etc.
Prefira usar StringBuffer para construir Strings
Concatenao de strings usando "+" extremamente cara: um novo objeto criado em cada fase
da compilao apenas para ser descartado em seguida
Use StringBuffer.append() e, no final, transforme o resultado em String

14.3 java.util.StringTokenizer:
Classe utilitria que ajuda a dividir texto em tokens
Recebe um String e uma lista de tokens
Usa um Enumeration para iterar entre os elementos
Exemplo:
String regStr = "Primeiro,Segundo,Terceiro,Quarto";
StringTokenizer tokens =
new StringTokenizer(regStr, ",");
String[] registros = null;
List regList = new ArrayList();
while (tokens.hasMoreTokens()) {
String item = tokens.nextToken();
regList.add(item);

61
}
int size = regList.size();
registros = (String[])regList.toArray(new String[size]);


62

Unidade 15 - Pacote
15.1 Pacote
No desenvolvimento de pequenas atividades ou aplicaes, vivel manter o cdigo e
suas classes no diretrio corrente. No entanto, para grandes aplicaes preciso organizar as
classes de maneira a evitar problemas com nomes duplicados de classes, e localizar o cdigo da
classe de forma eficiente.
Em Java, a soluo para esse problema est na organizao de classes e interfaces em
pacotes. Essencialmente, uma classe Xyz que pertence a um pacote nome.do.pacote tem o nome
completo nome.do.pacote.Xyz e o compilador Java espera encontrar o arquivo Xyz.class em um
subdiretrio nome/do/pacote. Este, por sua vez, deve estar localizado sob um dos diretrios
especificados na varivel de ambiente CLASSPATH.

63

Unidade 16 - Ncleo de Funcionalidades

16.1 Ncleo de Funcionalidades
Tudo em Java est organizado em classes. Algumas classes so desenvolvidas pelo
programador da aplicao e outras j esto disponveis atravs do ncleo de funcionalidades da
plataforma Java.
As classes que compem o ncleo de funcionalidades Java esto organizadas em pacotes.
Um package Java um mecanismo para agrupar classes de finalidades afins ou de uma mesma
aplicao. Alm de facilitar a organizao conceitual das classes, o mecanismo de pacotes permite
localizar cada classe necessria durante a execuo da aplicao. No entanto, a principal
funcionalidade de um pacote Java evitar a exploso do espao de nome, ou seja, classes com o
mesmo nome em pacotes diferentes podem ser diferenciadas pelo nome completo, pacote.classe.
Entre os principais pacotes oferecidos como parte do ncleo Java esto:
java.lang
java.util
java.io
java.awt
java.applet
java.net

Observe que esses nomes seguem a conveno Java, pela qual nomes de pacotes (assim
como nomes de mtodos) so grafados em letras minsculas, enquanto nomes de classes tm a
primeira letra (de cada palavra, no caso de nomes compostos) grafada com letra maiscula.
Alm dessas funcionalidades bsicas, h tambm APIs definidas para propsitos mais
especficos compondo a extenso padronizada ao ncleo Java.

16.2 java.lang:
O pacote java.lang contm as classes que constituem recursos bsicos da linguagem,
necessrios execuo de qualquer programa Java.
Entre as classes desse pacote destacam-se:
Object
expressa o conjunto de funcionalidades comuns a todos os objetos Java;

64
Class e ClassLoader
representa classes Java e o mecanismo para carreg-las dinamicamente;
String e StringBuffer
permite a representao e a manipulao de strings, fixos ou modificveis;
Math
contm a definio de mtodos para clculo de funes matemticas (trigonomtricas,
logartimicas, exponenciais, etc) e de constantes, tais como Math.E e Math.PI;
Boolean, Character, Byte, Short, Integer, Long, Float, Double
so classes wrappers, permitindo a manipulao de valores dos tipos literais da linguagem
como se fossem objetos;
System, Runtime e Process
so classes que permitem interao da aplicao com o ambiente de execuo;
Thread, Runnable, ThreadGroup
classes que do suporte execuo de mltiplas linhas de execuo;
Throwable, Error e Exception
classes que permitem a definio e manipulao de situaes de erros e condies
inesperadas de execuo, tais como OutOfMemoryError, ArithmeticException (por exemplo,
diviso inteira por zero) e ArrayIndexOutOfBoundsException (acesso a elemento de arranjo alm
da ltima posio ou antes da primeira posio).
Sub-pacotes relacionados incluem java.lang.ref, de referncias a objetos, e o pacote
java.lang.reflect, que incorpora funcionalidades para permitir a manipulao do contedo de
classes, ou seja, identificao de seus mtodos e campos. Observe que funes matemticas so
definidas em java.lang.Math, no em classes do pacote java.math, que define funcionalidades para
manipular nmeros inteiros e reais de preciso arbitrria.

16.3 System
A classe System oferece algumas funcionalidades bsicas de interface com o sistema no
qual a mquina virtual Java est executando. A documentao desta classe descreve:
Entre as facilidades fornecidas pela classe System esto a entrada padro (in), a sada
padro (out), e os erros de sada de streams (err); alcance s "propriedades externamente
definidas"; meios de carregar arquivos e bibliotecas; e um mtodo para copiar rapidamente uma
parcela de um array.
Entre as facilidades oferecidas esto o conjunto de variveis correspondentes aos
dispositivos padres de entrada e sada, um mtodo de classe para obter uma leitura de relgio
com preciso de milissegundos, long CurrentTimeMillis(), e um mtodo de classe para encerrar a
execuo da mquina virtual Java, void exit(int status), onde por conveno um valor de status
diferente de zero indica alguma situao anormal de trmino da execuo.

65
Uma classe intimamente relacionada a System a classe Runtime, para a qual existe um
nico objeto representando o ambiente no qual a mquina virtual Java est executando. Atravs
desta classe possvel disparar novos processos atravs do mtodo exec().

16.4 Utilitrios de Propsito Genrico:
O pacote java.util oferece, alm de estruturas de dados, algumas classes utilitrias de
propsito genrico.

16.5 Date
Permite representar uma data e hora usando uma representao interna em milissegundos
decorridos desde a meia-noite (GMT) de 01 de janeiro de 1970. O construtor default cria um objeto
com a data e hora corrente. Para obter o valor associado a esse objeto, o mtodo long getTime()
utilizado.

16.6 Random
Implementa um gerador de nmeros pseudo-aleatrios, com mtodos double nextDouble()
e float nextFloat() gerando valores uniformemente distribudos entre 0,0 e 1,0; long nextLong() e int
nextInt() geram valores inteiros uniformemente distribudos ao longo da faixa de valores possveis.
O mtodo double nextGaussian() retorna um valor com distribuio normal (mdia 0, desvio
padro 1).
A semente do gerador de nmeros pseudo-aleatrios obtida a partir do tempo corrente.
Outro valor pode ser especificado no construtor ou com o mtodo setSeed() -- para um mesmo
valor inicial, uma mesma seqncia de nmeros ser gerada.


66
Unidade 17 - Exerccios para programao
orientada a objetos
1) Faa um programa em Java que leia 3 nmeros e calcule a sua mdia.
O programa deve ser modularizado. Utilize uma funo para calcular e retornar a mdia dos
nmeros. Essa funo deve receber os trs nmeros como parmetro.

2) Crie um programa em Java que leia o raio de uma esfera (do tipo real) e passe esse valor para
a funo volumeEsfera. Essa funo deve calcular o volume da esfera na tela e retornar o seu
valor.
Para o clculo do volume deve ser usada a seguinte frmula:
Volume = (4.0 / 3.0) * PI * raio3

3) Faa um programa em Java em que o usurio entre com um valor de base e um valor de
expoente. O programa deve calcular a potncia. O programa deve ser modularizado. Voc deve
decidir se a subrotina ser um procedimento ou uma funo.

4) Cite exemplos de objetos do mundo real. Identifique atributos e comportamentos para esses
objetos. Agrupe esses objetos nas suas respectivas classes. Faa isso usando a notao UML
para classes e objetos.

5) Quando um mtodo construtor chamado?

6) Qual a funo de um mtodo modificador numa classe? E de um mtodo recuperador?

7) Analise o seguinte trecho de cdigo e identifique se existe algum erro. Caso exista, explique
qual o erro e como solucion-lo.

//classe Retangulo
public class Retngulo{
private double base, altura;
//mtodos
}


67
//classe calcula que cria objeto retangulo
public class CalculaRetangulo{
public static void main(String args[]){
Retangulo r = new Retangulo()
r.base = 5.0;
r.altura = 6.0
}
}

8) A seguinte classe tem dois mtodos static. Programe outra classe chamada UsaCalculos.java e
demonstre como esses mtodos static podem ser chamados dessa classe.

public class Calculos{
public static int potencia(int base, int exp){
int pote=1;
for (int i=1;i<=exp;i++)
pote = pote * base;
return pote;
}
public static int fatorial(int nu){
int fat=1;
for (int i=1;i<=nu;i++)
fat = fat * nu;
return fat;
}
}


68

Java PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Java PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Linguagem de Programao I

UNIDADE 1 - PARADIGMA DE PROGRAMAO ORIENTADA A OBJETO......................................................................... 3

Você também pode gostar