Bsicos da Orientao a Objetos em Java[1]

(www.javaworld.com/javaworld/jw-04-2001/jw-0406-java101_p.html) Artigo de Jeff Friesen, publicado originalmente na revista JavaWorld (www.javaworld.com), Copyright ITworld.com, Inc., Novembro de 2000. Reimpresso, adaptado e traduzido com permisso do autor.

Traduzido e adaptado por Leandro Krug Wives

(Clique aqui para baixar esse arquivo em formato PDF)

Parte I: Aprenda a declarar classes e criar objetos

Existem, basicamente, duas metodologias de desenvolvimento de software: a Programao Estruturada (PE) e a Programao Orientada a Objetos (POO). Na primeira, o objetivo consiste em separar os dados da funcionalidade do programa. Neste caso, as entidades so representadas de forma tal que satisfaam as restries da linguagem de programao utilizada. Isso acaba gerando programas que so difceis de manter e compreender, principalmente se eles forem muito grandes. Na segunda, a linguagem de programao que tem de satisfazer as restries e requisitos das entidades. Isso permite a construo de modelos mais realsticos do mundo, e, portanto, mais fceis de serem mantidos e compreendidos. Vamos tomar como exemplo a representao de um carro. Vamos descobrir que cada metodologia modela de forma diferente esse carro. Na PE, por exemplo, um carro representado por um conjunto de funes (trechos de cdigo) responsveis por ligar, frear, estacionar, acelerar e assim por diante. Um conjunto separado de variveis define a cor do carro, seu modelo, fabricante e demais caractersticas. Voc deve ento inicializar (atribuir valores) s variveis do carro e chamar algumas das funes para manipular estas variveis para que o carro funcione. J na POO, o carro visto como uma integrao de seus comportamentos (suas funes) e atributos (variveis) que mantm o estado atual do carro. A integrao destes atributos e comportamentos resulta em um objeto. A criao deste objeto simples e faz com que ele seja inicializado ao mesmo tempo sem comandos adicionais. Neste caso, um programa orientado a objetos pensa em objetos e no em funes e variveis separadas e soltas (na PE o programador que sabe quais funes e quais variveis pertencem ao carro; na POO, o prprio programa controla isso para o programador). A integrao destes atributos e comportamentos em objetos chamada de "encapsulamento". O encapsulamento tambm permite com que as informaes dos objetos fiquem escondidas, limitando o acesso a variveis e funes que no necessitam ser manipuladas ou acessadas fora do objeto. A orientao a objetos j existe h 15 anos, porm, eram poucas as linguagens que suportavam-na corretamente e por completo. Atualmente existem linguagens, tais como o Java, que suportam completamente a orientao a objetos. Devido a isso, todo programa escrito em Java necessita da presena de pelo menos uma classe. Mas o que uma classe? Bem, os objetos no surgem do nada. Assim como um mestre de obras necessita de um esquema de engenharia para realizar a construo de um prdio (a planta do prdio), um programa necessita de uma classe para criar objetos baseados nesta classe. A classe como se fosse o esquema (a receita) que indica como criar objetos do seu tipo. Esse esquema ou receita indica quais so os comportamentos, as caractersticas e o estado (valor) destas caractersticas nos objetos criados a partir dela.

Declarando Classes
A classe a planta ou esquema (em formato de cdigo Java) que indica como os objetos so criados, quais os seus comportamentos e variveis de estado. Para criar declarar uma classe voc deve utilizar a seguinte sintaxe[2]:

[plvacae]lsnm_acas aar-hv cas oed_lse { / cmotmno evressodcaao edsrtseteoeo / opraets aivi elrds ecio nr { } }

Logo, para declarar uma classe, coloque a palavra class seguida de um identificador (representado por nome_da_classe) que ir servir de nome para a classe. O identificador pode ser qualquer palavra, com exceo de alguma palavra reservada da linguagem (ou seja, algum comando). Por exemplo, class Conta introduz a declarao de uma nova classe onde Conta o nome da classe. Note que, por conveno, o nome de uma classe inicia sempre com uma letra maiscula. A palavra-chave opcional (pois est entre colchetes), e pode ser qualquer uma das seguintes: public, abstract, public abstract ou final. Utilize a palavra-chave public (sem as apstrofes) para criar um nome de classe que possa ser utilizado em qualquer outra classe de qualquer programa ou pacote[3]. Se voc no colocar public na frente de uma declarao de classe, ela s poder ser utilizada dentro do cdigo de programa ou pacote atual. importante salientar que voc pode declarar mais de uma classe por arquivo, porm, somente uma delas poder ser public (pblica). Neste caso, o nome do arquivo do cdigo-fonte dever ser o mesmo da classe pblica. Exemplo:
pbi casMnalse ulc ls ihCas {}

Neste caso, o nome do arquivo onde MinhaClasse foi definida deve se chamar MinhaClasse.java. Declarar essa classe (pblica) em outro arquivo no permitido e deve gerar um erro do compilador. Note que o Java considera diferentes letras maisculas e minsculas. Logo, o nome da classe e o nome do arquivo devem ser exatamente iguais (em termos de letras maisculas e minsculas). Isso significa que o nome do arquivo deve ser escrito com o M maisculo (de Minha) e C maisculo (de Classe). As demais letras devem ser minsculas. Utilize a palavra-chave abstract para indicar que a classe corresponde a uma classe abstrata. Classes abstratas no podem ser utilizadas para a criao de objetos. Elas s servem como classes-pai, para que classes-filhas sejam criadas a partir delas. Utilize a palavra-chave final para declarar uma classe final. Classes finais no podem ser utilizadas como classes-pai, impedindo com que classes-filhas sejam criadas a partir delas (e herdem seu comportamento e estados). Essas palavras-chave podem ser utilizadas em qualquer ordem. Voc s no pode especificar uma classe como sendo abstrata e final ao mesmo tempo, pois isso no faz sentido, j que classes abstratas s servem para a criao de classes-filhas e classes finais s funcionam como classes filhas. Cada classe possui um corpo onde voc declara os comportamentos (mtodos) e variveis de estado (atributos ou campos). O corpo comea com o caractere { e termina com o caractere } .

Criando Objetos
Um objeto uma instncia de uma classe. Para criar um objeto, utilize a seguinte sintaxe:
ecntuo nw osrtr

O comando new (que significa novo em Ingls), tambm conhecido como operador de criao, cria um novo objeto, alocando memria para o objeto e inicializando essa memria para valores default (padro). O comando new necessita de um operando: o construtor, que o nome de um mtodo especial que constri o objeto. Uma vez construdo, o objeto deve ser atribudo a uma varivel, para que possa ser utilizado e referenciado no futuro. Preste ateno ao exemplo seguinte:
casPso{ ls esa } casPormEepo ls rgaaxml{ pbi sai vi mi(tig prmto[) ulc ttc od anSrns aaers]{

Pso uaesaulur / dcaauavre qepd amznrojts esa mPsoQaqe; / elr m aivl u oe raea beo / d tp Pso (eiion cas atro) / o io esa dfnd a lse neir uaesaulur=nwPso(;/ ci uanv pso eclc- n mPsoQaqe e esa) / ra m oa esa ooaa a / vre uaesaulur / aivl mPsoQaqe } }

No exemplo anterior foi definida uma classe chamada Pessoa e aps, no programa principal, foi criada uma varivel chamada umaPessoaQualquer para receber um objeto do tipo pessoa (note que o tipo da varivel Pessoa, pois a varivel declarada de forma similar declarao de variveis do tipo int qualquer outro tipo natural da linguagem). Aps, um novo objeto do tipo Pessoa criado, atravs do comando new Pessoa(). Esse objeto colocado na varivel umaPessoaQualquer atravs do comando de atribuio (sinal de igual). Em Java, voc pode criar e atribuir um novo objeto a uma varivel, simultaneamente. Basta colocar tudo na mesma linha da seguinte forma:
Pso uaesaulur=nwPso(; esa mPsoQaqe e esa)

Destruindo objetos
A linguagem Java assume a responsabilidade de destruir qualquer objeto que voc tenha criado e no esteja mais usando. Ela faz isso atravs de um processo especial chamado coletor de lixo (garbage collector), que executado em intervalos regulares, examinando cada objeto para ver se ele ainda referenciado por alguma varivel. Caso o objeto no seja utilizado ao menos por uma varivel, ele destrudo e sua memria liberada.

Parte II: Declarando e acessando atributos e mtodos

Em Java, as variveis podem ser divididas em trs categorias: atributos (tambm chamados de campos), parmetros e variveis locais. No incio desta seo ser explorado o primeiro tipo o atributo. Os demais tipos sero discutidos em conjunto com os mtodos, apresentados em seguida.

Declarando atributos
Um atributo ou campo uma varivel declarada no corpo de uma classe. Ele serve para armazenar o estado de um objeto (e neste caso chamado de atributo de instncia) ou o estado de uma classe (atributo de classe). A sintaxe de declarao de um atributo a seguinte:
[(ulc |rvt|rtce)] pbi piae poetd [(ia|oaie )] fnl vltl [ttc ][rnin] sai taset tp_edd nm_oarbt [epeso] iod_ao oed_tiuo = xrs ;

A declarao de um atributo especifica 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 expresso opcional (que inicializa o atributo), especificadores de acesso e modificadores. Voc pode dar qualquer nome ao atributo, desde que este nome no corresponda a uma palavrareservada da linguagem. Por questes de padronizao, o nome de um atributo sempre comea com uma letra minscula. Considere o exemplo:
casEpeao ls mrgd{ Srn nm; tig oe / onm d epeao / oe o mrgd dul slro / oslrod epeao obe aai; / ai o mrgd it n iCro / ietfcdrd cdg d fn qeeeeec dag / dniiao o io a uo u l xre }

Neste exemplo, a classe chamada Empregado declara trs atributos: nome, salrio e idCargo (identificador do cargo). Assim, quando voc cria um objeto do tipo Empregado, o campo nome mantm uma referncia para uma string contendo o nome do empregado. O campo salrio armazena o seu salrio, e o campo idCargo armazena um nmero que identifica a categoria ou funo que ele exerce na empresa.

Especificadores de acesso
Opcionalmente, voc pode utilizar uma palavra-chave modificadora de acesso ao declarar um atributo. As palavras-chave modificadoras de acesso so as seguintes: public, private ou protected. O modificador de acesso determina quo acessvel o atributo para o cdigo de outras classes do seu programa. Essa acessibilidade pode variar de completamente inacessvel at completamente acessvel. Se voc no especificar um modificador de acesso, o Java assume o acesso padro, que permite com que o campo seja acessvel a classe no qual ele foi declarado e tambm a todas as classes existentes no mesmo arquivo (cdigo-fonte) ou pacote (biblioteca de classes) da classe que o declarou. Se voc declarar um atributo como sendo privado (private), somente o cdigo contido na sua classe pode acess-lo. Este atributo permanece escondido para qualquer outra classe, mesmo para as classes-filhas da classe ao qual foi declarado (neste caso, elas conseguem herd-lo, mas no conseguem manipul-lo). Se voc declarar um atributo como sendo pblico (public), o cdigo contido na sua classe e em todas as outras classes em qualquer pacote (biblioteca) pode acess-lo. Um atributo protegido (protected) possui o nvel de acesso padro, porm, as sub-classes (classes-filhas) da classe para o qual foi declarado tambm podem utiliz-lo.
casEpeao ls mrgd{ pbi ulc Srn nm; tig oe / sunm (ie qaqe cas) / e oe vsvl ulur lse piae dul slro / suslro(ncse fr d cas) rvt obe aai; / e ai iaesvl oa a lse poetdit rtce n iCro / cdg d cro(csiiiaepd) dag / io o ag aesbldd aro }

Mas, afinal, para que servem os modificadores de tipo? Bem, eles so utilizados para implementar o conceito de esconderijo ou encoberta de informao (information hiding) e encapsulamento. Para compreender melhor, vamos fazer uma analogia: suponha que voc crie classes chamadas de Corpo, Olho, Corao e Pulmo para modelar o corpo humano, os olhos, o corao e os pulmes de uma pessoa. A classe Corpo declara atributos para referenciar os olhos, o corao e os pulmes, como demonstrado no exemplo seguinte:
pbi casCro ulc ls op{ pbi Oh ulc lo ohEqed,loiet; losuroohDrio piaeCrocro rvt oa oa; piaePl plEqed,plDrio rvt umo umosuro umoiet; }

Os atributos olhoEsquerdo e olhoDireito so pblicos porque os olhos das pessoas so visveis para qualquer observador. J o corao, o pulmoEsquerdo e o pulmoDireito so privados porque os rgos que estes atributos representam esto escondidos dentro do corpo de uma pessoa. Se eles tivessem sido declarados pblicos, uma pessoa teria seu corao e pulmes vista... Muito estranho, voc no acha?

Modificadores
Voc pode utilizar, opcionalmente, uma palavra-chave modificadora: final ou volatile e/ou static e/ou transient. Se voc utilizar o modificador final na declarao de um atributo o compilador assume que esse campo uma constante (uma varivel somente de leitura que no pode ser modificada). Neste caso o compilador faz ajustes e otimizaes internas no cdigo do programa, j que ele sabe que esta varivel no ser modificada em momento algum da execuo do programa. O exemplo seguinte declara trs constantes. Note que as constantes so obrigatoriamente inicializadas na sua declarao. Alm disso, todas as letras do nome de uma constante so maisculas, por conveno. Assim, voc pode rapidamente saber se est trabalhando com uma varivel comum ou com uma constante (j que as constantes possuem todas as suas letras em maisculo e as variveis comuns no).
casEpeao ls mrgd{ fnlitFXNIO=1 ia n AIER ;

fnlitPORMDR=2 ia n RGAAO ; fnlitGRNE=3 ia n EET ; itiCro=PORMDR n dag RGAAO; }

Se voc declara um atributo utilizando o modificador volatile (voltil), vrias Threads (linhas ou processos de execuo) 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 for declarado como sendo static (esttico) todos os objetos compartilham (utilizam) a mesma cpia da varivel. Se um dos objetos modifica esse atributo todos os outros objetos enxergam essa mesma modificao. Neste caso, o atributo considerado um atributo de classe e no de objeto. Se voc no especificar o modificador static cada objeto vai possuir a sua cpia especfica deste atributo. Finalmente o modificador transient indica que o atributo no ser utilizado em uma operao de serializao do objeto (salvamento em arquivo ou envio de um objeto para outro computador ou programa). Esse processo no ser abordado aqui, logo, para maiores informaes, consulte a WEB ou um livro de Java.

Atributos de objetos (de instncia)

Um atributo de objeto (tambm conhecido por atributo de instncia) uma varivel declarada sem o modificador static. Os atributos de instncia pertencem (so associados) aos objetos e no s classes. Quando um atributo de objeto modificado, somente o objeto a que ele pertence enxerga a alterao (isso porque cada objeto possui o seu). Um atributo de objeto (ou instncia) criado quando o objeto criado (comando new) e destrudo quando o objeto a que pertence for destrudo. Veja o exemplo:
casEpeao ls mrgd{ pbi itcro ulc n ag; pbi vi cnrtCmPormdrvi) ulc od otaaoorgaao(od{ cro=2 / Di ocdg d pormdr ag ; / os io e rgaao } }

Para acessar o atributo de objeto em um mtodo pertencente mesma classe da qual o objeto foi criado (ou seja, um mtodo tambm pertencente ao objeto), simplesmente especifique o nome do atributo (o nome da varivel). No exemplo anterior, o atributo cargo acessado simplesmente pela utilizao do seu nome (veja a linha grifada). Se voc quiser acessar um atributo em um mtodo de outro objeto, voc vai necessitar de uma referncia (uma varivel) ao objeto ao qual o atributo pertence. Utilize essa varivel como prefixo do atributo, seguido do caractere . (ponto). Aps, especifique o atributo desejado:
casEpeao ls mrgd{ pbi itcro ulc n ag; pbi vi cnrtCmPormdrvi) ulc od otaaoorgaao(od{ cro=2 / Di ocdg d pormdr ag ; / os io e rgaao } } casPormEepo ls rgaaxml{ / Es porm uiiaacas Epeao(neir / se rgaa tlz lse mrgd atro)

pbi sai vi mi(tigprmto[) ulc ttc od anSrn aaers]{ Epeaoepeao=nwEpeao) / ci u ojt epeao mrgd mrgd e mrgd(; / ra m beo mrgd epeaocro=2 / md oarbt crod u epeao mrgd.ag ; / ua tiuo ag e m mrgd }

Note a diferena: os mtodos da classe Empregado podem utilizar o atributo cargo diretamente; j os mtodos da classe ProgramaExemplo devem sempre criar um objeto do tipo Empregado e utilizar esse objeto para ter acesso ao atributo (empregado.cargo). Isso serve para quando voc tiver vrios objetos (vrios empregados) e necessitar alterar o atributo de um deles. Imagine que seu programa tenha quatro variveis do tipo empregado e um deles tenha mudado de cargo. Essa mudana muito fcil de ser feita, basta voc informar qual objeto (qual empregado) que deve sofrer a alterao, seguido do seu atributo cargo, e pronto:
casPormEepo{ ls rgaaxml2 / Es porm uiiaacas Epeao(neir / se rgaa tlz lse mrgd atro)

pbi sai vi mi(tigprmto[) ulc ttc od anSrn aaers]{ Epeaoepeao =nwEpeao) mrgd mrgd1 e mrgd(; Epeaoepeao =nwEpeao) mrgd mrgd2 e mrgd(; Epeaoepeao =nwEpeao) mrgd mrgd3 e mrgd(; Epeaoepeao =nwEpeao) mrgd mrgd4 e mrgd(; epeao.ag =3 / md ocrod epeao pr grne mrgd1cro ; / ua ag o mrgd1 aa eet epeao.ag =1 / md ocrod epeao pr fxnio mrgd2cro ; / ua ag o mrgd2 aa aier epeao.ag =2 / md ocrod epeao pr pormdr mrgd3cro ; / ua ag o mrgd3 aa rgaao epeao.ag =2 / md ocrod epeao pr pormdr mrgd4cro ; / ua ag o mrgd4 aa rgaao } }

Quando a Mquina Virtual Java (MVJ ou Virtual Java Machine JVM, que o computador virtual onde um programa em Java executado) cria um objeto, ela aloca memria para todos os atributos do objeto e zera essa memria, inicializando-a. Esse valor inicial depende do tipo do atributo. Para tipos naturais numricos o valor inicial zero (0 ou 0.0). Os valores booleanos so inicializados em false (falso). Para os demais tipos de atributos (referncias construdas a partir de outras classes) o valor inicial NULL (nulo).

Atributos de classes
Um atributo de classe um atributo declarado com o modificador static. Os atributos de classe so associados com a classe e no com os objetos (ou instncias) criados a partir dela. Isso significa que quando um atributo de classe modificado, todos os objetos criados a partir da mesma classe enxergam a alterao. Veja o exemplo:
casEpeao ls mrgd{ sai itnmrDEpeao;/ arbt d cas ttc n ueoemrgds / tiuo e lse pbi itcro ulc n ag; } casPormEepo { ls rgaaxml3 pbi sai vi mi(tigprmto[) ulc ttc od anSrn aaers]{ Epeaoepeao =nwEpeao) / ci u ojt epeao mrgd mrgd1 e mrgd(; / ra m beo mrgd epeao.ueoemrgds=1 mrgd1nmrDEpeao ; epeao.ag =2 mrgd1cro ; Epeaoepeao =nwEpeao) / ci u nv epeao mrgd mrgd2 e mrgd(; / ra m oo mrgd epeao.ag =3 mrgd2cro ; epeao.ueoemrgds=2 / mdfc avre d cas mrgd2nmrDEpeao ; / oiia aivl e lse Sse.u.rnl(mrgd1cro;/ ipieocrod epeao ytmotpitnepeao.ag) / mrm ag o mrgd1 Sse.u.rnl(mrgd1nmrDEpeao) ytmotpitnepeao.ueoemrgds; / vimsrr2 / a ota / pru avre nmrDEpeao d cas Epeao(ner) / oqe aivl ueoemrgds a lse mrgd itia / enosmned epeao o d epeao / oet o mrgd1 u o mrgd2 / arbt d isca(beo / tiuo e ntni ojt)

Sse.u.rnl(mrgd2cro;/ ipieocrod epeao ytmotpitnepeao.ag) / mrm ag o mrgd2 } }

No exemplo anterior, quando o atributo numeroDeEmpregados modificado em um dos objetos, todos sofrem a mesma alterao, pois, diferente do atributo de objeto (onde cada um possui uma cpia diferente do atributo), ele pertence classe e no ao objeto. Similarmente, voc pode definir mtodos de classe e mtodos de objeto. A funo main de um programa um exemplo. Note que ela sempre definida como um mtodo de classe, pois possui o modificador static: public static void main(String parametros[]). Saiba mais sobre mtodos na seo seguinte: Declarando mtodos. Observao: Atributos de classes so as coisas mais prximas variveis globais que a linguagem Java oferece.

Constantes
Uma constante uma varivel que s permite a leitura do seu contedo (valor). Uma vez definida, uma constante no pode mais ser modificada. As constantes so declaradas atravs da palavra-chave final. As constantes tambm podem ser de classe ou de objeto. Por questes de performance, sempre crie constantes de classe, como no exemplo:
casPormEepo { ls rgaaxml4 fnlsai TTL=1; ia ttc OA 0 pbi sai vi mi(tigprmto[) ulc ttc od anSrn aaers]{ itcnao =0 n otdr ; wiecnao <TTL cnao+; hl(otdr OA) otdr+

} } Esse exemplo cria uma constante chamada TOTAL e inicializa-a com o valor 10. O valor de TOTAL no pode ser alterado em momento algum do programa. Caso voc tente alter-lo o compilador Java acusar um erro. Note que a constante foi definida com todas as suas letras em formato maisculo. Apesar de no ser obrigatrio fazer isso, por questes de padronizao as constantes so escritas com letras maisculas. Deste modo, voc pode identificar no seu programa quais variveis correspondem a atributos comuns e quais correspondem a constantes. Utilize constantes pelas seguintes razes: 1) Constantes facilitam a leitura e o entendimento do cdigo-fonte, pois fazem mais sentido do que um nmero sem explicao (TAMANHO_DO_VETOR, por exemplo, mais significativo do que o nmero 20); 2) mais fcil modificar o valor inicial de uma constante do que trocar todas as ocorrncias de determinado valor no cdigo-fonte. Agora que voc j aprendeu a declarar atributos, voc vai precisar aprender a declarar e utilizar mtodos.

Declarando mtodos
A linguagem Java utiliza o termo mtodo para se referir a trechos de cdigo que so associados classes. Se os atributos servem para manter ou armazenar o estado ou o valor de um objeto, os mtodos servem para descrever os comportamentos de um objeto ou classe. Um mtodo muito similar a uma funo em linguagem C. A maior diferena que os mtodos da linguagem Java so declarados completamente dentro de uma classe. Para declarar um mtodo utilize a seguinte sintaxe:
[(ulc |rvt|rtce)] pbi piae poetd ([btat ]|[ia][ttc ][aie ] [snhoie]) asrc fnl sai ntv ycrnzd tp_ertronm_omtd [lsad_aers] iod_eon oed_oo ( it_eprmto ) crod_oo op_omtd

A declarao de um mtodo consiste de uma assinatura do mtodo seguida por seu corpo ou trecho de cdigo. A assinatura do mtodo especifica o seu nome, tipo de retorno, lista de parmetros, especificadores de acesso, modificadores e os tipos de exceo que o mtodo pode gerar (excees sero discutidas em um outro momento). O corpo do mtodo um grupo ou bloco de comandos que so executados quando o mtodo chamado por um outro mtodo. O corpo de um mtodo sempre declarado dentro de colchetes { }. O nome do mtodo identifica-o. Escolha um identificador (nome) que no corresponda a uma palavra-reservada da linguagem Java. Precedendo o nome do mtodo h sempre o tipo de retorno. Ele identifica o tipo de dado que o mtodo retorna, podendo indicar tambm que o mtodo no retorna nada. Os valores possveis para ele so: 1) Um dos tipos de dados primitivos: boolean, byte, char, double, float, int, long ou short; 2) Uma referncia a um objeto (nome da classe do objeto que ser retornado); 3) O tipo void, indicando que o mtodo no retorna valor algum. Um par de parnteses (abre e fecha-parnteses) segue o nome do mtodo. Esse par de parnteses obrigatrio. Opcionalmente voc pode declarar, dentro destes parnteses, uma lista de variveis separadas por vrgulas. Cada uma destas variveis conhecida como parmetro. Assim, quando o mtodo chamado (em algum lugar do programa) uma lista de expresses separadas por vrgulas (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 so apresentados alguns exemplos de assinaturas de mtodos:
itcnat(n lmt) n otAit iie Dcaau mtd caaocnat,qercb u prmtoe uavre caaalmt ertra elr m oo hmd otA u eee m aer m m aivl hmd iie eon u vlrdcmlitio(n)a opoesmno m ao eia ner it ps rcsaet. itsm(n a itb n oait , n ) Dcaau mtd caaosm,qercb di prmto dcmi itio:opier n vre elr m oo hmd oa u eee os aers eias ners rmio a aivl aeosgnon vre b A opoesmnoafn rtrau vlrdcmlitio(n) eud a aivl . ps rcsaet uo eon m ao eia ner it. vi ipieSrn txo od mrm(tig et) Dcaau mtd caaoipie qercb u prmtod tp Srn n vre txo Afn elr m oo hmd mrm, u eee m aer o io tig a aivl et. uo poes enortravlrpr qe acao. rcsa eon ao aa um hmu fotsreaoavi) la otiNt(od Dcaau mtd caaosreaoa qenorcb prmtoagmertrau nmr d pno elr m oo hmd otiNt, u eee aer lu eon m eo e ot fuune(aua,cmvrua,d tp fot pr qe acao. ltat ntrl o gl) o io la, aa um hmu

Vamos ver um exemplo de um mtodo completo, que inclua o seu corpo:

itsm(n lmt) n oait iie { / ii d crod mtd / nco o op o oo itttl n oa; fr(n i=1 i=lmt;i+ o it ; < iie +) ttl+ i oa = ; rtr ttl eun oa; } / fmd crod mtd / i o op o oo Crod mtd op o oo Asntr d mtd siaua o oo

Neste ltimo exemplo, a primeira linha corresponde assinatura do mtodo. Essa assinatura indica que o mtodo retorna um valor do tipo int (um nmero inteiro decimal). Alm disso, ela indica que o mtodo se chama soma e recebe um parmetro decimal inteiro, chamado limite. O corpo do mtodo inicia com o abre-colchete { . Segue-se, em seguida, uma srie de comandos que executam determinadas

tarefas em funo do parmetro recebido (no caso, a soma dos nmeros existentes entre 1 e o valor passado como parmetro em limite). O corpo do mtodo termina quando o fecha-colchete } correspondente encontrado. Note que na linha anterior ao fecha-colchete o comando return utilizado. Esse comando faz com que o valor da varivel total seja retornado. O tipo da varivel ou valor retornado deve ser o mesmo que foi 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 variveis correspondentes de parmetros), processa-os e ento, opcionalmente, retorna um valor para quem chamou esse mtodo. Para fins de exemplo, vamos supor que voc tenha criado um mtodo para calcular a raiz-quadrada de um nmero e que agora voc esteja fazendo um programa que necessite deste mtodo. O cdigo do seu programa chama o mtodo de clculo da raiz-quadrada passando o valor (nmero) do qual voc deseja saber a raiz quadrada. O mtodo de clculo de raiz-quadrada recebe o argumento passado (o valor, que poderia at mesmo estar em uma varivel) via o parmetro correspondente. Aps algum tempo de processamento, o mtodo retorna a raiz-quadrada do valor solicitado para o programa que o chamou. Veja o exemplo:
casMtmtc { ls aeia fotriQard(la nmr) la azudaafot ueo{ fotb=nmr *nmr; la ueo ueo / cdg qecluaari qard d nmr psaocm prmto / io u acl az udaa o eo asd oo aer } } casPormEepo{ ls rgaaxml pbi sai vi mi(tigagmno[) ulc ttc od anSrn ruets] { Mtmtc fnosaeaia =nwMtmtc; aeaia uceMtmtcs e aeaia fot la rslao eutd, nmr ueo =2; 0 / cluaari-udaad nmr 1: / acl azqard o eo 0 rslao=fnosaeaia.azudaa1) eutd uceMtmtcsriQard(0; Sse.u.rnl(Ari-udaad 1 +rslao; ytmotpitn azqard e 0 : eutd) / cluaari-udaad vre nmr (u vl 2) / acl azqard a aivl eo qe ae 0: rslao=fnosaeaia.azudaanmr) eutd uceMtmtcsriQard(ueo; Sse.u.rnl(Ari-udaad +nmr + +rslao; ytmotpitn azqard e ueo : eutd) } }

Neste ltimo exemplo, o ProgramaExemplo chama o mtodo raizQuadrada (nas linhas grifadas), passando como parmetro valores (um nmero, no primeiro caso, e o contedo de uma varivel, no segundo). Durante a chamada, quando o mtodo executado, a Mquina Virtual Java (Java Virtual Machine JVM) cria dentro dele uma varivel chamada numero e atribui o valor passado como parmetro para essa varivel. Qualquer comando existente dentro do corpo do mtodo raizQuadrada pode acessar e utilizar a varivel numero. Isso porque a varivel declarada como parmetro uma varivel como outra qualquer do mtodo, e pode ser utilizada dentro dele, em qualquer lugar, normalmente. Por ser uma varivel do mtodo, numero s pode ser utilizada dentro dele (os outros mtodos no a enxergam, mesmo que tenham sido declarados dentro da classe Matemtica). Quando a execuo do mtodo acaba a JVM destri o parmetro numero. Apesar dos parmetros e as variveis locais de um mtodo no poderem ser acessadas fora dele, e serem muito parecidas por esse motivo, existem diferenas entre o escopo de um parmetro e o escopo[4] de uma varivel local. O parmetro vale dentro de todo o corpo do mtodo, enquanto que uma varivel local vale a partir do local onde ela foi declarada. Veja o exemplo seguinte:
0 1 0 2 0 3 0 4 0 5 0 6 0 7 0 8 casMtmtc { ls aeia itsm(n lmt) n oait iie{ Sse.u.rnl(Ovlrd lmt +lmt) / O ytmotpitn ao e iie : iie; / K Sse.u.rnl(Ovlrd ttl +ttl;/ Er! ytmotpitn ao e oa : oa) / ro itttl n oa; / Polm! / rbea

fr(n i=1 i=lmt;i+{ o it ; < iie +) ttl+ i oa = ; }

0 9 1 0 1 1 1 2 } }

Sse.u.rnl(Ovlrd i +i;/ Er! ytmotpitn ao e : ) / ro rtr ttl eun oa;

Neste ltimo exemplo a 4a linha apresenta um erro, pois o programador tentou utilizar a varivel total e ela ainda no havia sido declarada. Nunca utilize uma varivel local antes dela ter sido declarada. Tambm h um erro na linha 9. Neste caso a varivel i foi declarada dentro de um bloco interno (o bloco do comando for) e seu escopo (validade) consiste somente no corpo do comando for, entre o { e o }, logo, na 9a linha essa varivel j no existe mais. Nunca utilize uma varivel de um bloco interno em um bloco externo. Variveis locais tambm apresentam um outro problema em potencial: elas devem ser explicitamente inicializadas (sempre). Note que na linha 5 a varivel total declarada dentro do mtodo soma. Isso significa que ela uma varivel local deste mtodo e s pode ser utilizada dentro dele. Note tambm que ela no foi inicializada (algo do tipo: int total = 0). Isso ocasionaria um problema pois o lao (for) utiliza-a como acumulador do valor da varivel i e seu valor inicial desconhecido (e deveria ser zero). Sempre inicialize suas variveis locais a fim de evitar erros que podem surgir pela falta de um valor inicial de uma varivel. Examine agora o comando return da linha 10. Esse comando retorna um valor para quem chamou o mtodo soma. A sintaxe deste comando a seguinte:
eun [xrs]; rtr epeso

Um comando de retorno consiste da palavra-chave return opcionalmente seguida de uma expresso. A menos que o tipo de retorno de um mtodo seja void (significando que a funo no retorna coisa alguma), voc deve sempre colocar aps o return uma expresso cujo tipo de dado seja igual ao tipo de retorno da funo. Alm disso, se o tipo de retorno no for void, a execuo do mtodo deve sempre terminar via 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 que o programa vai? Se a chamada do mtodo no fizer parte de uma expresso, a execuo continua no comando (linha ou declarao) seguinte chamada do mtodo. Caso contrrio, a expresso continua com o operador que avalia os outros operandos da expresso.

Especificadores de acesso
Voc utilizar um dos seguintes especificadores de acesso na declarao de um mtodo: public, private ou protected. O especificador determina o quo acessvel esse mtodo para o cdigo de outras classes de um programa. O acesso varia de totalmente acessvel totalmente inacessvel. O funcionamento muito similar ao dos atributos, vistos anteriormente. Se voc no utilizar um especificador de acesso o Java utiliza o nvel de acesso padro, fazendo com que o mtodo s possa ser chamado por outros mtodos declarados na mesma classe e em todas as classes do mesmo pacote. Se voc utilizar o especificador private (privado), somente o cdigo contido na mesma classe pode chamar esse mtodo:
casMtmtc { ls aeia piaeitftra(n nmr) rvt n aoilit ueo{ i( = 0 rtr 1 / ftra d zr 1 fn = ) eun ; / aoil e eo itpouo=1 n rdt ; friti=2 i< nmr;i+ pouo* i o(n ; = ueo +) rdt = ; rtr pouo eun rdt; } itprua(n n itr{ n emtoit , n ) rtr ftra()/ftra( r; eun aoiln aoiln )

} }

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 permutao. Como, neste caso, ele foi feito somente para ajudar o mtodo permutao, no faz sentido que outras classes vejam-no e utilizem-no. Quando um mtodo existe somente para ajudar os outros mtodos de uma classe ele deve ser declarado privado (private). Declarar mtodos deste tipo promove o ocultamento de informaes no relevantes ou no importantes para quem est fora da classe, alm de mant-la organizada e fcil de dar manuteno. Se voc declarar um mtodo utilizando a palavra-chave public o mtodo torna-se acessvel para toda e qualquer classe. Um mtodo protected (protegido) um mtodo com o nvel padro de acesso, com uma diferena: todas as classes filhas da classe na qual ele foi declarado podem acess-lo.

Modificadores
Os modificadores de mtodo disponveis em Java so os seguintes: abstract ou final e/ou static e/ou native e/ou synchronized. Se voc utilizar a palavra-chave abstract (abstrato), voc estar informando ao Java que a declarao consiste somente em uma assinatura do mtodo. Isso porque, em Java, um mtodo abstrato um mtodo sem corpo (sem bloco de comandos). Um mtodo abstrato no pode ser declarado, simultaneamente, como sendo final, nem static, nem synchronized e nem private. Se voc declarar um mtodo final, o compilador assume que ele no pode ser sobre-escrito (modificado) em sub-classes (classes-filhas). Se voc declarar um mtodo como sendo static (esttico), ele ser considerado um mtodo de classe e no um mtodo de objetos (algo similar aos atributos de classe e de objetos, que foram discutidos na seo anterior). Neste caso ele s poder acessar atributos de classe. Se essa palavra-chave no for utilizada, o mtodo considerado como sendo um mtodo de instncia (= de objeto), e poder acessar qualquer espcie de atributo (de classe ou de objeto). A palavra-chave native (nativo) indica para o Java que o corpo do mtodo foi escrito em C++ e est armazenado em alguma biblioteca especfica de plataforma (tal qual uma DLL). Neste caso, somente a assinatura do mtodo deve ser declarada. Finalmente, se voc utilizar o modificador synchronized (sincronizada), somente uma thread (linha de execuo) por vez pode executar o mtodo.

Mtodos de instncia
Mtodos de instncia so os mtodos de objetos. Estes mtodos podem acessar atributos de instncia e atributos de classe declarados na sua classe. Para declarar um mtodo de instncia, no especifique a palavra-chave static. Se seu mtodo de instncia possuir um parmetro que tenha o mesmo nome de um atributo de instncia da sua classe, seria possvel atribuir o valor do parmetro para o atributo de mesmo nome? Sim, isso pode ser feito da seguinte forma:
0 casEpeao{ 1 ls mrgd 0 2 0 3 piaedul slro rvt obe aai; vi autSlrodul slro{/ osreqeslroj eit od jsaaai(obe aai) / bev u aai xse / cm arbt d cas! / oo tiuo e lse ti.aai =slro / clc ocned d prmton arbt hsslro aai; / ooa oto o aer o tiuo }

0 4 0 5 0 } 6

Na terceira linha o mtodo ajustaSalario declara um parmetro chamado salario. Note que uma varivel (um atributo) contendo o mesmo nome j havia sido declarada anteriormente, na linha dois. Nesta situao, para que voc possa colocar o valor do parmetro no atributo (na varivel j existente), voc tem que utilizar o prefixo this. Essa palavra-chave identifica o objeto atual no cdigo-fonte. Quando voc utiliza esse prefixo, voc diz para o Java: acesse o atributo pertencente a esse objeto, cujo nome o seguinte.... O nome do atributo vem aps o ponto, como voc pode ver na linha quatro do exemplo.

A chamada (utilizao) de um mtodo de instncia depende se voc est em um outro mtodo da prpria classe onde ele foi declarado ou em uma outra classe. Se voc estiver em um outro mtodo da mesma classe e tambm for um mtodo de instncia, basta voc especificar o nome do mtodo e sua lista de argumentos entre parnteses: ajustaSalrio(850.00). Exemplo:
casEpeao{ ls mrgd piaedul slro rvt obe aai; vi autSlrodul slro{ od jsaaai(obe aai) ti.aai =slro hsslro aai; } vi amnaePret(od {/ otomtd d iscad msacas od uetDzocnovi) / ur oo e ntni a em lse dul nvSlro=slro+slro*01 obe ooaai ai ai .; autSlronvSlro; jsaaai(ooaai) } } / caau mtd d msacas / hm m oo a em lse

Se voc, por acaso, necessitar chamar (utilizar) um mtodo que pertence a uma outra classe ou a um mtodo de classe, primeiro crie um objeto do tipo da classe que contm o mtodo que voc deseja chamar e depois utilize esse objeto para chamlo:
casCasU { ls lsem piaeboenarbtQaqe; rvt ola tiuoulur pbi vi mtd(ola vlr{/ mtd asrcaaoprotacas ulc od eooboen ao) / oo e hmd o ur lse arbtQaqe =vlr tiuoulur ao; } } casOtalse{ ls urCas vi otoeoovi) od urMtd(od{ CasU ojt =nwCasU(; lsem beo e lsem) ojt.ootu) beomtd(re; / caaomtd arvsd ojt / hm oo ta o beo nwCasU(.eoofle; e lsem)mtd(as) } } / caaomtd arvsd ojt / hm oo ta o beo

Esse ltimo exemplo tambm mostra que voc no precisa colocar o objeto criado em uma varivel para chamar um mtodo de outro objeto. A expresso new ClasseUm().mtodo(false); cria um objeto a partir da ClasseUm e, ao mesmo tempo (implicitamente), usa a referncia ao objeto recm criado para chamar metodo(). Similarmente, voc tambm pode encadear chamadas de mtodos de instncia (desde que elas retornem referncias para objetos):
casAca { ls lThu pbi sai vi mi(tiglsaeaaers]{ ulc ttc od anSrn itDPrmto[) nwAca(.l(.ca(;/ caaaecdaad mtds e lThu)a)thu) / hmd naed e oo } Aca a){ lThu l( / omtd artrau ojt d tp Aca / oo l eon m beo o io lThu Sse.u.rnl(A) ytmotpitnl; rtr ti; eun hs / rtraet ojt / eon se beo } Aca thu){ lThu ca( / omtd thurtrau ojt d tp Aca / oo ca eon m beo o io lThu Sse.u.rnl(Thu) ytmotpitnca; rtr ti; eun hs / rtraet ojt / eon se beo }

Mtodos de Classe
Um mtodo de classe um mtodo que acessa somente os atributos de classe definidos na sua prpria classe. Para declarar um mtodo deste tipo, especifique a palavra-chave static:
casEpeao{ ls mrgd piaesai itnmrDEpeao; rvt ttc n ueoemrgds sai vi autNmrDEpeao(n nmr) ttc od jsaueoemrgdsit ueo{ nmrDEpeao =nmr; ueoemrgds ueo } }

Se, no exemplo anterior, o parmetro numero tivesse o mesmo nome do atributo numeroDeEmpregados, seria possvel utilizar this para passar o valor do parmetro para esse atributo? Veja o exemplo:
casEpeao{ ls mrgd piaesai itnmrDEpeao; rvt ttc n ueoemrgds sai vi autNmrDEpeao(n nmrDEpeao) ttc od jsaueoemrgdsit ueoemrgds{ ti.ueoemrgds=nmrDEpeao;/ER! hsnmrDEpeao ueoemrgds /RO } }

Voc no pode utilizar this em um mtodo de classe porque essa palavra-chave se refere instncia (ao objeto) de classe atual e, infelizmente, um mtodo de classe no associado a nenhum objeto (instncia de classe). Para chamar um mtodo de classe por outro mtodo de classe ou de instncia da mesma classe, simplesmente utilize seu nome e sua lista de argumentos entre chaves:
casPierEeud { ls rmioSgno sai vi pier( { ttc od rmio) Sse.u.rnl(Pier; ytmotpitnrmio) } sai vi sgno){ ttc od eud( pier(; rmio) Sse.u.rnl(Sgno) ytmotpitneud; } }

Se a chamada estiver em um mtodo de classe de outra classe, prefixe o mtodo com o nome de sua classe seguido do operador de ponto:
casUaPierEeud { ls srrmioSgno pbi sai vi mi(tiglsaeruets] { ulc ttc od anSrn itDAgmno[) PierEeud.rmio) rmioSgnopier(; PierEeud.eud(; rmioSgnosgno) } }

Se o mtodo da outra classe no for de classe, chame-o da mesma forma como voc chamaria um mtodo de instncia de outra classe (primeiro crie um objeto e depois chame o mtodo a partir dele).

Sobre a passagem de argumentos

At o momento nada foi dito sobre como so passados os argumentos (parmetros) para os mtodos de classe ou de instncia. Existem duas abordagens para tal: chamada por valor e chamada por referncia. As chamadas por valor fazem uma cpia de cada argumento e passa essa cpia para o mtodo. Assim, o valor original no modificado. Em Java, somente os tipos primitivos (int, double, float...) so passados por valor. Isso significa que, se durante seu processamento, o mtodo realizar alguma mudana nos contedos dos parmetros, as variveis originais no sero afetadas (no mtodo que realizou a chamada).

Em contraste, as chamadas por referncia passam somente uma referncia ao endereo do argumento original, tornando possvel ao mtodo chamar os mtodos e acessar os atributos (elementos) deste argumento e modific-los.

Sobrecarregando mtodos
Declarar mltiplos mtodos que possuam o mesmo nome, porm com listas de parmetros diferentes, uma tcnica denominada sobrecarga de mtodo (method overloading). 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 (atravs da comparao de assinaturas). Veja o exemplo seguinte:
vi ipii({ od mrmr) Sse.u.rnl(Ipesopd; ytmotpitnmrs aro) } vi ipii(tigagmno{ od mrmrSrn ruet) Sse.u.rnl(ruet) ytmotpitnagmno; }

O exemplo anterior demonstra dois mtodos imprimir sobrecarregados. Os dois mtodos possuem o mesmo nome, porm, parmetros diferentes. Ao se chamar imprimir() o primeiro chamado (executado). Ao se chamar imprimir(Ol), o segundo chamado. Voc pode declarar e implementar quantas sobrecargas voc achar conveniente. Porm, importante lembrar que os argumentos devem ser sempre diferentes. No basta voc modificar o tipo de retorno, mantendo o resto da assinatura igual. Veja o exemplo:
itsmritx ity{ n oa(n , n ) rtr x+y eun ; } ln smritx ity{ ot oa(n , n ) rtr x+y eun ; }

Neste ltimo caso o compilador no tem como decidir qual mtodo chamar, e acusar um erro.

Construtores (constructors)
Construtor um mtodo especial que chamado pelo operador new quando um novo objeto necessita ser criado. Dentro do construtor voc pode colocar o seu prprio cdigo customizado de inicializao do objeto. Por serem mtodos, os construtores podem ser declarados com listas de parmetros e especificadores de acesso. Entretanto, 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 declarao. Voc se lembra da classe Empregado?
casEpeao{ ls mrgd piaeitnmrDEpeao; rvt n ueoemrgds piaedul slro rvt obe aai; pbi vi autNmrDEpeao(n nmrDEpeao) ulc od jsaueoemrgdsit ueoemrgds{ ti.ueoemrgds=nmrDEpeao; hsnmrDEpeao ueoemrgds } vi autSlrodul slro{ od jsaaai(obe aai) ti.aai =slro hsslro aai; } }

Objetos desta classe podem criados atravs da utilizao do operador new:

casEepo{ ls xml pbi sai vi mi(tiglsaeruets]{ ulc ttc od anSrn itDAgmno[) Epeaoe=nwEpeao) mrgd e mrgd(; } }

A linha Empregado e = new Empregado() cria um novo objeto do tipo Empregado e coloca-o na varivel e, que tambm do tipo Empregado. O Empregado() que vem depois do operador new um construtor (sempre depois do new deve-se colocar um construtor). Note, porm, que no cdigo da classe Empregado no h a declarao de construtor algum! O que est acontecendo? Basicamente, quando voc no declara um construtor para uma classe o compilador cria um construtor-padro (default), com uma lista vazia de parmetros. Olhe o exemplo:
casX ls { }

Essa classe parece vazia, mas ela no est. Na realidade, o compilador enxerga a classe X da seguinte maneira:
casX ls { X( ) { } }

O Compilador somente cria o construtor padro quando nenhum outro for explicitamente declarado na classe. Logo, se voc declarar algum outro construtor, o compilador no vai gerar um construtor-padro sem argumentos:
casX ls { piaeiti rvt n ; X(n i / Epiiaet dcaau cntuo cmagmno it ) / xlctmne elr m osrtr o ruets { ti. =i hsi ; } } casUa ls sX { pbi sai vi mi(tig lsaeruets]{ ulc ttc od anSrns itDAgmno[) Xx =nwX2; 1 e () Xx =nwX) / ER:noeit cntuo smagmno n cas X 2 e (; / RO xse osrtr e ruets a lse ! } }

Neste ultimo exemplo, a tentativa de chamar o construtor-padro (sem argumentos) gera um erro de compilao por que no h um construtor-padro. Voc pode declarar mltiplos construtores em uma classe. Mltiplos construtores tornam possvel a realizao de diferentes tipos de inicializao:
casCruo ls icl { piaeitx y r rvt n , , ; Cruo) / dcaau cntuo smagmno icl( / elr m osrtr e ruets { / Sse.u.rnl(Ats) / ytmotpitnne; ti(,,) hs001; Sse.u.rnl(Dpi; ytmotpitneos) } Cruoitx ity itr/ dcaau cntuo qercb 3agmno icl(n , n , n )/ elr m osrtr u eee ruets { ti. =x hsx ; ti. =y hsy ; ti. =r hsr ; } itrtra( { n eonX)

rtr x eun ; } itrtra( { n eonY) rtr y eun ; } itrtraao){ n eonRi( rtr r eun ; } } casEepo ls xml { pbi sai vi mi(tiglsaeruets] ulc ttc od anSrn itDAgmno[) { Cruoc =nwCruo) icl 1 e icl(; Sse.u.rnl(Cnr X +c.eonX); ytmotpitneto : 1rtra() Sse.u.rnl(Cnr Y +c.eonY); ytmotpitneto : 1rtra() Sse.u.rnl(Ri ytmotpitnao :+c.eonRi() 1rtraao); Cruoc =nwCruo567; icl 2 e icl(,,) Sse.u.rnl(Cnr X +c.eonX); ytmotpitneto : 2rtra() Sse.u.rnl(Cnr Y +c.eonY); ytmotpitneto : 2rtra() Sse.u.rnl(Ri ytmotpitnao :+c.eonRi() 2rtraao); } }

Este ltimo programa declara um par de classes: Exemplo e Circulo. A classe Crculo declara um par de construtores. O primeiro construtor no recebe argumento algum e contm a seguinte linha de cdigo: this(0,0,1), que nada mais faz do que chamar o segundo construtor que possui 3 argumentos (dentro de uma classe, utilize this() ao invs do nome do seu construtor). Uma chamada ao construtor via o comando this() deve ser a primeira linha de cdigo dentro de um construtor (caso contrrio o compilador gera um erro). Por esse motivo, a linha System.out.println(Depois), que aparece no primeiro construtor da classe Circulo, est comentada. Tambm, devido a esse mesmo motivo, voc no pode chamar dois construtores em um construtor.

Parte III: Composio Construindo objetos a partir de outros objetos

Suponha que seu instrutor pea para voc escrever uma aplicao Java que modele um carro. De acordo com as especificaes dele, esta aplicao deve declarar uma classe chamada Motor (que modela o motor do carro) e uma classe chamada Carro (que modela carros). Finalmente, a aplicao deve declarar uma classe chamada DemonstracaoCarro, que possua uma funo main a fim de executar o programa. Mas afinal, neste caso, o que que o mtodo main faz realmente? Neste caso o mtodo main, por ser um mtodo de classe especial, fica encarregado de criar objetos do tipo Carro (que possuam objetos do tipo Motor em cada um deles), colocar informaes apropriadas em cada objeto (via chamadas a seus construtores) e (para cada carro) imprimir as informaes de cada carro. Depois de um tempo escrevendo essa aplicao, voc deve terminar com o seguinte cdigo-fonte:
casMtr ls oo { piaeSrn tp; rvt tig io MtrSrn tp) oo(tig io { ti.io=tp; hstp io } } casCro ls ar { piaeSrn mra rvt tig ac;

piaeSrn mdl; rvt tig oeo piaeSrn fbiat; rvt tig arcne CroSrn mra Srn mdl,Srn fbiat) ar(tig ac, tig oeo tig arcne { ti.ac =mra hsmra ac; ti.oeo=mdl; hsmdl oeo ti.arcne=fbiat; hsfbiat arcne } pbi Srn rtraac( {rtr mra } ulc tig eonMra) eun ac; pbi Srn rtraoeo){rtr mdl;} ulc tig eonMdl( eun oeo pbi Srn rtraarcne){rtr fbiat;} ulc tig eonFbiat( eun arcne } casDmsrcoar ls eotaaCro { pbi sai vi mi(tiglsaeruets]{ ulc ttc od anSrn itDAgmno[) Mtrm =nwMtr.LV; oo 1 e oo(38 6) Croc =nwCroutn ovre od) ar 1 e ar(Msag, Cnesvl, Fr; Mtrm =nwMtree Rm10) oo 2 e oo(Ztc oa .; Croc =nwCroa,oua od) ar 2 e ar(K Pplr, Fr; Sse.u.rnl(c.eonFbiat( ++ ytmotpitn 1rtraarcne) c.eonMra) 1rtraac( ++ c.eonMdl( 1rtraoeo) ++m.eonTp( ) 1rtraio) ; Sse.u.rnl(c.eonFbiat( ++ ytmotpitn 2rtraarcne) c.eonMra) 2rtraac( ++ c.eonMdl( 2rtraoeo) ++m.eonTp( ) 2rtraio) ; }

Muito bem! O cdigo anterior segue as especificaes e requisitos solicitados pelo instrutor. Por outro lado, esse cdigo apresenta um problema de modelagem importante: as classes Carro e Motor esto desconectadas ou desacopladas uma da outra. No mundo real, comum dizer que um carro possui um motor, assim como pneus e outros itens. Em outras palavras, vrios itens, incluindo um motor, compem um carro. Em contraste, o cdigo anterior mostra que um carro no compe um carro e, neste caso, possvel criar objetos do tipo Carro sem um motor associado uma situao estranha. Voc j imaginou algum comprando um carro sem motor!? O erro de se criar um novo Carro sem um Motor resulta do fato das duas classes estarem desconectadas. A soluo para esse erro consiste em conectar estas duas classes. exatamente esse o assunto desta seo: composio de objetos.

O que composio?
Em nosso mundo, entidades compem outras entidades. S para dar um exemplo, um chassi, algumas portas, pneus, um motor, uma transmisso, um sistema de escapamento, e similares, compem um veculo. Pelo fato de objetos servirem como representaes de software de entidades do mundo real, possvel que vrios 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:
casMtr ls oo { / arbtsemtdsqeietfcmaetuuad u mtr / tiuo oo u dniia srtr e m oo } casVuo ls ecl { Mtrmtr / dfn uavre qeamzn u ojt d tp Mtr oo oo; / eie m aivl u raea m beo o io oo VuoMtrm ecl(oo ) { mtr=m oo ; } }

Esse exemplo de cdigo declara duas classes: Motor e Veculo. A classe Veculo declara um atributo chamado motor, que do

tipo Motor, e utiliza esse atributo para referenciar um objeto que descreve o motor de um veculo. O construtor Veculo(Motor m) inicializa o atributo motor para referenciar um objeto do tipo Motor atribuindo o contedo do parmetro m para esse atributo. Depois de fazer a atribuio, motor possui (referencia, na verdade) o mesmo que m. A figura seguinte demonstra a conceitualizao um Veculo composto de um Motor:

Agora que voc sabe alguma coisa sobre a estrutura das classes Veculo e Motor, como voc faz para criar um objeto do tipo Motor e um objeto do tipo Veculo que seja composto do objeto Motor? A resposta est no exemplo seguinte:
Mtr m=nwMtr) / ci u nv mtreclc n vre mtr oo e oo(; / ra m oo oo ooa a aivl oo Vuov=nwVuom;/ ci u nv vuo psad omtrpr ee ecl e ecl() / ra m oo ecl, asno oo aa l

No exemplo acima, a primeira linha cria o objeto Motor e atribui seu endereo varivel de referencia de objetos m, do tipo Motor. A segunda linha, que cria o objeto Veculo, passa o endereo do objeto (que est na varivel m) para o construtor do Veculo. Com isso, o construtor salva o contedo da varivel m dentro do seu atributo privado motor. Neste momento, o objeto Veculo referenciado pela varivel v composto do objeto Motor referenciado pelo atributo interno do Veculo. A relao entre os dois objetos recm criados aparece na figura seguinte:

Nesta figura voc pode notar que existem dois objetos: o objeto do tipo Veculo, que est referenciado na varivel v, e o objeto do tipo Motor, que referenciado pelo atributo motor do objeto Veculo. A princpio eles existem em locais diferentes de memria, porm, devido ao atributo motor, eles esto ligados, fazendo com que o objeto Veculo seja composto por um Motor.

Parte IV: Herana Construindo objetos em camadas

O que Herana?
Herana a habilidade de se derivar alguma coisa especfica a partir de algo mais genrico. Ns encontramos essa habilidade ou capacidade no nosso cotidiano. Um Plio-EX, estacionado na frente da garagem do seu vizinho, uma instncia especfica da categoria Carro, mais genrica, por exemplo. Da mesma forma, uma Honda CG 125 Cargo uma instncia especfica da categoria mais genrica Moto. Se levarmos as categorias Carro e Moto para um outro nvel mais elevado, as duas se relacionaro uma com a outra por serem instncias especficas de uma categoria mais genrica ainda do que elas: a categoria Veculo. Em outras palavras, carros e motos so veculos. A figura seguinte esquematiza as relaes entre uma entidade PlioEX, a categoria Carro, uma entidade Honda CG 125 Cargo, a categoria Moto, e a supercategoria Veculo.

Entidades as so coisas tangveis com as quais ns interagimos (o Plio-EX ou a CG 125, por exemplo). As categorias relacionam entidades com outras entidades, em uma hierarquia: o seu carro (se voc tiver um) se relaciona com outros carros atravs da categoria Carro. E os Carros se relacionam com Motos atravs da supercategoria Veculo. Se utilizarmos uma metfora de rvore invertida (onde a raiz desta rvore encontra-se no topo e as folhas em baixo), as categorias so os ramos ou galhos da rvore, e as entidades so as folhas desta rvore (conforme voc pode ver na figura anterior). A hierarquia de galhos de categorias organiza a forma da rvore (arquitetura de entidades), e as folhas (as entidades) so instncias dos galhos mais baixos (categorias). Esse 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). Em contraste, herana mltipla permite com que uma entidade herde diretamente comportamentos e estados de duas ou mais categorias ao mesmo tempo. Imagine o Empregado chamado Jos de uma empresa qualquer. Para ser mais especfico, pense no Jos como sendo Gerente e Contador ao mesmo tempo. Ele herdaria (possuiria) as capacidades de um Gerente e de um Contador (por que no?). Veja a prxima figura:

Estendendo classes
Na linguagem Java a herana se manifesta de duas maneiras: ou pela extenso de classes (chamada de herana de implementao) j 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, novas classes derivam capacidades (expressas como atributos e mtodos) de classes j existentes. Isso faz com que o tempo de desenvolvimento de uma aplicao seja bem menor, pois classes j existentes e comprovadamente funcionais (livres de erros e j testadas) so reaproveitadas (ou reutilizadas). A sintaxe que expressa o conceito de extenso de classes a seguinte:
lsietfcdrelse xedietfcdrelse cas dniiaoDCas1 etns dniiaoDCas2 { / Cmo emtds / aps oo }

Essa sintaxe pode ser lida da seguinte forma: o identificadorDeClasse1 estende o identificadorDeClasse2. Em outras palavras, o identificadorDeClasse1 herda (ou deriva) capacidades (expressas atravs de atributos e mtodos) do identificadorDeClasse2. O identificadorDeClasse1 conhecido como subclasse, classe derivada ou classe-filha. O identificadorDeClasse2 conhecido como superclasse, classe bsica ou classe-pai. A palavra-chave extends (estende) faz com que uma subclasse herde (receba) todos os campos e mtodos declarados na classe-pai (desde que ela no seja final), incluindo todas as classes-pai da classe-pai. A classe-filha pode acessar todos os atributos e mtodos no privados. Ela no pode acessar (ao menos diretamente) os mtodos e atributos privados (declarados com a palavra-chave private). Considere o exemplo seguinte:
casPno ls ot { piaedul x y rvt obe , ; Pnodul x dul y ot(obe , obe ) { ti. =x hsx ; ti. =y hsy ; } dul rtra( obe eonX) { rtr x eun ; }

dul rtra( obe eonY) { rtr y eun ; } } casCruoetnsPno ls icl xed ot { piaedul ri; rvt obe ao Crl(obex dul y dul ri) icedul , obe , obe ao { sprx y;/ CaaPnodul x dul y ue(, ) / hm ot(obe , obe ) ti.ao=ri; hsri ao } dul rtraao){ obe eonRi( { rtr ri; eun ao } }

O cdigo acima consiste de duas classes: Ponto e Circulo. Ponto uma classe que descreve um ponto, que no nada mais do que um par de coordenadas (x, y), expresso por valores de ponto-flutuante de dupla-preciso numrica (tipo double). Circulo descreve um crculo (um crculo um ponto que possui um raio). Se voc fosse criar um objeto a partir da classe Circulo, voc acabaria com o objeto de multicamadas representado na figura ao lado. Essa figura mostra que o objeto Circulo de duas camadas possui trs atributos: x, y e raio. Entretanto ele somente declara somente o atributo raio. Os outros dois atributos so apresentados na camada mais interna, do Ponto. As subclasses (classes-filha) so geralmente mais largas do que as superclasses (classes-pai). Isso porque elas costumam adicionar novos 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 no tenha sido declarada final. Por exemplo, se a declarao da classe Ponto tivesse sido final class Ponto, o compilador teria acusado um erro. Logo, por razes de segurana, se voc quiser garantir que uma classe no vai ser estendida, declare-a como sendo final. A sintaxe da herana sugere que voc pode estender uma e somente uma classe. A linguagem Java no suporta a implementao de herana mltipla. Isso porque, segundo os projetistas da linguagem, esse tipo de implementao poderia gerar confuso. Imagine, por exemplo, duas classes-base declarando um atributo que possua o mesmo nome mas com tipos diferentes. Qual dos dois a classe-filha deveria herdar? O mesmo poderia acontecer com um mtodo. Se dois mtodos possussem o mesmo nome mas diferentes listas de parmetros ou tipos de retorno, qual deles a subclasse deveria herdar? Para prevenir tais problemas a linguagem Java rejeita a implementao de herana mltipla.

Chamando construtores da classe-pai

No exemplo anterior, examine o construtor da classe Circulo. Veja que dentro dele h o seguinte cdigo na linha grifada: super(x, y). Essa linha utiliza a palavra-chave super para chamar o construtor Ponto(double x, double y) da sua superclasse (classe-pai) e passar para ele o contedo das variveis x e y. importante para a classe Circulo chamar esse construtor da classe Ponto para que os valores de x e de y inicializem corretamente. Pelo fato da classe Ponto declarar estes atributos como sendo privados (private), nenhuma classe (nem mesmo sua classe-filha Circulo) a no ser a prpria classe Ponto, pode acesslos. Logo, para inicializar os valores de x e de y passados como argumentos para o construtor da classe Circulo, essa classe necessita delegar essa tarefa para o construtor da classe Ponto, e isso feito chamando-se super(x, y). Suponha que voc modifique o construtor da classe Circulo e retire a linha que contm super(x, y); e aps voc 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 voc no colocar uma chamada para o construtor da superclasse, o compilador insere automaticamente na subclasse o cdigo que chama o construtor-padro (sem argumentos). No exemplo anterior, se voc tivesse retirado super(x, y) o compilador teria inserido o comando super() para chamar o construtor-padro da classe Ponto(). Note que, neste caso, a classe Ponto no tem nenhum construtor-padro, 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). E, por esse motivo, um erro seria gerado (lembre-se que quando voc no especifica um construtor o compilador gera automaticamente o construtor padro; mas esse no foi o caso ocorrido na classe Ponto). Existem duas outras regras que devem ser levadas em considerao. 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 sobrescrever, trocar ou re-escrever um mtodo de sua superclasse. Para que isso ocorra, o mtodo da subclasse deve possuir o mesmo nome, a mesma lista de parmetros e o mesmo tipo de retorno do mtodo da sua superclasse. Veja o exemplo:
casPno ls ot { vi dsna) od eeh( { Sse.u.rnl(E suu pno; ytmotpitnu o m ot.) } } casCruoetnsPno ls icl xed ot { vi dsna) / r-elr o r-srv omtd od eeh( / edcaa u eecee oo { Sse.u.rnl(E suu cruo; ytmotpitnu o m cl.) } }

De acordo com o cdigo presente no exemplo acima, se voc criar um novo objeto do tipo Circulo e chamar o mtodo desenha(), ento a frase Eu sou um crculo. ir aparecer:
Cruoc=nwCruo) icl e icl(; cdsna) .eeh(;

Entretanto, se a classe Circulo no tivesse re-escrito o mtodo desenha() com o seu prprio cdigo, voc teria visto Eu sou um ponto., ao invs. Agora imagine que voc tenha um atributo ou mtodo, em uma subclasse, que seja idntico a um atributo ou mtodo de sua superclasse. Imagine tambm que voc queira acessar esse atributo ou mtodo que pertence superclasse e no subclasse. Como voc poderia fazer isso? A resposta voc vai encontrar no fragmento de cdigo seguinte:
casSpr ls ue { dul x=2 obe ; vi dsna) od eeh( { Sse.u.rnl(Spr) ytmotpitnue; } } casSbetnsSpr ls u xed ue { dul x=3 obe ; / r-elr oarbt / edcaa tiuo

vi dsna){/ r-elr /r-srv omtd od eeh( / edcaa eecee oo Sse.u.rnl(Sb) ytmotpitnu; Sse.u.rnl(x=+x; ytmotpitn ) Sse.u.rnl(Sprx=+sprx; ytmotpitnue. ue.) sprdsna) ue.eeh(; } / caaomtd d sprlse / hm oo a uecas

O exemplo anterior demonstra um outro uso pra a palavra-chave super. Prefixando com super. um mtodo ou um atributo faz com que o mtodo da superclasse seja chamado ou com que o atributo da superclasse seja utilizado. Lembre-se, porm, que um mtodo s pode ser sobre-escrito se ele no tiver sido declarado privado (private) na superclasse, isto , ele tem que ser acessvel. Da mesma forma, o mtodo no pode ter sido declarado final, pois essa palavrachave faz com que o mtodo no possa ser sobre-escrito.

Nomeando ou especificando o tipo de um objeto (type Casting)

Todo 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 Veculo, e um objeto do tipo Circulo tambm um objeto do tipo Ponto, conforme nossas declaraes anteriores). Essa afirmao implica no fato de voc poder atribuir um objeto de uma subclasse para uma referncia criada ou declarada para um objeto de sua superclasse.
Pnop=nwCruo1.,2.,3.) ot e icl(00 00 00;

A linha de cdigo acima cria um objeto do tipo Circulo e atribui sua referncia varivel p. Note que essa varivel p uma varivel que armazena referncias para objetos do tipo Ponto. Esse tipo de atribuio perfeitamente possvel, j que um Circulo, pelas definies de classe que foram descritas em exemplos anteriores, uma subclasse de Ponto (e, neste caso, um crculo tambm um ponto). Assim, atravs da varivel p possvel chamar os mtodos retornaX() e retornaY(), que pertencem ao tipo Ponto. Mas seria possvel, tambm, chamarmos o mtodo retornaRaio()? A resposta no, pois quem declara esse mtodo a camada do Circulo e no a camada do Ponto (voc se lembra que os objetos podem ser construdos em mais de uma camada?). Em essncia, retornaRaio() um mtodo que pertence camada do Circulo e no do Ponto. Logo, se voc declara uma varivel do tipo Ponto ela enxerga somente a camada existente dentro da classe Ponto. Por outro lado, se voc declara uma varivel do tipo Crculo 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 varivel p para acessar o mtodo retornaRaio() utilizando um recurso chamado type cast[5], que em Ingls significa algo do tipo nomeao ou especificao de tipo. Com esse recurso, uma varivel pode assumir momentaneamente outro papel (ou tipo), para que voc possa atribu-la ou utiliz-la em alguma expresso. Em Java, assim como na linguagem C, o cast de uma varivel ou expresso realizado colocando-se entre parnteses o tipo desejado. Logo, se no exemplo anterior voc quisesse utilizar o mtodo retornaRaio() para poder retornar o valor do raio do crculo e coloc-lo em uma varivel, voc teria que fazer o seguinte:
dul ri =(Cruo p.eonRi(; obe ao (icl) )rtraao)

Lembre-se que as operaes dentro de parnteses so executadas primeiro. Logo, primeiro o compilador troca o tipo da varivel p para Circulo e depois, com esse resultado (que ser um objeto do tipo Circulo), ele chama o mtodo retornaRaio(). O valor retornado atribudo varivel chamada raio. importante lembrar que voc pode utilizar esse artifcio de nomeao para transformar uma classe-filha em qualquer uma de suas classes-pai. O inverso, porm, no permitido. Veja o exemplo:
Pno p ot =nwPno1.,2.) e ot(00 00; dul ri =(Cruo p.eonRi(; obe ao (icl) )rtraao)

O problema, neste caso, que um objeto do tipo Ponto no tem noo alguma de um mtodo chamado retornaRaio. Isso porque quem introduz esse mtodo a classe Circulo. Logo, apesar desse cdigo compilar sem acusar erro, quando voc execut-lo, a JVM vai gerar uma exceo (uma falha) do tipo ClassCastException (Exceo de Nomeao de Tipo), ou at mesmo travar, quando a chamada ao mtodo retornaRaio() ocorrer.

Herana versus Composio

Herana e composio relacionam-se entre si da mesma forma que um lado se relaciona com o outro em uma moeda. Herana promove um objeto em camadas, como uma cebola. Em contraste, a composio promove objetos que possuem outros objetos, como mingau de aveia em flocos, onde cada floco um objeto. Na seo (captulo) anterior, voc aprendeu que a composio resulta de relaes do tipo tem um, entre objetos (exemplo: carro tem um motor). A herana resulta de relaes do tipo um. Logo, quando voc encontrar um texto ou uma descrio do tipo um carro um tipo de veculo, voc est lidando com

herana. Para projetar ou construir objetos complexos voc pode utilizar tanto a herana quanto composio. Uma no exclui a outra, e voc pode, inclusive, utiliz-las junto. Um dos problemas mais difceis que um projetista pode enfrentar, quando estiver desenvolvendo uma hierarquia de classes, saber decidir quando utilizar composio e quando utilizar herana. Algumas vezes as relaes do tipo um ou tem um no so muito claras. Para exemplificar, suponha que voc no saiba que um crculo seja um ponto sem raio. Ao contrrio, voc acredita que um crculo tenha um ponto e um raio. A partir desta premissa, voc pode acabar implementando o seguinte fragmento de cdigo:
casPno ls ot{ piaedul x y rvt obe , ; Pnodul x dul y{ ot(obe , obe ) ti. =x hsx ; ti. =y hsy ; } dul rtra( { obe eonX) rtr x eun ; } dul rtra( { obe eonY) rtr y eun ; } } casCruo ls icl{ piaePno p rvt ot ; piaedul ri; rvt obe ao Crl(obex dul y dul ri) icedul , obe , obe ao{ p=nwPnox y; e ot(, ) ti.ao=ri; hsri ao } dul rtraao){ obe eonRi( rtr ri; eun ao } dul rtra( { obe eonX) rtr prtra(; eun .eonX) } dul rtra( { obe eonY) rtr prtra(; eun .eonY) } }

A partir de uma interface ou cdigo externos, um objeto criado a partir desta classe Circulo equivalente ao da classe Circulo apresentada no incio desta seo. Com este exemplo, pode parecer que no importa se a herana ou no utilizada. Mas, na verdade, importa: preste muita ateno na classe Circulo. Note que h a definio dos mtodos retornaX e retornaY. Estes mtodos duplicam o cdigo j existente na classe Ponto sem necessidade. Com isso, a reutilizao de cdigo no feita (e uma das grandes vantagens da orientao a objetos poder reutilizar cdigo). Portanto, se voc focalizar somente a composio de objetos voc poder estar adicionando redundncia ao cdigo. Em uma escala muito maior, esse tipo de redundncia pode se tornar um pesadelo de manuteno.

Parte V: A raiz de todas as classes

Muitas linguagens orientadas a objetos, como o C++, no suportam a noo de existir uma nica classe a partir da qual todas as outras classes so derivadas, sem que isso seja um detrimento da linguagem. Entretanto, na linguagem Java, a falta desse tipo de classe tornaria a linguagem limitada.

A camada Objeto
Todos os objetos da linguagem Java so de mltiplas camadas. Cada classe, na hierarquia de classes, representa uma camada

que adiciona diversas capacidades a um objeto. No topo desta hierarquia voc sempre vai encontrar uma classe chamada de Objet (objeto). Imagine, por exemplo, que voc tenha declarado uma classe chamada DemoCamadaObjeto que no estende, explicitamente, nenhuma outra classe. O cdigo seguinte apresenta uma possvel representao desta classe:
casDmCmdOjt{ ls eoaaabeo itarbtDIsaca=1 n tiuoentni ; pbi sai vi mi(tiglsaeruets]{ ulc ttc od anSrn itDAgmno[) DmCmdOjt atg =nwDmCmdOjt(; eoaaabeo nio e eoaaabeo) Sse.u.rnl(nioarbtDIsaca; ytmotpitnatg.tiuoentni) Sse.u.rnl(niotSrn() ytmotpitnatg.otig); } }

primeira vista, voc no nota nada de especial nesta classe. Ela declara um atributo de objeto e um mtodo main que cria um objeto do tipo DemoCamadaObjeto e imprime o valor do atributo atributoDeInstancia. Entretanto, se voc examinar com mais calma, voc vai notar algo estranho: antigo.toString(). De alguma forma, a funo main chama um mtodo toString, mesmo que DemoCamadaObjeto no tenha declarado esse mtodo ou tenha especificado uma classe-pai. As aparncias podem ser decepcionantes. Na realidade DemoCamadaObjeto implicitamente estende a classe Objet. como se o programador tivesse declarado class DemoCamadaObjeto extends Object, o que perfeitamente permitido. Pelo fato de qualquer classe estender implicitamente (sem ser necessrio declarar) a classe Object, a classe DemoCamadaObjeto uma classe-filha da classe Object. Tambm pelo fato da classe Object possuir um mtodo chamado toString() (que converte um objeto para uma String), perfeitamente legal chamar esse mtodo no mtodo main do exemplo anterior. Para compreender melhor como o objeto criado a partir de DemoCamadaObjeto se parece, observe a figura seguinte.

No centro do objeto DemoCamadaObjeto, representado na figura anterior, voc vai encontrar uma camada do tipo Objet (representada pelo crculo interno). Essa camada interna apresenta alguns mtodos que ns vamos examinar em detalhes nesta seo. A camada externa, que representa o objeto DemoCamadaObjeto, herda estes mtodos. Alm dos mtodos herdados, a camada externa tambm apresenta dois novos componentes: o atributo atributoDeInstancia e o mtodo main. Em termos mais gerais, se voc tiver uma classe-filha qualquer que estende alguma outra classe-pai qualquer, a classe-pai geralmente estende diretamente a classe raiz Objet, e a classe-filha estende-a tambm, indiretamente. Mas quais so estes mtodos herdados por elas? Vamos descobrir!

Obtendo informaes sobre uma classe

O primeiro mtodo da classe Object que ns vamos estudar o mtodo getClass (retornar classe). Quando chamado, o mtodo getClass() retorna uma referencia para um objeto do tipo Class (classe). O mtodo getClasse declarado final, logo, voc no pode sobrescreve-lo em uma subclasse. Um objeto da classe Class contm diversos mtodos que retornam diversas informaes sobre uma classe, tais como seus construtores, atributos e informaes 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 mtodo getClass() no pode ser utilizado em um tipo de dado primitivo, tal como char, int ou float, porque eles no so objetos. Por outro lado, a linguagem Java permite com que voc descubra o tipo de qualquer varivel atravs do operador .class, que deve ser utilizado como sufixo da varivel na qual se deseja descobrir o tipo. Esse operador pode ser utilizado mesmo que voc ainda no tenha criado um objeto (j o getClasse exige que voc tenha criado um objeto). Exemplo:

Cas ls cas1 cas2 cas3 cas4 lse, lse, lse, lse; ca hr lta= er c; Epeaoe mrgd =nwEpeao) e mrgd(; cas1=Epeaocas / vld:u tp d vre lse mrgd.ls; / io m io e ivl cas2=ca.ls; lse hrcas / vld:u tp d vre / io m io e ivl cas3=egtls(; lse .eCas) / vld:u ojt / io m beo cas4=Epeaogtls(;/ ivld:nou ojt lse mrgd.eCas) / nio m beo cas5=cgtls(; lse .eCas) / ivld:nou ojt / nio m beo cas6=ccas lse .ls; / ivld:nou tp d vre / nio m io e aivl cas7=ecas lse .ls; / ivld:nou tp d vre / nio m io e aivl

Logo, quando voc estiver trabalhando com um objeto, utilize o mtodo getClass. Porm, se voc estiver trabalhando com um tipo de varivel, utilize o .class. As classes Object e Class possuem uma srie de outros mtodos que voc pode utilizar. Confira na tabela seguinte alguns destes mtodos e para que eles servem: Mtodo
getClass()

classe Object Utilidade

Retorna uma referncia do tipo Class que contm informaes sobre a classe do objeto.

classe Class Mtodo

getName()

Utilidade
Retorna uma String contendo o nome da classe do objeto.

clone()

Retorna um clone (uma cpia) idntica do objeto (veja seo seguinte).

getSuperClass()

Retorna uma referncia do tipo Class que contm informaes sobre a classe-pai da classe do objeto.

equals(objeto)

Compara o objeto atual com o objeto passado como parmetro. Se eles forem iguais retornado um valor booleano true (verdadeiro). Caso contrrio false (falso).

classe Field (atributo) Mtodo

getType()

getDeclaredField(atributo)

Utilidade
Retorna uma referncia do tipo Class que contm informaes sobre o tipo (classe) do atributo.

Retorna uma referncia do tipo Field (atributo) que contm informaes sobre o atributo de classe solicitado. Atributo uma String que contm o nome do atributo desejado.

Clonagem
Clonagem o processo de fazer duplicatas exatas de uma entidade. A linguagem Java suporta a clonagem atravs do mtodo clone(), que pertence classe Object. O mtodo clone retorna uma referencia para um objeto que exatamente a duplicata do objeto que a chama. Durante a operao de clonagem, o construtor do objeto no chamado. Como resultado, o mtodo clone cria uma duplicata de um objeto mais rapidamente que a utilizao do comando new, seguido de uma chamada ao construtor do objeto. O mtodo clone retorna uma referncia para um objeto do tipo Object. Logo, antes de colocar esse objeto clonado em uma

varivel voc tem que nome-lo (cast) para o tipo adequado (tipo do objeto original, que foi clonado):
Epeaoe =nwEpeao) mrgd 1 e mrgd(; / ci u epeao / ra m mrgd Epeaoe =(mrgd)e.ln(; mrgd 2 Epeao 1coe)

O mtodo clone um mtodo protegido. Isso significa que somente aquelas classes filhas da classe Object podem utiliza-lo, fazendo com que objetos possam clonar a si mesmos, mas no possam clonar outros objetos. A clonagem de um objeto pode ser superficial (shallow) ou profunda (deep). O mtodo clone sempre realiza uma clonagem do tipo superficial. Na clonagem superficial, somente os contedos dos, atributos e no os objetos referenciados por estes atributos, que so clonados. A clonagem profunda envolve, primeiramente, a realizao da clonagem superficial. Aps, os atributos devem ser atribudos para referncias de novos objetos. Finalmente, estes objetos devem ser populados (preenchidos) com informaes duplicadas (clonadas).

Igualdade
Comparar duas variveis para verificar se o seu contedo igual e comprar dois objetos para verificar se eles so iguais so tarefas diferentes. Quando voc quer comparar o contedo de duas variveis, voc utiliza o operador de igualdade (==). O que o operador de igualdade faz comparar se o contedo de duas variveis igual. Se seus contedos forem iguais, ele retorna o valor Booleano true (verdadeiro). Se elas forem diferentes, o valor false retornado. Esse operador funciona muito bem com tipos primitivos de dados (int, float, double...). J nos outros tipos de variveis, quando voc estiver trabalhando com objetos, errado utilizar esse operador. Isso porque essas variveis no contm os objetos em si, mas, sim, referncias para estes objetos. Logo, o comparador de igualdade estaria comparando duas referncias (endereos) e no o contedo dos objetos. Para comparar dois objetos voc deve utilizar o mtodo equals. Veja a diferena entre os dois:
Srn nm1=enro; tig oe Load Srn nm2=enro; tig oe Load Sse.u.rnl(nm1= nm2 ytmotpitnoe = oe :+nm1= nm2; oe = oe) / fle / as Sse.u.rnl(nm1eul(oe) +nm1eul(oe)) / tu ytmotpitnoe.qasnm2: oe.qasnm2 ; / re

Se voc utilizar uma das classes j existentes da linguagem Java, o mtodo equals funcionar muito bem. Porm, se voc criar uma nova classe ele no vai funcionar corretamente. Isso porque o mtodo equals padro utiliza, internamente, o operador de comparao (==). Para que ele funcione corretamente voc deve redefinir (reescrever) este mtodo dentro da sua classe de modo que ele possa realizar a comparao correta.
[1] By Jeff Friesen. It was originally published by JavaWorld (www.javaworld.com), copyright ITworld.com, Inc., November 2000. Reprinted with permission. [2] Preste ateno na conveno de sintaxe utilizada: os itens entre colchetes so opcionais e, geralmente, devem ser substitudos por palavras-chave detalhadas em

seguida ao cdigo; os itens entre apstrofes so obrigatrios e correspondem aos comandos ou estruturas da linguagem; j os itens em itlico so obrigatrios, mas voc pode utilizar qualquer identificador (palavra, desde que no seja reservada) para represent-los.
[3] Pacote o nome dado a uma biblioteca de classes desenvolvidas na linguagem Java. [4] Escopo o local ou regio onde uma varivel vlida. [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.