Você está na página 1de 25

Bsicos da Orientao a Objetos em Java

1

Artigo de Je lriesen, publicado originalmente na reista Jaa\orld ,www.jaaworld.com,,
Copyright Itworld.com, Inc., Noembro de 2000. Reimpresso, adaptado e traduzido com permissao do autor.
,www.jaaworld.com,jaaworld,jw-04-2001,jw-0406-jaa101_p.html,

1raduzido e adaptado por Leandro Krug Wives
Parte I: Aprenda a declarar classes e criar objetos
Lxistem, basicamente, duas metodologias de desenolimento de sotware: a Programaao Lstruturada ,PL, e a
Programaao Orientada a Objetos ,POO,.
Na primeira, o objetio consiste em separar os dados da uncionalidade do programa. Neste caso, as entidades
sao representadas de orma tal que satisaam as restrioes da linguagem de programaao utilizada. Isso acaba
gerando programas que sao diceis de manter e compreender, principalmente se eles orem muito grandes.
Na segunda, a linguagem de programaao que tem de satisazer as restrioes e requisitos das entidades. Isso
permite a construao de modelos mais realsticos do mundo, e, portanto, mais aceis de serem mantidos e
compreendidos.
Vamos tomar como exemplo a representaao de um carro. Vamos descobrir que cada metodologia modela de
orma dierente esse carro.
Na PL, por exemplo, um carro representado por um conjunto de unoes ,trechos de cdigo, responsaeis por
ligar, rear, estacionar, acelerar e assim por diante. Um conjunto separado de ariaeis deine a cor do carro, seu
modelo, abricante e demais caractersticas. Voc dee entao inicializar ,atribuir alores, as ariaeis do carro e
chamar algumas das unoes para manipular estas ariaeis para que o carro uncione.
Ja na POO, o carro isto como uma integraao de seus comportamentos ,suas unoes, e atributos ,ariaeis,
que mantm o estado atual do carro. A integraao destes atributos e comportamentos resulta em um objeto. A
criaao deste objeto simples e az com que ele seja inicializado ao mesmo tempo sem comandos adicionais.
Neste caso, um programa orientado a objetos pensa em objetos e nao em unoes e ariaeis separadas e soltas
,na PL o programador que sabe quais unoes e quais ariaeis pertencem ao carro, na POO, o prprio
programa controla isso para o programador,.
A integraao destes atributos e comportamentos em objetos chamada de "encapsulamento". O encapsulamento
tambm permite com que as inormaoes dos objetos iquem escondidas, limitando o acesso a ariaeis e
unoes que nao necessitam ser manipuladas ou acessadas ora do objeto.
A orientaao a objetos ja existe ha 15 anos, porm, eram poucas as linguagens que suportaam-na corretamente e
por completo. Atualmente existem linguagens, tais como o Jaa, que suportam completamente a orientaao a
objetos. Deido a isso, todo programa escrito em Jaa necessita da presena de pelo menos uma classe.
Mas o que e uma classe? Bem, os objetos nao surgem do nada. Assim como um mestre de obras necessita de
um esquema de engenharia para realizar a construao de um prdio ,a planta do prdio`,, um programa
necessita de uma classe para criar objetos baseados nesta classe. A classe como se osse o esquema ,a receita,
que indica como criar objetos do seu tipo. Lsse esquema ou receita indica quais sao os comportamentos, as
caractersticas e o estado ,alor, destas caractersticas nos objetos criados a partir dela.
Declarando Classes
A classe a planta ou esquema ,em ormato de cdigo Jaa, que indica como os objetos sao criados, quais os
seus comportamentos e ariaeis de estado. Para criar declarar uma classe oc dee utilizar a seguinte sintaxe
2
:
[ palavra-chave ] class nome_da_classe
{
// comportamentos e variveis so declarados e descritos entre o { e o }
}

1
By Je lriesen. It was originally published by Jaa\orld ,www.jaaworld.com,, copyright I1world.com, Inc., Noember 2000.
Reprinted with permission.
2
Preste atenao na conenao de sintaxe utilizada: os itens entre colchetes sao opcionais e, geralmente, deem ser substitudos por
palaras-chae detalhadas em seguida ao cdigo, os itens entre apstroes sao obrigatrios e correspondem aos comandos ou estruturas
da linguagem, ja os itens em italico sao obrigatrios, mas oc pode utilizar qualquer identiicador ,palara, desde que nao seja reserada,
para representa-los.
Logo, para declarar uma classe, coloque a palara class seguida de um identiicador ,representado por
vove_aa_cta..e, que ira serir de nome para a classe. O identiicador pode ser qualquer palara, com exceao de
alguma palara reserada da linguagem ,ou seja, algum comando,. Por exemplo, class Conta introduz a
declaraao de uma noa classe onde Conta o nome da classe. Note que, por conenao, o nome de uma classe
inicia sempre com uma letra maiscula.
A palavra-chave opcional ,pois esta entre colchetes,, e pode ser qualquer uma das seguintes: public',
abstract', public abstract' ou final'.
Utilize a palavra-chave public` ,sem as apstroes, para criar um nome de classe que possa ser utilizado em
qualquer outra classe de qualquer programa ou pacote
3
. Se oc nao colocar public na rente de uma declaraao
de classe, ela s podera ser utilizada dentro do cdigo de programa ou pacote atual. L importante salientar que
oc pode declarar mais de uma classe por arquio, porm, somente uma delas podera ser public ,pblica,.
Neste caso, o nome do arquio do cdigo-onte deera ser o mesmo da classe pblica.
Lxemplo:
public class MinhaClasse
{ }
Neste caso, o nome do arquio onde MinhaClasse oi deinida dee se chamar MinhaClasse.java. Declarar
essa classe ,pblica, em outro arquio nao permitido e dee gerar um erro do compilador. Note que o Jaa
considera dierentes letras maisculas e minsculas. Logo, o nome da classe e o nome do arquio deem ser
exatamente iguais ,em termos de letras maisculas e minsculas,. Isso signiica que o nome do arquio dee ser
escrito com o M` maisculo ,de Minha, e C` maisculo ,de Classe,. As demais letras deem ser minsculas.
Utilize a palavra-chave abstract' para indicar que a classe corresponde a uma classe abstrata. Classes abstratas
nao podem ser utilizadas para a criaao de objetos. Llas s serem como classes-pai`, para que classes-ilhas`
sejam criadas a partir delas.
Utilize a palavra-chave final' para declarar uma classe inal. Classes inais nao podem ser utilizadas como
classes-pai, impedindo com que classes-ilhas sejam criadas a partir delas ,e herdem seu comportamento e
estados,.
Lssas palaras-chae podem ser utilizadas em qualquer ordem. Voc s nao pode especiicar uma classe como
sendo abstrata e inal ao mesmo tempo, pois isso nao az sentido, ja que classes abstratas s serem para a
criaao de classes-ilhas e classes inais s uncionam como classes ilhas.
Cada classe possui um corpo` onde oc declara os comportamentos ,mtodos, e ariaeis de estado ,atributos
ou campos,. O corpo comea com o caractere { e termina com o caractere ] `.
Criando Objetos
Um objeto uma instancia de uma classe. Para criar um objeto, utilize a seguinte sintaxe:
new construtor
O comando new ,que signiica noo em Ingls,, tambm conhecido como operador de criaao, cria um noo
objeto, alocando memria para o objeto e inicializando essa memria para alores deault ,padrao,. O comando
new necessita de um operando: o construtor, que o nome de um mtodo especial que constri o objeto. Uma
ez construdo, o objeto dee ser atribudo a uma ariael, para que possa ser utilizado e reerenciado no uturo.
Preste atenao ao exemplo seguinte:
class Pessoa{
}
class ProgramaExemplo{
public static void main(Strings parametros[]){
Pessoa umaPessoaQualquer; // declara uma varivel que pode armazenar objetos
// do tipo Pessoa (definido na classe anterior)
umaPessoaQualquer = new Pessoa(); // cria uma nova pessoa e coloca-a na
// varivel umaPessoaQualquer
}
}

3
Pacote o nome dado a uma biblioteca de classes desenvolvidas na linguagem Java.
No exemplo anterior oi deinida uma classe chamada Pessoa e aps, no programa principal, oi criada uma
ariael chamada umaPessoaQualquer para receber um objeto do tipo pessoa ,note que o tipo da ariael
Pessoa, pois a ariael declarada de orma similar a declaraao de ariaeis do tipo int qualquer outro tipo
natural da linguagem,. Aps, um noo objeto do tipo Pessoa criado, atras do comando new Pessoa(). Lsse
objeto colocado na ariael umaPessoaQualquer atras do comando de atribuiao ,sinal de igual,.
Lm Jaa, oc pode criar e atribuir um noo objeto a uma ariael, simultaneamente. Basta colocar tudo na
mesma linha da seguinte orma:
Pessoa umaPessoaQualquer = new Pessoa();
Destruindo objetos
A linguagem Jaa assume a responsabilidade de destruir qualquer objeto que oc tenha criado e nao esteja mais
usando. Lla az isso atras de um processo especial chamado coletor de lixo ,garbage collector,, que
executado em interalos regulares, examinando cada objeto para er se ele ainda reerenciado por alguma
ariael. Caso o objeto nao seja utilizado ao menos por uma ariael, ele destrudo e sua memria liberada.
Parte II: Declarando e acessando atributos e mtodos
Lm Jaa, as ariaeis podem ser diididas em trs categorias: atributos ,tambm chamados de campos,,
parmetros e variveis locais. No incio desta seao sera explorado o primeiro tipo - o atributo. Os demais
tipos serao discutidos em conjunto com os mtodos, apresentados em seguida.
Declarando atributos
Um atributo ou campo uma ariael declarada no corpo de uma classe. Lle sere para armazenar o estado de
um objeto ,e neste caso chamado de atributo de instancia, ou o estado de uma classe ,atributo de classe,. A
sintaxe de declaraao de um atributo a seguinte:
[ ( public | private | protected ) ]
[ ( final | volatile ) ]
[ static ] [ transient ]
tipo_de_dado nome_do_atributo [ = expresso ] ;
A declaraao de um atributo especiica o seu nome, seu tipo ,que pode ser um dos tipos naturais, tais como int,
char, double, float, ou o nome de uma classe, como String ou Pessoa,, uma expressao opcional ,que inicializa
o atributo,, especiicadores de acesso e modiicadores. Voc pode dar qualquer nome ao atributo, desde que este
nome nao corresponda a uma palara-reserada da linguagem. Por questoes de padronizaao, o nome de um
atributo sempre comea com uma letra minscula. Considere o exemplo:
class Empregado{
String nome; // o nome do empregado
double salario; // o salrio do empregado
int idCargo // identificador do cdigo da funo que ele exerce
}
Neste exemplo, a classe chamada Lmpregado declara trs atributos: nome, salrio e idCargo ,identiicador do
cargo,. Assim, quando oc cria um objeto do tipo Lmpregado, o campo nome mantm uma reerncia para
uma string contendo o nome do empregado. O campo salario armazena o seu salario, e o campo idCargo
armazena um nmero que identiica a categoria ou unao que ele exerce na empresa.
Especificadores de acesso
Opcionalmente, oc pode utilizar uma palara-chae modiicadora de acesso ao declarar um atributo. As
palaras-chae modiicadoras de acesso sao as seguintes: public, private ou protected. O modiicador de acesso
determina quao acessel o atributo para o cdigo de outras classes do seu programa. Lssa acessibilidade pode
ariar de completamente inacessel at completamente acessel.
Se oc nao especiicar um modiicador de acesso, o Jaa assume o acesso padrao, que permite com que o
campo seja acessel a classe no qual ele oi declarado e tambm a todas as classes existentes no mesmo arquio
,cdigo-onte, ou pacote ,biblioteca de classes, da classe que o declarou.
Se oc declarar um atributo como sendo priado ,private,, somente o cdigo contido na sua classe pode
acessa-lo. Lste atributo permanece escondido` para qualquer outra classe, mesmo para as classes-ilhas da
classe ao qual oi declarado ,neste caso, elas conseguem herda-lo, mas nao conseguem manipula-lo,.
Se oc declarar um atributo como sendo pblico ,public,, o cdigo contido na sua classe e em todas as outras
classes em qualquer pacote ,biblioteca, pode acessa-lo.
Um atributo protegido ,protected, possui o nel de acesso padrao, porm, as sub-classes ,classes-ilhas, da
classe para o qual oi declarado tambm podem utiliza-lo.
class Empregado{
public String nome; // seu nome (visvel qualquer classe)
private double salario; // seu salrio (inacessvel fora da classe)
protected int idCargo // cdigo do cargo (acessibilidade padro)
}
Mas, afinal, para que servem os modificadores de tipo Bem, eles sao utilizados para implementar o
conceito de esconderijo ou encoberta de informao ,inormation hiding, e encapsulamento. Para
compreender melhor, amos azer uma analogia: suponha que oc crie classes chamadas de Corpo, Olho,
Corao e Pulmo para modelar o corpo humano, os olhos, o coraao e os pulmoes de uma pessoa. A classe
Corpo declara atributos para reerenciar os olhos, o coraao e os pulmoes, como demonstrado no exemplo
seguinte:
public class Corpo{
public Olho olhoEsquerdo,olhoDireito;
private Corao corao;
private Pulmo pulmoEsquerdo, pulmoDireito;
}
Os atributos olhoLsquerdo e olhoDireito sao pblicos porque os olhos das pessoas sao iseis para qualquer
obserador. Ja o corao, o pulmoLsquerdo e o pulmoDireito sao priados porque os rgaos que estes
atributos representam estao escondidos dentro do corpo de uma pessoa. Se eles tiessem sido declarados
pblicos, uma pessoa teria seu coraao e pulmoes a ista... Muito estranho, oc nao acha
Modificadores
Voc pode utilizar, opcionalmente, uma palara-chae modiicadora: final ou volatile e,ou static e,ou
transient.
Se oc utilizar o modiicador final na declaraao de um atributo o compilador assume que esse campo uma
constante ,uma ariael somente de leitura que nao pode ser modiicada,. Neste caso o compilador az ajustes e
otimizaoes internas no cdigo do programa, ja que ele sabe que esta ariael nao sera modiicada em momento
algum da execuao do programa.
O exemplo seguinte declara trs constantes. Note que as constantes sao obrigatoriamente inicializadas na sua
declaraao. Alm disso, todas as letras do nome de uma constante sao maisculas, por conenao. Assim, oc
pode rapidamente saber se esta trabalhando com uma ariael comum ou com uma constante ,ja que as
constantes possuem todas as suas letras em maisculo e as ariaeis comuns nao,.
class Empregado{
final int FAXINEIRO = 1;
final int PROGRAMADOR = 2;
final int GERENTE = 3;
int idCargo = PROGRAMADOR;
}
Se oc declara um atributo utilizando o modiicador volatile ,olatil,, arias 1hreads ,linhas ou processos de
execuao, podem acessar esse atributo. Neste caso, o prprio compilador realiza ajustes para que esse atributo
seja acessado corretamente por cada uma delas, sem que ocorram problemas.
Se o atributo or declarado como sendo static ,estatico, todos os objetos compartilham ,utilizam, a mesma cpia
da ariael. Se um dos objetos modiica esse atributo todos os outros objetos enxergam essa mesma
modiicaao. Neste caso, o atributo considerado um atributo de classe e nao de objeto. Se oc nao especiicar
o modiicador static cada objeto ai possuir a sua cpia especica deste atributo.
linalmente o modiicador transient indica que o atributo nao sera utilizado em uma operaao de serializaao do
objeto ,salamento em arquio ou enio de um objeto para outro computador ou programa,. Lsse processo nao
sera abordado aqui, logo, para maiores inormaoes, consulte a \LB ou um liro de Jaa.
Atributos de objetos (de instncia)
Um atributo de objeto ,tambm conhecido por atributo de instancia, uma ariael declarada sem o
modiicador static. Os atributos de instancia pertencem ,sao associados, aos objetos e nao as classes. Quando
um atributo de objeto modiicado, somente o objeto a que ele pertence enxerga a alteraao ,isso porque cada
objeto possui o seu,. Um atributo de objeto ,ou instancia, criado quando o objeto criado ,comando new, e
destrudo quando o objeto a que pertence or destrudo.
Veja o exemplo:
class Empregado{
public int cargo;
public void contrataComoProgramador(void){
cargo = 2; // Dois o cdigo de programador
}
}
Para acessar o atributo de objeto em um mtodo pertencente a mesma classe da qual o objeto oi criado ,ou seja,
um mtodo tambm pertencente ao objeto,, simplesmente especiique o nome do atributo ,o nome da ariael,.
No exemplo anterior, o atributo cargo acessado simplesmente pela utilizaao do seu nome ,eja a linha
griada,.
Se oc quiser acessar um atributo em um mtodo de outro objeto, oc ai necessitar de uma reerncia ,uma
ariael, ao objeto ao qual o atributo pertence. Utilize essa ariael como preixo do atributo, seguido do
caractere .` ,ponto,. Aps, especiique o atributo desejado:
class Empregado{
public int cargo;
public void contrataComoProgramador(void){
cargo = 2; // Dois o cdigo de programador
}
}
class ProgramaExemplo{ // Esse programa utiliza a classe Empregado (anterior)
public static void main(String parametros[]){
Empregado empregado = new Empregado(); // cria um objeto empregado

empregado.cargo = 2; // muda o atributo cargo de um empregado
}
}
Note a dierena: os mtodos da classe Lmpregado podem utilizar o atributo cargo diretamente, ja os mtodos
da classe ProgramaLxemplo deem sempre criar um objeto do tipo Lmpregado e utilizar esse objeto para ter
acesso ao atributo ,empregado.cargo,. Isso sere para quando oc tier arios objetos ,arios empregados, e
necessitar alterar o atributo de um deles. Imagine que seu programa tenha quatro ariaeis do tipo empregado e
um deles tenha mudado de cargo. Lssa mudana muito acil de ser eita, basta oc inormar qual objeto ,qual
empregado, que dee sorer a alteraao, seguido do seu atributo cargo, e pronto:
class ProgramaExemplo2{ // Esse programa utiliza a classe Empregado (anterior)
public static void main(String parametros[]){
Empregado empregado1 = new Empregado();
Empregado empregado2 = new Empregado();
Empregado empregado3 = new Empregado();
Empregado empregado4 = new Empregado();

empregado1.cargo = 3; // muda o cargo do empregado1 para gerente
empregado2.cargo = 1; // muda o cargo do empregado2 para faxineiro
empregado3.cargo = 2; // muda o cargo do empregado3 para programador
empregado4.cargo = 2; // muda o cargo do empregado4 para programador
}
}
Quando a Maquina Virtual Jaa ,MVJ ou Virtual Jaa Machine - JVM, que o computador irtual onde um
programa em Jaa executado, cria um objeto, ela aloca memria para todos os atributos do objeto e zera essa
memria, inicializando-a. Lsse alor inicial depende do tipo do atributo. Para tipos naturais numericos o alor
inicial zero ,0 ou 0.0,. Os alores booleanos sao inicializados em false ,also,. Para os demais tipos de
atributos ,reerncias construdas a partir de outras classes, o alor inicial NULL ,nulo,.
Atributos de classes
Um atributo de classe um atributo declarado com o modiicador static. Os atributos de classe sao associados
com a classe e nao com os objetos ,ou instancias, criados a partir dela. Isso signiica que quando um atributo de
classe modiicado, todos os objetos criados a partir da mesma classe enxergam a alteraao. Veja o exemplo:
class Empregado{
static int numeroDeEmpregados; // atributo de classe
public int cargo; // atributo de instncia (objeto)
}
class ProgramaExemplo3 {
public static void main(String parametros[]){
Empregado empregado1 = new Empregado(); // cria um objeto empregado
empregado1.numeroDeEmpregados = 1;
empregado1.cargo = 2;
Empregado empregado2 = new Empregado(); // cria um novo empregado
empregado2.cargo = 3;
empregado2.numeroDeEmpregados = 2; // modifica a varivel de classe
System.out.println(empregado1.cargo); // imprime o cargo do empregado1
System.out.println(empregado1.numeroDeEmpregados); // vai mostrar 2
// porque a varivel numeroDeEmpregados da classe Empregado (inteira)
// e no somente do empregado1 ou do empregado2
System.out.println(empregado2.cargo); // imprime o cargo do empregado2
}
}
No exemplo anterior, quando o atributo numeroDeLmpregados modiicado em um dos objetos, todos sorem
a mesma alteraao, pois, dierente do atributo de objeto ,onde cada um possui uma cpia dierente do atributo,,
ele pertence a classe e nao ao objeto.
Similarmente, oc pode deinir mtodos de classe e mtodos de objeto. A unao main de um programa um
exemplo. Note que ela sempre deinida como um mtodo de classe, pois possui o modiicador static: public
static oid main,String parametros||,. Saiba mais sobre metodos na seo seguinte: Declarando metodos.
Observao: Atributos de classes so as coisas mais prximas variveis globais que a linguagem Java
oferece.
Constantes
Uma constante uma ariael que s permite a leitura do seu contedo ,alor,. Uma ez deinida, uma
constante nao pode mais ser modiicada. As constantes sao declaradas atras da palara-chae final. As
constantes tambm podem ser de classe ou de objeto. Por questoes de perormance, sempre crie constantes de
classe, como no exemplo:
class ProgramaExemplo4 {
final static TOTAL = 10;
public static void main(String parametros[]){
int contador = 0;
while(contador < TOTAL) contador++;
}
}
Lsse exemplo cria uma constante chamada 1O1AL e inicializa-a com o alor 10. O alor de 1O1AL nao pode
ser alterado em momento algum do programa. Caso oc tente altera-lo o compilador Jaa acusara um erro.
Note que a constante oi deinida com todas as suas letras em formato maisculo. Apesar de nao ser
obrigatrio azer isso, por questoes de padronizaao as constantes sao escritas com letras maisculas. Deste
modo, oc pode identiicar no seu programa quais ariaeis correspondem a atributos comuns e quais
correspondem a constantes.
Utilize constantes pelas seguintes razoes:
1, Constantes acilitam a leitura e o entendimento do cdigo-onte, pois azem mais sentido do que um
nmero sem explicaao ,1AMANlO_DO_VL1OR, por exemplo, mais signiicatio do que o
nmero 20,,
2, L mais acil modiicar o alor inicial de uma constante do que trocar todas as ocorrncias de
determinado alor no cdigo-onte.
Agora que oc ja aprendeu a declarar atributos, oc ai precisar aprender a declarar e utilizar mtodos.
Declarando mtodos
A linguagem Jaa utiliza o termo metodo para se reerir a trechos de cdigo que sao associados a classes. Se os
atributos serem para manter ou armazenar o estado ou o alor de um objeto, os mtodos serem para descreer
os comportamentos de um objeto ou classe. Um mtodo muito similar a uma unao em linguagem C. A maior
dierena que os mtodos da linguagem Jaa sao declarados completamente dentro de uma classe.
Para declarar um mtodo utilize a seguinte sintaxe:
[ ( public | private | protected ) ]
( [ abstract ] | [ final ] [ static ] [ native ] [synchronized ] )
tipo_de_retorno nome_do_mtodo ( [ lista_de_parmetros ] )
corpo_do_mtodo
A declaraao de um mtodo consiste de uma assinatura do mtodo seguida por seu corpo ou trecho de
cdigo. A assinatura do metodo especiica o seu nome, tipo de retorno, lista de parmetros,
especificadores de acesso, modificadores e os tipos de exceo que o mtodo pode gerar ,exceoes serao
discutidas em um outro momento,. O corpo do mtodo um grupo ou bloco de comandos que sao executados
quando o mtodo chamado por um outro mtodo. O corpo de um mtodo sempre declarado dentro de
colchetes { ].
O nome do mtodo identiica-o. Lscolha um identiicador ,nome, que nao corresponda a uma palara-reserada
da linguagem Jaa.
Precedendo o nome do mtodo ha sempre o tipo de retorno. Lle identiica o tipo de dado que o mtodo
retorna, podendo indicar tambm que o mtodo nao retorna nada. Os alores posseis para ele sao:
1, Um dos tipos de dados primitios: boolean, byte, char, double, float, int, long ou short,
2, Uma reerncia a um objeto ,nome da classe do objeto que sera retornado,,
3, O tipo void, indicando que o mtodo nao retorna alor algum.
Um par de parnteses ,abre e echa-parnteses, segue o nome do mtodo. Lsse par de parnteses e
obrigatrio. Opcionalmente oc pode declarar, dentro destes parnteses, uma lista de ariaeis separadas por
rgulas. Cada uma destas ariaeis conhecida como parmetro. Assim, quando o mtodo chamado ,em
algum lugar do programa, uma lista de expressoes separadas por rgulas ,chamadas de argumentos, pode ser
passada para ele. O nmero de argumentos e seus tipos de dados devem ser iguais ao nmero de
parmetros e o tipo de dados de cada um deles (da esquerda para a direita).
A seguir sao apresentados alguns exemplos de assinaturas de mtodos:
int contaAt(int limite)
Declara um mtodo chamado contaAt, que recebe um parmetro em uma varivel
chamada limite e retorna um valor decimal inteiro (int) aps o processamento.
int soma(int a, int b)
Declara um mtodo chamado soma, que recebe dois parmetros decimais inteiros: o
primeiro na varivel a e o segundo na varivel b. Aps o processamento a funo
retorna um valor decimal inteiro (int).
void imprime(String texto)
Declara um mtodo chamado imprime, que recebe um parmetro do tipo String na
varivel texto. A funo processa e no retorna valor para quem a chamou.
float sorteiaNota(void)
Declara um mtodo chamado sorteiaNota, que no recebe parmetro algum e retorna
um nmero de ponto flutuante (natural, com vrgula), do tipo float, para quem a
chamou.
Vamos er um exemplo de um mtodo completo, que inclua o seu corpo:
int soma(int limite) Assinatura do mtodo

{ // incio do corpo do mtodo
int total;
for (int i = 1; i<= limite; i++)
total += i;
return total;
} // fim do corpo do mtodo
Corpo do mtodo

Neste ltimo exemplo, a primeira linha corresponde a assinatura do mtodo. Lssa assinatura indica que o
mtodo retorna um alor do tipo int ,um nmero inteiro decimal,. Alm disso, ela indica que o mtodo se
chama soma e recebe um parametro decimal inteiro, chamado limite.
O corpo do mtodo inicia com o abre-colchete { `. Segue-se, em seguida, uma srie de comandos que executam
determinadas tareas em unao do parametro recebido ,no caso, a soma dos nmeros existentes entre 1 e o
alor passado como parametro em limite,. O corpo do mtodo termina quando o echa-colchete ] `
correspondente encontrado. Note que na linha anterior ao echa-colchete o comando return utilizado. Lsse
comando az com que o alor da ariael total seja retornado. O tipo da ariael ou alor retornado dee ser o
mesmo que oi declarado como tipo de retorno na assinatura do mtodo ,int, no caso,.
Chamando (executando) um mtodo
Para chamar um mtodo, passe zero ou mais argumentos para o mtodo. O mtodo acessa estes argumentos
,colocando-os nas ariaeis correspondentes de parametros,, processa-os e entao, opcionalmente, retorna um
alor para quem chamou esse mtodo. Para ins de exemplo, amos supor que oc tenha criado um mtodo
para calcular a raiz-quadrada de um nmero e que agora oc esteja azendo um programa que necessite deste
mtodo. O cdigo do seu programa chama o mtodo de calculo da raiz-quadrada passando o alor ,nmero, do
qual oc deseja saber a raiz quadrada. O mtodo de calculo de raiz-quadrada recebe o argumento passado ,o
alor, que poderia at mesmo estar em uma ariael, ia o parametro correspondente. Aps algum tempo de
processamento, o mtodo retorna a raiz-quadrada do alor solicitado para o programa que o chamou. Veja o
exemplo:
class Matemtica {
float raizQuadrada(float numero){
float b = numero * numero;
// cdigo que calcula a raiz quadrada do nmero passado como parmetro
}
}
class ProgramaExemplo {
public static void main(String argumentos[])
{
Matematica funcoesMatematicas = new Matematica;
float resultado,
numero = 20;
// calcula a raiz-quadrada do nmero 10:
resultado = funcoesMatematicas.raizQuadrada(10);
System.out.println(A raiz-quadrada de 10 : + resultado);
// calcula a raiz-quadrada da varivel nmero (que vale 20):
resultado = funcoesMatematicas.raizQuadrada(numero);
System.out.println(A raiz-quadrada de + numero + : + resultado);
}
}
Neste ltimo exemplo, o ProgramaLxemplo chama o mtodo raizQuadrada ,nas linhas griadas,, passando
como parametro alores ,um nmero, no primeiro caso, e o contedo de uma ariael, no segundo,. Durante a
chamada, quando o mtodo executado, a Maquina Virtual Jaa ,Jaa Virtual Machine - JVM, cria dentro dele
uma ariael chamada numero e atribui o alor passado como parametro para essa ariael. Qualquer comando
existente dentro do corpo do mtodo raizQuadrada pode acessar e utilizar a ariael numero. Isso porque a
ariael declarada como parametro uma ariael como outra qualquer do mtodo, e pode ser utilizada dentro
dele, em qualquer lugar, normalmente. Por ser uma ariael do mtodo, numero s pode ser utilizada dentro
dele ,os outros mtodos nao a enxergam, mesmo que tenham sido declarados dentro da classe Matemtica,.
Quando a execuao do mtodo acaba a JVM destri o parametro numero.
Apesar dos parametros e as ariaeis locais de um mtodo nao poderem ser acessadas ora dele, e serem muito
parecidas por esse motio, existem dierenas entre o escopo de um parametro e o escopo
4
de uma ariael local.
O parametro ale dentro de todo o corpo do mtodo, enquanto que uma ariael local ale a partir do local onde
ela oi declarada. Veja o exemplo seguinte:
01 class Matemtica {
02 int soma(int limite){
03 System.out.println(O valor de limite : + limite); // OK
04 System.out.println(O valor de total : + total); // Erro!
05 int total; // Problema!
06 for (int i = 1; i<= limite; i++){
07 total += i;
08 }
09 System.out.println(O valor de i : + i); // Erro!
10 return total;
11 }
12 }
Neste ltimo exemplo a 4
a
linha apresenta um erro, pois o programador tentou utilizar a ariael total e ela ainda
nao haia sido declarada. Nunca utilize uma varivel local antes dela ter sido declarada. 1ambm ha um
erro na linha 9. Neste caso a ariael i oi declarada dentro de um bloco interno ,o bloco do comando for, e seu
escopo ,alidade, consiste somente no corpo do comando or, entre o { e o ], logo, na 9
a
linha essa ariael ja
nao existe mais. Nunca utilize uma varivel de um bloco interno em um bloco externo.
Variaeis locais tambm apresentam um outro problema em potencial: elas deem ser explicitamente
inicializadas ,sempre,. Note que na linha 5 a ariael total declarada dentro do mtodo soma. Isso signiica que
ela uma ariael local deste mtodo e s pode ser utilizada dentro dele. Note tambm que ela nao oi
inicializada ,algo do tipo: int total = 0,. Isso ocasionaria um problema pois o lao ,or, utiliza-a como
acumulador do alor da ariael i e seu alor inicial desconhecido ,e deeria ser zero,. Sempre inicialize suas
variveis locais a fim de evitar erros que podem surgir pela falta de um valor inicial de uma varivel.
Lxamine agora o comando return da linha 10. Lsse comando retorna um alor para quem chamou o mtodo
soma. A sintaxe deste comando a seguinte:
return [expresso];
Um comando de retorno consiste da palara-chae return opcionalmente seguida de uma expresso. A menos
que o tipo de retorno de um mtodo seja void ,signiicando que a unao nao retorna coisa alguma,, oc dee
sempre colocar aps o return uma expressao cujo tipo de dado seja igual ao tipo de retorno da unao. Alm
disso, se o tipo de retorno nao or void, a execuao do mtodo dee sempre terminar ia um comando return.
,o comando return pode ser colocado em qualquer lugar dentro do mtodo,.
Uma vez que o comando return tenha sido executado, para onde e que o programa vai? Se a chamada do
mtodo nao izer parte de uma expressao, a execuao continua no comando ,linha ou declaraao, seguinte a
chamada do mtodo. Caso contrario, a expressao continua com o operador que aalia os outros operandos da
expressao.

4
Escopo o local ou regio onde uma varivel vlida.
Especificadores de acesso
Voc utilizar um dos seguintes especiicadores de acesso na declaraao de um mtodo: public, private ou
protected. O especiicador determina o quao acessel esse mtodo para o cdigo de outras classes de um
programa. O acesso aria de totalmente acessel a totalmente inacessel. O uncionamento muito similar ao
dos atributos, istos anteriormente.
Se oc no utilizar um especificador de acesso o Jaa utiliza o nel de acesso padrao, azendo com que o
mtodo s possa ser chamado por outros mtodos declarados na mesma classe e em todas as classes do mesmo
pacote.
Se oc utilizar o especiicador private ,priado,, somente o cdigo contido na mesma classe pode chamar esse
mtodo:
class Matemtica {
private int fatorial(int numero){
if(n == 0) return 1; // fatorial de zero 1
int produto = 1;
for(int i = 2; i <= numero; i++) produto *= i;
return produto;
}
int permutao(int n, int r){
return fatorial(n) / fatorial(n r);
}
}
Somente os mtodos da classe Matemtica podem chamar o mtodo fatorial. O mtodo fatorial um mtodo
de ajuda para o mtodo permutao porque ele auxilia-o a executar a permutaao. Como, neste caso, ele oi
eito somente para ajudar o mtodo permutao, nao az sentido que outras classes ejam-no e utilizem-no.
Quando um mtodo existe somente para ajudar os outros mtodos de uma classe ele dee ser declarado priado
,private,. Declarar mtodos deste tipo promoe o ocultamento de inormaoes nao releantes ou nao
importantes para quem esta ora da classe, alm de mant-la organizada e acil de dar manutenao.
Se oc declarar um mtodo utilizando a palara-chae public o mtodo torna-se acessel para toda e qualquer
classe.
Um mtodo protected ,protegido, um mtodo com o nel padrao de acesso, com uma dierena: todas as
classes ilhas da classe na qual ele oi declarado podem acessa-lo.
Modificadores
Os modiicadores de mtodo disponeis em Jaa sao os seguintes: abstract ou final e,ou static e,ou native
e,ou synchronized.
Se oc utilizar a palara-chae abstract ,abstrato,, oc estara inormando ao Jaa que a declaraao consiste
somente em uma assinatura do mtodo. Isso porque, em Jaa, um mtodo abstrato um mtodo sem corpo
,sem bloco de comandos,. Um mtodo abstrato nao pode ser declarado, simultaneamente, como sendo final,
nem static, nem synchronized e nem private.
Se oc declarar um mtodo final, o compilador assume que ele nao pode ser sobre-escrito ,modiicado, em
sub-classes ,classes-ilhas,.
Se oc declarar um mtodo como sendo static ,estatico,, ele sera considerado um mtodo de classe e nao um
mtodo de objetos ,algo similar aos atributos de classe e de objetos, que oram discutidos na seao anterior,.
Neste caso ele s podera acessar atributos de classe. Se essa palara-chae nao or utilizada, o mtodo
considerado como sendo um mtodo de instancia ,~ de objeto,, e podera acessar qualquer espcie de atributo
,de classe ou de objeto,.
A palara-chae native ,natio, indica para o Jaa que o corpo do mtodo oi escrito em C-- e esta
armazenado em alguma biblioteca especica de plataorma ,tal qual uma DLL,. Neste caso, somente a assinatura
do mtodo dee ser declarada.
linalmente, se oc utilizar o modiicador synchronized ,sincronizada,, somente uma thread ,linha de
execuao, por ez pode executar o mtodo.
Mtodos de instncia
Mtodos de instancia sao os mtodos de objetos. Lstes mtodos podem acessar atributos de instancia e atributos
de classe declarados na sua classe. Para declarar um mtodo de instancia, nao especiique a palara-chae static.
Se seu mtodo de instancia possuir um parametro que tenha o mesmo nome de um atributo de instancia da sua
classe, seria possel atribuir o alor do parametro para o atributo de mesmo nome Sim, isso pode ser eito da
seguinte orma:
01 class Empregado {
02 private double salario;
03 void ajustaSalario(double salario){ // observe que salario j existe
// como atributo de classe!
04 this.salario = salario; // coloca o contedo do parmetro no atributo
05 }
06 }
Na terceira linha o mtodo ajustaSalario declara um parametro chamado salario. Note que uma ariael ,um
atributo, contendo o mesmo nome ja haia sido declarada anteriormente, na linha dois. Nesta situaao, para que
oc possa colocar o alor do parametro no atributo ,na ariael ja existente,, oc tem que utilizar o preixo
this. Lssa palara-chae identiica o objeto atual no cdigo-onte. Quando oc utiliza esse preixo, oc diz
para o Jaa: acesse o atributo pertencente a esse objeto, cujo nome o seguinte...`. O nome do atributo em
aps o ponto, como oc pode er na linha quatro do exemplo.
A chamada ,utilizaao, de um mtodo de instancia depende se oc esta em um outro mtodo da prpria classe
onde ele oi declarado ou em uma outra classe. Se oc estier em um outro mtodo da mesma classe e tambm
or um mtodo de instancia, basta oc especiicar o nome do mtodo e sua lista de argumentos entre
parnteses: ajustaSalrio(8S0.00). Lxemplo:
class Empregado {
private double salario;
void ajustaSalario(double salario){
this.salario = salario;
}
void aumentaDezPorcento(void) { // outro mtodo de instncia da mesma classe
double novoSalario = salrio + salrio * 0.1;
ajustaSalario(novoSalario); // chama um mtodo da mesma classe
}
}
Se oc, por acaso, necessitar chamar ,utilizar, um mtodo que pertence a uma outra classe ou a um metodo de
classe, primeiro crie um objeto do tipo da classe que contm o mtodo que oc deseja chamar e depois utilize
esse objeto para chama-lo:
class ClasseUm {
private boolean atributoQualquer;
public void metodo(boolean valor){ // mtodo a ser chamado por outra classe
atributoQualquer = valor;
}
}
class OutraClasse {
void outroMetodo(void){
ClasseUm objeto = new ClasseUm();
objeto.mtodo(true); // chama o mtodo atravs do objeto
new ClasseUm().metodo(false); // chama o mtodo atravs do objeto
}
}
Lsse ltimo exemplo tambm mostra que oc nao precisa colocar o objeto criado em uma ariael para chamar
um mtodo de outro objeto. A expressao new ClasseUm().metodo(false), cria um objeto a partir da ClasseUm
e, ao mesmo tempo ,implicitamente,, usa a reerncia ao objeto recm criado para chamar metodo().
Similarmente, oc tambm pode encadear chamadas de mtodos de instancia ,desde que elas retornem
reerncias para objetos,:
class AlTchau {
public static void main(String listaDeParametros[]){
new AlTchau().al().tchau(); // chamada encadeada de mtodos
}
AlTchau al() { // o mtodo al retorna um objeto do tipo AlTchau
System.out.println(Al);
return this; // retorna este objeto
}
AlTchau tchau() { // o mtodo tchau retorna um objeto do tipo AlTchau
System.out.println(Tchau);
return this; // retorna este objeto
}
}
Mtodos de Classe
Um mtodo de classe um mtodo que acessa somente os atributos de classe deinidos na sua prpria classe.
Para declarar um mtodo deste tipo, especiique a palara-chae static:
class Empregado {
private static int numeroDeEmpregados;
static void ajustaNumeroDeEmpregados(int numero){
numeroDeEmpregados = numero;
}
}
Se, no exemplo anterior, o parametro numero tiesse o mesmo nome do atributo numeroDeLmpregados,
seria possel utilizar this para passar o alor do parametro para esse atributo Veja o exemplo:
class Empregado {
private static int numeroDeEmpregados;
static void ajustaNumeroDeEmpregados(int numeroDeEmpregados){
this.numeroDeEmpregados = numeroDeEmpregados; //ERRO!
}
}
Voc nao pode utilizar this em um mtodo de classe porque essa palara-chae se reere a instancia ,ao objeto,
de classe atual e, inelizmente, um mtodo de classe nao associado a nenhum objeto ,instancia de classe,.
Para chamar um mtodo de classe por outro metodo de classe ou de instncia da mesma classe,
simplesmente utilize seu nome e sua lista de argumentos entre chaes:
class PrimeiroESegundo {
static void primeiro() {
System.out.println(Primeiro);
}
static void segundo() {
primeiro();
System.out.println(Segundo);
}
}
Se a chamada estier em um metodo de classe de outra classe, preixe o mtodo com o nome de sua classe
seguido do operador de ponto:
class UsarPrimeiroESegundo {
public static void main(String listaDeArgumentos[]) {
PrimeiroESegundo.primeiro(); PrimeiroESegundo.segundo();
}
}
Se o mtodo da outra classe nao or de classe, chame-o da mesma orma como oc chamaria um mtodo de
instancia de outra classe ,primeiro crie um objeto e depois chame o mtodo a partir dele,.
Sobre a passagem de argumentos
At o momento nada oi dito sobre como sao passados os argumentos ,parametros, para os mtodos de classe
ou de instancia. Lxistem duas abordagens para tal: chamada por valor e chamada por referncia.
As chamadas por valor azem uma cpia de cada argumento e passa essa cpia para o mtodo. Assim, o alor
original nao modiicado. Lm Jaa, somente os tipos primitivos ,int, double, loat..., sao passados por alor.
Isso signiica que, se durante seu processamento, o mtodo realizar alguma mudana nos contedos dos
parametros, as ariaeis originais nao serao aetadas ,no mtodo que realizou a chamada,.
Lm contraste, as chamadas por referncia passam somente uma reerncia ao endereo do argumento original,
tornando possel ao mtodo chamar os mtodos e acessar os atributos ,elementos, deste argumento e modiica-
los.
Sobrecarregando mtodos
Declarar mltiplos mtodos que possuam o mesmo nome, porm com listas de parametros dierentes, uma
tcnica denominada sobrecarga de metodo ,method oerloading,. Neste caso, o compilador seleciona o
mtodo apropriado escolhendo aquele cujo nome, nmero e tipo de argumentos coincidir com a chamada de um
mtodo com o mesmo nome, nmero e tipo de argumentos ,atras da comparaao de assinaturas,. Veja o
exemplo seguinte:
void imprimir(){
System.out.println(Impresso padro);
}
void imprimir(String argumento){
System.out.println(argumento);
}
O exemplo anterior demonstra dois mtodos imprimir sobrecarregados. Os dois mtodos possuem o mesmo
nome, porm, parametros dierentes. Ao se chamar imprimir() o primeiro chamado ,executado,. Ao se
chamar imprimir,Ola`,, o segundo chamado.
Voc pode declarar e implementar quantas sobrecargas voc achar conveniente. Porem, e importante
lembrar que os argumentos devem ser sempre diferentes. Nao basta oc modiicar o tipo de retorno,
mantendo o resto da assinatura igual. Veja o exemplo:
int somar(int x, int y){
return x + y;
}
lont somar(int x, int y){
return x + y;
}
Neste ltimo caso o compilador nao tem como decidir qual mtodo chamar, e acusara um erro.
Construtores (constructors)
Construtor um mtodo especial que chamado pelo operador new quando um noo objeto necessita ser
criado. Dentro do construtor oc pode colocar o seu prprio cdigo customizado` de inicializaao do objeto.
Por serem mtodos, os construtores podem ser declarados com listas de parametros e especiicadores de acesso.
Lntretanto, um construtor deve ter o mesmo nome da classe em que for declarado. Alm disso, um
construtor no deve ter um tipo de retorno em sua declaraao.
Voc se lembra da classe Lmpregado?
class Empregado {
private int numeroDeEmpregados;
private double salario;
public void ajustaNumeroDeEmpregados(int numeroDeEmpregados){
this.numeroDeEmpregados = numeroDeEmpregados;
}
void ajustaSalario(double salario){
this.salario = salario;
}
}
Objetos desta classe podem criados atras da utilizaao do operador new:
class Exemplo {
public static void main(String listaDeArgumentos[]){
Empregado e = new Empregado();
}
}
A linha Lmpregado e = new Lmpregado() cria um noo objeto do tipo Lmpregado e coloca-o na ariael e,
que tambm do tipo Lmpregado. O Lmpregado() que em depois do operador new um construtor
,sempre depois do new dee-se colocar um construtor,. Note, porm, que no cdigo da classe Lmpregado
no h a declarao de construtor algum! O que esta acontecendo Basicamente, quando oc nao declara
um construtor para uma classe o compilador cria um construtor-padrao ,deault,, com uma lista azia de
parametros. Olhe o exemplo:
class X
{
}
Lssa classe parece azia, mas ela nao esta. Na realidade, o compilador enxerga a classe X da seguinte maneira:
class X
{
X ()
{
}
}
O Compilador somente cria o construtor padrao quando nenhum outro or explicitamente declarado na classe.
Logo, se oc declarar algum outro construtor, o compilador no vai gerar um construtor-padrao sem
argumentos:
class X
{
private int i;

X (int i) // Explicitamente declara um construtor com argumentos
{
this.i = i;
}
}
class UsaX
{
public static void main(Strings listaDeArgumentos[]){
X x1 = new X(2);
X x2 = new X(); // ERRO: no existe construtor sem argumentos na classe X!
}
}
Neste ultimo exemplo, a tentatia de chamar o construtor-padrao ,sem argumentos, gera um erro de compilaao
por que nao ha um construtor-padrao.
Voc pode declarar mltiplos construtores em uma classe. Mltiplos construtores tornam possel a realizaao de
dierentes tipos de inicializaao:
class Circulo
{
private int x, y, r;

Circulo() // declara um construtor sem argumentos
{
// System.out.println(Antes);
this(0,0,1);
System.out.println(Depois);
}
Circulo(int x, int y, int r)// declara um construtor que recebe 3 argumentos
{
this.x = x;
this.y = y;
this.r = r;
}
int retornaX() {
return x;
}
int retornaY() {
return y;
}
int retornaRaio() {
return r;
}
}
class Exemplo
{
public static void main(String listaDeArgumentos[])
{
Circulo c1 = new Circulo();
System.out.println(Centro X: + c1.retornaX());
System.out.println(Centro Y: + c1.retornaY());
System.out.println(Raio : + c1.retornaRaio());
Circulo c2 = new Circulo(5,6,7);
System.out.println(Centro X: + c2.retornaX());
System.out.println(Centro Y: + c2.retornaY());
System.out.println(Raio : + c2.retornaRaio());
}
}
Lste ltimo programa declara um par de classes: Lxemplo e Circulo. A classe Circulo declara um par de
construtores. O primeiro construtor nao recebe argumento algum e contm a seguinte linha de cdigo:
this(0,0,J), que nada mais az do que chamar o segundo construtor que possui 3 argumentos ,dentro de uma
classe, utilize this() ao ins do nome do seu construtor,.
Uma chamada ao construtor ia o comando this() dee ser a primeira linha de cdigo dentro de um construtor
,caso contrario o compilador gera um erro,. Por esse motio, a linha System.out.println(Depois), que
aparece no primeiro construtor da classe Circulo, esta comentada. 1ambm, deido a esse mesmo motio, oc
nao pode chamar dois construtores em um construtor.
Parte III: Composio - Construindo objetos a partir de outros objetos
Suponha que seu instrutor pea para oc escreer uma aplicaao Jaa que modele um carro. De acordo com as
especiicaoes dele, esta aplicaao dee declarar uma classe chamada Motor ,que modela o motor do carro, e
uma classe chamada Carro ,que modela carros,. linalmente, a aplicaao dee declarar uma classe chamada
DemonstracaoCarro, que possua uma unao main a im de executar o programa.
Mas afinal, neste caso, o que e que o metodo main faz realmente? Neste caso o mtodo main, por ser um
mtodo de classe especial, ica encarregado de criar objetos do tipo Carro ,que possuam objetos do tipo Motor
em cada um deles,, colocar inormaoes apropriadas em cada objeto ,ia chamadas a seus construtores, e ,para
cada carro, imprimir as inormaoes de cada carro. Depois de um tempo escreendo essa aplicaao, oc dee
terminar com o seguinte cdigo-onte:
class Motor
{
private String tipo;
Motor(String tipo)
{
this.tipo = tipo;
}
}
class Carro
{
private String marca;
private String modelo;
private String fabricante;
Carro(String marca, String modelo, String fabricante)
{
this.marca = marca;
this.modelo = modelo;
this.fabricante = fabricante;
}
public String retornaMarca() { return marca; }
public String retornaModelo() { return modelo; }
public String retornaFabricante() { return fabricante; }
}
class DemostracaoCarro
{
public static void main(String listaDeArgumentos[]){
Motor m1 = new Motor(3.8L V6);
Carro c1 = new Carro(Mustang, Conversvel, Ford);
Motor m2 = new Motor(Zetec Roam 1.0);
Carro c2 = new Carro(Ka, Popular, Ford);
System.out.println( c1.retornaFabricante() + +
c1.retornaMarca() + +
c1.retornaModelo() + + m1.retornaTipo() );
System.out.println( c2.retornaFabricante() + +
c2.retornaMarca() + +
c2.retornaModelo() + + m2.retornaTipo() );
}
Muito bem! O cdigo anterior segue as especiicaoes e requisitos solicitados pelo instrutor. Por outro lado, esse
cdigo apresenta um problema de modelagem importante: as classes Carro e Motor estao desconectadas ou
desacopladas uma da outra.
No mundo real, comum dizer que um carro possui um motor, assim como pneus e outros itens. Lm outras
palaras, arios itens, incluindo um motor, compoem um carro. Lm contraste, o cdigo anterior mostra que um
carro nao compoe um carro e, neste caso, possel criar objetos do tipo Carro sem um motor associado - uma
situaao estranha. Voc ja imaginou algum comprando um carro sem motor! O erro de se criar um noo Carro
sem um Motor resulta do ato das duas classes estarem desconectadas. A soluao para esse erro consiste em
conectar estas duas classes. L exatamente esse o assunto desta seao: composio de objetos.
O que composio?
Lm nosso mundo, entidades compoem outras entidades. S para dar um exemplo, um chassi, algumas portas,
pneus, um motor, uma transmissao, um sistema de escapamento, e similares, compoem um eculo. Pelo ato de
objetos serirem como representaoes de sotware de entidades do mundo real, possel que arios objetos
sejam utilizados para compor um outro objeto. O ato de compor um objeto a partir de outros objetos chamado
de composio ou agregao.
Analise o cdigo seguinte:
class Motor
{
// atributos e mtodos que identificam a estrutura de um motor
}
class Veculo
{
Motor motor; // define uma varivel que armazena um objeto do tipo Motor
Veculo(Motor m)
{
motor = m;
}
}
Lsse exemplo de cdigo declara duas classes: Motor e Veiculo. A classe Veiculo declara um atributo chamado
motor, que do tipo Motor, e utiliza esse atributo para reerenciar um objeto que descree o motor de um
eculo. O construtor Veiculo(Motor m) inicializa o atributo motor para reerenciar um objeto do tipo Motor
atribuindo o contedo do parametro m para esse atributo. Depois de azer a atribuiao, motor possui
,reerencia, na erdade, o mesmo que m. A igura seguinte demonstra a conceitualizaao um Veiculo composto
de um Motor:

Agora que oc sabe alguma coisa sobre a estrutura das classes Veiculo e Motor, como oc az para criar um
objeto do tipo Motor e um objeto do tipo Veiculo que seja composto do objeto Motor A resposta esta no
exemplo seguinte:
Motor m = new Motor(); // cria um novo motor e coloca na varivel motor
Veculo v = new Veculo(m); // cria um novo veculo, passando o motor para ele
No exemplo acima, a primeira linha cria o objeto Motor e atribui seu endereo a ariael de reerencia de
objetos m, do tipo Motor. A segunda linha, que cria o objeto Veiculo, passa o endereo do objeto ,que esta na
ariael m, para o construtor do Veiculo. Com isso, o construtor sala o contedo da ariael m dentro do seu
atributo priado motor. Neste momento, o objeto Veiculo reerenciado pela ariael v composto do objeto
Motor reerenciado pelo atributo interno do Veiculo. A relaao entre os dois objetos recm criados aparece na
igura seguinte:

Nesta igura oc pode notar que existem dois objetos: o objeto do tipo Veiculo, que esta reerenciado na
ariael v, e o objeto do tipo Motor, que reerenciado pelo atributo motor do objeto Veiculo. A princpio eles
existem em locais dierentes de memria, porm, deido ao atributo motor, eles estao ligados, azendo com que
o objeto Veiculo seja composto por um Motor.
Parte IV: Herana - Construindo objetos em camadas
O que Herana?
lerana a habilidade de se deriar alguma coisa especica a partir de algo mais genrico. Ns encontramos
essa habilidade ou capacidade no nosso cotidiano. Um Plio-LX, estacionado na rente da garagem do seu
izinho, uma instancia especica da categoria Carro, mais genrica, por exemplo. Da mesma orma, uma
Honda CG J2S Cargo uma instancia especica da categoria mais genrica Moto. Se learmos as categorias
Carro e Moto para um outro nel mais eleado, as duas se relacionarao uma com a outra por serem instancias
especicas de uma categoria mais genrica ainda do que elas: a categoria Veiculo. Lm outras palaras, carros e
motos sao eculos. A igura seguinte esquematiza as relaoes entre uma entidade Plio-LX, a categoria Carro,
uma entidade Honda CG J2S Cargo, a categoria Moto, e a supercategoria Veiculo.

Veculo
Motor

Veculo
Motor
v
motor


Lntidades as sao coisas tangeis com as quais ns interagimos ,o Palio-LX ou a CG 125, por exemplo,. As
categorias relacionam entidades com outras entidades, em uma hierarquia: o seu carro ,se oc tier um, se
relaciona com outros carros atras da categoria Carro. L os Carros se relacionam com Motos atras da
supercategoria Veiculo. Se utilizarmos uma metaora de arore inertida ,onde a raiz desta arore encontra-se
no topo e as olhas em baixo,, as categorias sao os ramos ou galhos da arore, e as entidades sao as olhas desta
arore ,conorme oc pode er na igura anterior,. A hierarquia de galhos de categorias organiza a orma da
arore ,arquitetura de entidades,, e as olhas ,as entidades, sao instancias dos galhos mais baixos ,categorias,.
Lsse exemplo ilustrou a herana simples. Neste caso, uma entidade herda estados e comportamentos ,atributos
e mtodos, de uma e somente uma categoria. O Plio, por exemplo, herda da categoria Carro ,e somente dela,
diretamente,. Lm contraste, herana mltipla permite com que uma entidade herde diretamente
comportamentos e estados de duas ou mais categorias ao mesmo tempo. Imagine o Lmpregado chamado Jose
de uma empresa qualquer. Para ser mais especico, pense no Jose como sendo Gerente e Contador ao mesmo
tempo. Lle herdaria ,possuiria, as capacidades de um Gerente e de um Contador ,por que nao,. Veja a prxima
igura:

Estendendo classes
Na linguagem Jaa a herana se maniesta de duas maneiras: ou pela extenso de classes ,chamada de herana
de implementao, ja existentes ou pela implementao de interfaces ,chamada de herana de interface,.
Nesta seo ns vamos estudar somente a herana de implementao.
De acordo com a herana de implementao, noas classes deriam capacidades ,expressas como atributos e
mtodos, de classes ja existentes. Isso az com que o tempo de desenolimento de uma aplicaao seja bem
menor, pois classes ja existentes e comproadamente uncionais ,lires de erros e ja testadas, sao reaproeitadas
,ou reutilizadas,. A sintaxe que expressa o conceito de extensao de classes a seguinte:
class identificadorDeClasse1 extends identificadorDeClasse2
{
// Campos e mtodos
}
Lssa sintaxe pode ser lida da seguinte orma: o identificadorDeClasseJ estende o identificadorDeClasse2.
Lm outras palaras, o identificadorDeClasseJ herda ,ou deria, capacidades ,expressas atras de atributos e
mtodos, do identificadorDeClasse2. O identificadorDeClasseJ conhecido como subclasse, classe
derivada ou classe-filha. O identificadorDeClasse2 conhecido como superclasse, classe bsica ou
classe-pai.
Veculo
Carro
Plio-EX
Moto
Honda CG 125 Cargo

Empregado
Contador
Joo
Gerente

A palara-chae extends ,estende, az com que uma subclasse herde ,receba, todos os campos e mtodos
declarados na classe-pai ,desde que ela nao seja final,, incluindo todas as classes-pai da classe-pai. A classe-ilha
pode acessar todos os atributos e mtodos nao priados. Lla nao pode acessar ,ao menos diretamente, os
mtodos e atributos priados ,declarados com a palara-chae private,. Considere o exemplo seguinte:
class Ponto
{
private double x, y;
Ponto(double x, double y)
{
this.x = x;
this.y = y;
}
double retornaX()
{
return x;
}
double retornaY()
{
return y;
}
}
class Circulo extends Ponto
{
private double raio;
Circle(double x, double y, double raio)
{
super(x, y); // Chama Ponto(double x, double y)
this.raio = raio;
}
double retornaRaio() {
{
return raio;
}
}
O cdigo acima consiste de duas classes: Ponto e Circulo. Ponto uma classe que
descree um ponto, que nao nada mais do que um par de coordenadas ,x, y,,
expresso por alores de ponto-lutuante de dupla-precisao numrica ,tipo double,.
Circulo descree um crculo ,um crculo um ponto que possui um raio,. Se oc
osse criar um objeto a partir da classe Circulo, oc acabaria com o objeto de
multicamadas representado na igura ao lado.
Lssa igura mostra que o objeto Circulo de duas camadas possui trs atributos: x, y e
raio. Lntretanto ele somente declara somente o atributo raio. Os outros dois atributos
sao apresentados na camada mais interna, do Ponto. As subclasses ,classes-ilha, sao
geralmente mais largas do que as superclasses ,classes-pai,. Isso porque elas costumam
adicionar noos atributos ou mtodos. Neste caso, por exemplo, a subclasse Circulo
adicionou um atributo chamado raio e um mtodo chamado retornaRaio,,.
Uma subclasse pode estender uma superclasse, desde que a superclasse nao tenha sido declarada final. Por
exemplo, se a declaraao da classe Ponto tiesse sido final class Ponto, o compilador teria acusado um erro.
Logo, por razoes de segurana, se oc quiser garantir que uma classe nao ai ser estendida, declare-a como
sendo final.
A sintaxe da herana sugere que oc pode estender uma e somente uma classe. A linguagem Jaa nao suporta a
implementaao de herana mltipla. Isso porque, segundo os projetistas da linguagem, esse tipo de
implementaao poderia gerar conusao. Imagine, por exemplo, duas classes-base declarando um atributo que
possua o mesmo nome mas com tipos dierentes. Qual dos dois a classe-ilha deeria herdar O mesmo poderia
acontecer com um mtodo. Se dois mtodos possussem o mesmo nome mas dierentes listas de parametros ou
tipos de retorno, qual deles a subclasse deeria herdar Para preenir tais problemas a linguagem Jaa rejeita a
implementaao de herana mltipla.
raio
x e y
Camada
do Ponto
Camada
do Circulo

Chamando construtores da classe-pai
No exemplo anterior, examine o construtor da classe Circulo. Veja que dentro dele ha o seguinte cdigo na linha
griada: super(x, y). Lssa linha utiliza a palara-chae super para chamar o construtor Ponto(double x, double
y) da sua superclasse ,classe-pai, e passar para ele o contedo das ariaeis x e y. L importante para a classe
Circulo chamar esse construtor da classe Ponto para que os alores de x e de y inicializem corretamente. Pelo
ato da classe Ponto declarar estes atributos como sendo priados ,private,, nenhuma classe ,nem mesmo sua
classe-ilha Circulo, a nao ser a prpria classe Ponto, pode acessa-los. Logo, para inicializar os alores de x e de
y passados como argumentos para o construtor da classe Circulo, essa classe necessita delegar essa tarea para o
construtor da classe Ponto, e isso eito chamando-se super(x, y,.
Suponha que oc modiique o construtor da classe Circulo e retire a linha que contm super(x, y), e aps oc
tente compilar o programa. O que aconteceria O compilador acusaria um erro. Isso porque um construtor de
subclasse deve sempre chamar um construtor de sua superclasse, mesmo que a superclasse no declare
explicitamente um construtor. Se oc nao colocar uma chamada para o construtor da superclasse, o
compilador insere automaticamente na subclasse o cdigo que chama o construtor-padrao ,sem argumentos,. No
exemplo anterior, se oc tiesse retirado super(x, y) o compilador teria inserido o comando super() para
chamar o construtor-padrao da classe Ponto(). Note que, neste caso, a classe Ponto nao tem nenhum
construtor-padrao, sem argumentos, declarada dentro dela. A classe Ponto do exemplo possui somente o
construtor que recebe dois argumentos do tipo double: Ponto(double x, double y). L, por esse motio, um
erro seria gerado ,lembre-se que quando oc nao especiica um construtor o compilador gera automaticamente
o construtor padrao, mas esse nao oi o caso ocorrido na classe Ponto,.
Lxistem duas outras regras que deem ser leadas em consideraao. A primeira delas diz que voc s pode
chamar o construtor de uma superclasse se estiver dentro de um construtor de sua subclasse ,e em mais
nenhum mtodo,. A segunda diz que, dentro de um construtor, voc nunca pode colocar cdigo algum
antes de chamar o construtor da superclasse.
Sobre-escrevendo mtodos (Overriding)
Uma subclasse pode sobrescreer, trocar ou re-escreer um mtodo de sua superclasse. Para que isso ocorra, o
mtodo da subclasse dee possuir o mesmo nome, a mesma lista de parametros e o mesmo tipo de retorno do
mtodo da sua superclasse. Veja o exemplo:
class Ponto
{
void desenha()
{
System.out.println(Eu sou um ponto.);
}
}
class Circulo extends Ponto
{
void desenha() // re-declara ou re-escreve o mtodo
{
System.out.println(Eu sou um crculo.);
}
}
De acordo com o cdigo presente no exemplo acima, se oc criar um noo objeto do tipo Circulo e chamar o
mtodo desenha(), entao a rase Lu sou um circulo. ira aparecer:
Circulo c = new Circulo();
c.desenha();
Lntretanto, se a classe Circulo nao tiesse re-escrito o mtodo desenha() com o seu prprio cdigo, oc teria
isto Lu sou um ponto.`, ao ins.
Agora imagine que oc tenha um atributo ou mtodo, em uma subclasse, que seja idntico a um atributo ou
mtodo de sua superclasse. Imagine tambm que oc queira acessar esse atributo ou mtodo que pertence a
superclasse e nao a subclasse. Como oc poderia azer isso A resposta oc ai encontrar no ragmento de
cdigo seguinte:


class Super
{
double x = 2;
void desenha()
{
System.out.println(Super);
}
}
class Sub extends Super
{
double x = 3; // re-declara o atributo
void desenha() { // re-declara / re-escreve o mtodo
System.out.println(Sub);
System.out.println(x = + x);
System.out.println(Super.x = + super.x);
super.desenha(); // chama o mtodo da superclasse
}
}
O exemplo anterior demonstra um outro uso pra a palara-chae super. Preixando com super.` um mtodo
ou um atributo az com que o mtodo da superclasse seja chamado ou com que o atributo da superclasse seja
utilizado.
Lembre-se, porm, que um metodo s pode ser sobre-escrito se ele no tiver sido declarado privado
(private) na superclasse, isto , ele tem que ser acessel. Da mesma orma, o mtodo nao pode ter sido
declarado final, pois essa palara-chae az com que o mtodo nao possa ser sobre-escrito.
Nomeando ou especificando o tipo de um objeto (type Casting)
1odo objeto criado a partir de uma subclasse tambm um objeto do tipo da sua superclasse ,um objeto do tipo
Carro tambm um objeto do tipo Veiculo, e um objeto do tipo Circulo tambm um objeto do tipo Ponto,
conorme nossas declaraoes anteriores,. Lssa airmaao implica no ato de oc poder atribuir um objeto de
uma subclasse para uma reerncia criada ou declarada para um objeto de sua superclasse.
Ponto p = new Circulo(10.0, 20.0, 30.0);
A linha de cdigo acima cria um objeto do tipo Circulo e atribui sua reerncia a ariael p. Note que essa
ariael p uma ariael que armazena reerncias para objetos do tipo Ponto. Lsse tipo de atribuiao
pereitamente possel, ja que um Circulo, pelas deinioes de classe que oram descritas em exemplos
anteriores, uma subclasse de Ponto ,e, neste caso, um crculo tambm um ponto,. Assim, atras da ariael
p possel chamar os mtodos retornaX() e retornaY(), que pertencem ao tipo Ponto. Mas seria possel,
tambm, chamarmos o mtodo retornaRaio()
A resposta no, pois quem declara esse mtodo a camada do Circulo e nao a camada do Ponto ,oc se
lembra que os objetos podem ser construdos em mais de uma camada,. Lm essncia, retornaRaio() um
mtodo que pertence a camada do Circulo e nao do Ponto. Logo, se oc declara uma ariael do tipo Ponto
ela enxerga somente a camada existente dentro da classe Ponto. Por outro lado, se oc declara uma ariael do
tipo Circulo ela enxerga a toda a camada da classe Circulo, e a camada da classe Circulo engloba a camada da
classe Ponto.
Neste caso, a nica maneira de utilizar a ariael p para acessar o mtodo retornaRaio() utilizando um recurso
chamado type cast
S
, que em Ingls signiica algo do tipo nomeao ou especificao de tipo. Com esse
recurso, uma ariael pode assumir momentaneamente outro papel ,ou tipo,, para que oc possa atribu-la ou
utiliza-la em alguma expressao. Lm Jaa, assim como na linguagem C, o cast de uma ariael ou expressao
realizado colocando-se entre parnteses o tipo desejado. Logo, se no exemplo anterior oc quisesse utilizar o
mtodo retornaRaio() para poder retornar o alor do raio do crculo e coloca-lo em uma ariael, oc teria que
azer o seguinte:
double raio = ((Circulo) p).retornaRaio();

5
A palavra cast, em Ingls, pode significar elenco, que diz respeito lista de atores de uma pea de teatro, novela ou
filme. O elenco tem a ver com o papel que determinado ator ou pessoa representa. Analogamente, passando para o
contexto de linguagens de programao, o significado da expresso type cast seria algo do tipo indicar/mudar
momentaneamente o papel (ou o tipo) de determinada varivel.
Lembre-se que as operaoes dentro de parnteses sao executadas primeiro. Logo, primeiro o compilador troca o
tipo da ariael p para Circulo e depois, com esse resultado ,que sera um objeto do tipo Circulo,, ele chama o
mtodo retornaRaio(). O alor retornado atribudo a ariael chamada raio.
L importante lembrar que oc pode utilizar esse articio de nomeaao para transormar uma classe-ilha em
qualquer uma de suas classes-pai. O inverso, porem, no e permitido. Veja o exemplo:
Ponto p = new Ponto(10.0, 20.0);
double raio = ((Circulo) p).retornaRaio();
O problema, neste caso, que um objeto do tipo Ponto nao tem noao alguma de um mtodo chamado
retornaRaio. Isso porque quem introduz esse mtodo a classe Circulo. Logo, apesar desse cdigo compilar
sem acusar erro, quando oc executa-lo, a JVM ai gerar uma exceao ,uma alha, do tipo
ClassCastLxception (Lxceo de Nomeao de 1ipo), ou at mesmo traar, quando a chamada ao mtodo
retornaRaio() ocorrer.
Herana versus Composio
lerana e composiao relacionam-se entre si da mesma orma que um lado se relaciona com o outro em uma
moeda. lerana promoe um objeto em camadas, como uma cebola. Lm contraste, a composiao promoe
objetos que possuem outros objetos, como mingau de aeia em locos, onde cada loco um objeto. Na seao
,captulo, anterior, oc aprendeu que a composiao resulta de relaoes do tipo tem um`, entre objetos
,exemplo: carro tem um motor,. A herana resulta de relaoes do tipo um`. Logo, quando oc encontrar um
texto ou uma descriao do tipo um carro e um tipo de eculo`, oc esta lidando com herana. Para projetar
ou construir objetos complexos oc pode utilizar tanto a herana quanto a composiao. Uma nao exclui a outra,
e oc pode, inclusie, utiliza-las junto.
Um dos problemas mais diceis que um projetista pode enrentar, quando estier desenolendo uma hierarquia
de classes, saber decidir quando utilizar composiao e quando utilizar herana. Algumas ezes as relaoes do
tipo um` ou tem um` nao sao muito claras. Para exempliicar, suponha que oc nao saiba que um crculo
seja um ponto sem raio. Ao contrario, oc acredita que um crculo tenha um ponto e um raio. A partir desta
premissa, oc pode acabar implementando o seguinte ragmento de cdigo:
class Ponto{
private double x, y;
Ponto(double x, double y){
this.x = x;
this.y = y;
}
double retornaX() {
return x;
}
double retornaY() {
return y;
}
}
class Circulo{
private Ponto p;
private double raio;
Circle(double x, double y, double raio){
p = new Ponto(x, y);
this.raio = raio;
}
double retornaRaio() {
return raio;
}
double retornaX() {
return p.retornaX();
}
double retornaY() {
return p.retornaY();
}
}
A partir de uma interace ou cdigo externos, um objeto criado a partir desta classe Circulo equialente ao da
classe Circulo apresentada no incio desta seao. Com este exemplo, pode parecer que nao importa se a herana
ou nao utilizada. Mas, na erdade, importa: preste muita atenao na classe Circulo. Note que ha a deiniao
dos mtodos retornaX e retornaY. Lstes mtodos duplicam o cdigo ja existente na classe Ponto sem
necessidade. Com isso, a reutilizaao de cdigo nao eita ,e uma das grandes antagens da orientaao a objetos
poder reutilizar cdigo,. Portanto, se oc ocalizar somente a composiao de objetos oc podera estar
adicionando redundancia ao cdigo. Lm uma escala muito maior, esse tipo de redundancia pode se tornar um
pesadelo de manutenao.
Parte V: A raiz de todas as classes
Muitas linguagens orientadas a objetos, como o C--, nao suportam a noao de existir uma nica classe a partir
da qual todas as outras classes sao deriadas, sem que isso seja um detrimento da linguagem. Lntretanto, na
linguagem Jaa, a alta desse tipo de classe tornaria a linguagem limitada.
A camada "Objeto"
1odos os objetos da linguagem Jaa sao de mltiplas camadas. Cada classe, na hierarquia de classes, representa
uma camada que adiciona diersas capacidades a um objeto. No topo desta hierarquia oc sempre ai encontrar
uma classe chamada de Objet ,objeto,. Imagine, por exemplo, que oc tenha declarado uma classe chamada
DemoCamadaObjeto que nao estende, explicitamente, nenhuma outra classe. O cdigo seguinte apresenta uma
possel representaao desta classe:
class DemoCamadaObjeto{
int atributoDeInstancia = 1;
public static void main(String listaDeArgumentos[]){
DemoCamadaObjeto antigo = new DemoCamadaObjeto();
System.out.println(antigo.atributoDeInstancia);
System.out.println(antigo.toString());
}
}
A primeira ista, oc nao nota nada de especial nesta classe. Lla declara um atributo de objeto e um mtodo
main que cria um objeto do tipo DemoCamadaObjeto e imprime o alor do atributo atributoDeInstancia.
Lntretanto, se oc examinar com mais calma, oc ai notar algo estranho: antigo.toString(). De alguma
orma, a unao main chama um mtodo toString, mesmo que DemoCamadaObjeto nao tenha declarado esse
mtodo ou tenha especiicado uma classe-pai. As aparncias podem ser decepcionantes. Na realidade
DemoCamadaObjeto implicitamente estende a classe Objet. L como se o programador tiesse declarado class
DemoCamadaObjeto extends Object, o que pereitamente permitido. Pelo ato de qualquer classe estender
implicitamente ,sem ser necessario declarar, a classe Object, a classe DemoCamadaObjeto uma classe-ilha
da classe Object. 1ambm pelo ato da classe Object possuir um mtodo chamado toString() ,que conerte um
objeto para uma String,, pereitamente legal chamar esse mtodo no mtodo main do exemplo anterior. Para
compreender melhor como o objeto criado a partir de DemoCamadaObjeto se parece, obsere a igura
seguinte.

No centro do objeto DemoCamadaObjeto, representado na igura anterior, oc ai encontrar uma camada do
tipo Objet ,representada pelo crculo interno,. Lssa camada interna apresenta alguns mtodos que ns amos
examinar em detalhes nesta seao. A camada externa, que representa o objeto DemoCamadaObjeto, herda
Mtodos
da classe
Object
atributoDeInstancia
main
Mtodos
da classe
Object
Mtodos
da classe
Object
atributoDeInstancia
main

estes mtodos. Alm dos mtodos herdados, a camada externa tambm apresenta dois noos componentes: o
atributo atributoDeInstancia e o mtodo main.
Lm termos mais gerais, se oc tier uma classe-ilha qualquer que estende alguma outra classe-pai qualquer, a
classe-pai geralmente estende diretamente a classe raiz Objet, e a classe-ilha estende-a tambm, indiretamente.
Mas quais sao estes mtodos herdados por elas Vamos descobrir!
Obtendo informaes sobre uma classe
O primeiro mtodo da classe Object que ns amos estudar o mtodo getClass ,retornar classe,. Quando
chamado, o mtodo getClass() retorna uma reerencia para um objeto do tipo Class ,classe,. O mtodo
getClasse declarado final, logo, oc nao pode sobrescree-lo em uma subclasse. Um objeto da classe Class
contm diersos mtodos que retornam diersas inormaoes sobre uma classe, tais como seus construtores,
atributos e inormaoes sobre mtodos.
Um objeto da classe Class permite com que o programador determine ,descubra, dinamicamente o nome, os
atributos, os mtodos e etc, de um objeto qualquer. Para descobrir o nome da classe ,tipo, de um objeto
qualquer utilize o mtodo getName(), que retorna uma String que contm esse nome.
O metodo getClass() no pode ser utilizado em um tipo de dado primitivo, tal como char, int ou loat,
porque eles nao sao objetos. Por outro lado, a linguagem Jaa permite com que oc descubra o tipo de qualquer
ariael atras do operador .class, que dee ser utilizado como suixo da ariael na qual se deseja descobrir o
tipo. Lsse operador pode ser utilizado mesmo que oc ainda nao tenha criado um objeto ,ja o getClasse exige
que oc tenha criado um objeto,. Lxemplo:
Class classe1, classe2, classe3, classe4;
char letra = c;
Empregado e = new Empregado();
classe1 = Empregado.class; // vlido: um tipo de vrivel
classe2 = char.class; // vlido: um tipo de vrivel
classe3 = e.getClass(); // vlido: um objeto
classe4 = Empregado.getClass(); // invlido: no um objeto
classe5 = c.getClass(); // invlido: no um objeto
classe6 = c.class; // invlido: no um tipo de varivel
classe7 = e.class; // invlido: no um tipo de varivel
Logo, quando oc estier trabalhando com um objeto, utilize o mtodo getClass. Porm, se oc estier
trabalhando com um tipo de ariael, utilize o .class`. As classes Object e Class possuem uma srie de outros
mtodos que oc pode utilizar. Conira na tabela seguinte alguns destes mtodos e para que eles serem:

classe Object classe Class
Metodo Utilidade Metodo Utilidade
getClass,, Retorna uma reerncia do tipo
Class que contm inormaoes
sobre a classe do objeto.
getName,, Retorna uma String contendo o
nome da classe do objeto.
clone,, Retorna um clone ,uma cpia,
idntica do objeto ,eja seao
seguinte,.
equals,objeto, Compara o objeto atual com o
objeto passado como parametro.
Se eles orem iguais retornado
um alor booleano true
,erdadeiro,. Caso contrario false
,also,.
getSuperClass,, Retorna uma reerncia do tipo
Class que contm inormaoes
sobre a classe-pai da classe do
objeto.
classe Iield (atributo)
Metodo Utilidade
get1ype,, Retorna uma reerncia do tipo
Class que contm inormaoes
sobre o tipo ,classe, do atributo.
getDeclaredlield,atributo, Retorna uma reerncia do tipo
Iield ,atributo, que contm
inormaoes sobre o atributo de
classe solicitado. Atributo uma
String que contm o nome do
atributo desejado.
Clonagem
Clonagem o processo de azer duplicatas exatas de uma entidade. A linguagem Jaa suporta a clonagem atras
do mtodo clone(), que pertence a classe Object. O mtodo clone retorna uma reerencia para um objeto que
exatamente a duplicata do objeto que a chama. Durante a operaao de clonagem, o construtor do objeto nao
chamado. Como resultado, o mtodo clone cria uma duplicata de um objeto mais rapidamente que a utilizaao
do comando new, seguido de uma chamada ao construtor do objeto.
O mtodo clone retorna uma reerncia para um objeto do tipo Object. Logo, antes de colocar esse objeto
clonado em uma ariael oc tem que nomea-lo ,cast, para o tipo adequado ,tipo do objeto original, que oi
clonado,:
Empregado e1 = new Empregado(); // cria um empregado
Empregado e2 = (Empregado) e1.clone();
O mtodo clone um mtodo protegido. Isso signiica que somente aquelas classes ilhas da classe Object
podem utiliza-lo, azendo com que objetos possam clonar a si mesmos, mas nao possam clonar outros objetos.
A clonagem de um objeto pode ser supericial ,shallow, ou prounda ,deep,. O mtodo clone sempre realiza
uma clonagem do tipo supericial. Na clonagem superficial, somente os contedos dos, atributos e nao os
objetos reerenciados por estes atributos, que sao clonados.
A clonagem profunda enole, primeiramente, a realizaao da clonagem supericial. Aps, os atributos deem
ser atribudos para reerncias de noos objetos. linalmente, estes objetos deem ser populados ,preenchidos,
com inormaoes duplicadas ,clonadas,.
Igualdade
Comparar duas ariaeis para eriicar se o seu contedo igual e comprar dois objetos para eriicar se eles sao
iguais sao tareas dierentes. Quando oc quer comparar o contedo de duas ariaeis, oc utiliza o operador
de igualdade ,~~,.
O que o operador de igualdade az comparar se o contedo de duas ariaeis igual. Se seus contedos orem
iguais, ele retorna o valor Booleano true ,erdadeiro,. Se elas orem dierentes, o alor false retornado. Lsse
operador unciona muito bem com tipos primitios de dados ,int, loat, double...,.
Ja nos outros tipos de ariaeis, quando oc estier trabalhando com objetos, errado utilizar esse operador.
Isso porque essas ariaeis nao contm os objetos em si, mas, sim, reerncias para estes objetos. Logo, o
comparador de igualdade estaria comparando duas reerncias ,endereos, e nao o contedo dos objetos.
Para comparar dois objetos oc dee utilizar o mtodo equals. Veja a dierena entre os dois:
String nome1 = Leonardo;
String nome2 = Leonardo;
System.out.println(nome1 == nome2 : + nome1 == nome2); // false
System.out.println(nome1.equals(nome2): + nome1.equals(nome2) ); // true
Se voc utilizar uma das classes j existentes da linguagem Java, o metodo equals funcionar muito
bem. Porm, se voc criar uma nova classe ele no vai funcionar corretamente. Isso porque o mtodo
equals padrao utiliza, internamente, o operador de comparaao ,~~,. Para que ele funcione corretamente
voc deve redefinir (reescrever) este metodo dentro da sua classe de modo que ele possa realizar a
comparaao correta.