04-Linguagem Programaçãoi

Linguagem de Programao I
UNIDADE 1 1.1 1.2 1.3 1.4 1.5 1.6 1.7
PARADIGMA DE PROGRAMAO ORIENTADA A OBJETO......................................................................... 3
UM POUCO DE HISTRIA ................................................................................................................................................ 3 ORIENTAO A OBJETO CONCEITOS BSICOS ................................................................................................................... 3 ABSTRAO................................................................................................................................................................. 4 PARA FINALIZAR ESSA SEO VAMOS FAZER UMA PEQUENA REVISO: ...................................................................................... 4 HISTRICO DA LINGUAGEM JAVA ..................................................................................................................................... 5 PRINCIPAL CARACTERSTICA ............................................................................................................................................ 5 COMPILADOR, CDIGO FONTE, JVM ............................................................................................................................... 7 PROGRAMAO ORIENTADA A OBJETOS ............................................................................................... 10
UNIDADE 2 2.1 2.2 2.3
PRINCPIOS DA LINGUAGEM JAVA .................................................................................................................................. 10 CLASSES.................................................................................................................................................................... 10 OBJETOS ................................................................................................................................................................... 12 CLASSES EM JAVA................................................................................................................................... 14
UNIDADE 3 3.1 3.2
DEFINIO DE CLASSES EM JAVA.................................................................................................................................... 14 CONSTRUTORES ......................................................................................................................................................... 14 ATRIBUTOS............................................................................................................................................. 16
UNIDADE 4 4.1 4.2 4.3
ATRIBUTOS................................................................................................................................................................ 16 TIPOS PRIMITIVOS ...................................................................................................................................................... 16 CLASSES WRAPPERS..................................................................................................................................................... 19 MTODOS .............................................................................................................................................. 23
UNIDADE 5 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8
MTODOS ................................................................................................................................................................. 23 PRIVATE .................................................................................................................................................................... 23 PUBLIC ...................................................................................................................................................................... 24 PROTECTED................................................................................................................................................................ 24 ABSTRACT.................................................................................................................................................................. 24 FINAL ....................................................................................................................................................................... 25 STATIC ...................................................................................................................................................................... 27 DEFINIO DO CORPO DE MTODOS .............................................................................................................................. 28 MANIPULAO DE OBJETOS .................................................................................................................. 29
UNIDADE 6 6.1 6.2 6.3 6.4 6.5
MANIPULAO DE OBJETOS ......................................................................................................................................... 29 THIS ......................................................................................................................................................................... 30 EXEMPLOS DE USO DE THIS ........................................................................................................................................... 31 REMOO DE OBJETOS ................................................................................................................................................ 31 A CLASSE OBJECT ....................................................................................................................................................... 32 HERANA ............................................................................................................................................... 34
UNIDADE 7 7.1 7.2 7.3 7.4 7.5 7.6 7.7
HERANA .................................................................................................................................................................. 34 FORMAS DE HERANA ................................................................................................................................................. 34 CONTRAO .............................................................................................................................................................. 35 SINTAXE.................................................................................................................................................................... 35 CONSTRUO DE OBJETOS DERIVADOS ........................................................................................................................... 36 A PALAVRA-CHAVE SUPER ............................................................................................................................................ 36 RESTRIES DE ACESSO ................................................................................................................................................ 38 POLIMORFISMO ..................................................................................................................................... 40
UNIDADE 8 8.1 8.2 8.3 8.4
POLIMORFISMO: ........................................................................................................................................................ 40 LIGAO TARDIA: ....................................................................................................................................................... 40 SOBRECARGA (OVERLOADING): ..................................................................................................................................... 40 POLIMORFISMO EM JAVA: ............................................................................................................................................ 41
8.5 8.6 8.7
UPCASTING: .............................................................................................................................................................. 43 USO DE MTODOS ABSTRATOS: ..................................................................................................................................... 44 POLIMORFISMO EM CONSTRUTORES: .............................................................................................................................. 44 INTERFACES ............................................................................................................................................ 46
UNIDADE 9 9.1 9.2 9.3 9.4
INTERFACE: ............................................................................................................................................................... 46 DECLARAO DE INTERFACE:......................................................................................................................................... 46 IMPLEMENTAO DE INTERFACES: ................................................................................................................................. 46 DEFINIO DE CONSTANTES: ........................................................................................................................................ 47 IDENTIFICADORES .............................................................................................................................. 48
UNIDADE 10 10.1 10.2 10.3
IDENTIFICADORES ....................................................................................................................................................... 48 PALAVRAS RESERVADAS EM JAVA: ................................................................................................................................. 48 CONVENO PARA IDENTIFICADORES: ............................................................................................................................. 48 EXPRESSES ....................................................................................................................................... 50
UNIDADE 11 11.1 11.2 11.3 11.4 11.5 11.6
EXPRESSES ARITMTICAS:........................................................................................................................................... 50 EXPRESSES LGICAS INTEIRAS: .................................................................................................................................... 50 EXPRESSES LGICAS BOOLEANAS: ................................................................................................................................ 51 CONDIES: .............................................................................................................................................................. 52 RETORNO:................................................................................................................................................................. 52 OPERAES SOBRE OBJETOS: ....................................................................................................................................... 53 FLUXO DE CONTROLE DE EXECUO .................................................................................................. 54
UNIDADE 12 12.1 12.2 12.3
COMANDOS DE FLUXO DE CONTROLE DE EXECUO: ......................................................................................................... 54 ESCOLHA:.................................................................................................................................................................. 54 ITERAO:................................................................................................................................................................. 55 ARRANJOS EM JAVA........................................................................................................................... 57
UNIDADE 13 13.1
ARRANJOS EM JAVA: ................................................................................................................................................... 57 STRINGS ............................................................................................................................................. 58
UNIDADE 14 14.1 14.2 14.3
STRINGS: .................................................................................................................................................................. 58 STRINGBUFFER:.......................................................................................................................................................... 59 JAVA.UTIL.STRINGTOKENIZER: ....................................................................................................................................... 60 PACOTE .............................................................................................................................................. 62
UNIDADE 15 15.1
PACOTE .................................................................................................................................................................... 62 NCLEO DE FUNCIONALIDADES ......................................................................................................... 63
UNIDADE 16 16.1 16.2 16.3 16.4 16.5 16.6
NCLEO DE FUNCIONALIDADES ..................................................................................................................................... 63 JAVA.LANG: ............................................................................................................................................................... 63 SYSTEM .................................................................................................................................................................... 64 UTILITRIOS DE PROPSITO GENRICO: .......................................................................................................................... 65 DATE........................................................................................................................................................................ 65 RANDOM .................................................................................................................................................................. 65
Unidade 1 - Paradigma de Programao Orientada a Objeto

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

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

O paradigma de programao orientada a objeto baseado em alguns conceitos que definem uma forma de criar programas para computadores. A filosofia principal desse paradigma de programao solucionar um problema (via programao) atravs da representao computacional dos objetos existentes nesse problema (objetos do mundo real), usando para isso os conceitos mencionados acima. Com isso, essa maneira de se desenvolver programas fica mais prxima das situaes, dos problemas como eles acontecem no mundo real. Ser um pouco difcil entender todas as vantagens de OO (Orientao a Objetos). Agora, portanto, vamos mencionar apenas duas: - mais fcil conversar com o cliente que pediu o software se falarmos com objetos que existem no mundo dele (o mundo do software fica mais perto do mundo real). - O software feito com OO pode ser feito com maior qualidade e pode ser mais fcil de escrever e, principalmente, alterar no futuro. O nosso mundo est repleto de objetos, sejam eles concretos ou abstratos. Qualquer tipo de objeto possui atributos (caractersticas) e comportamentos que so inerentes a esses objetos. Para usar objetos na programao, primeiro precisamos distinguir entre um objeto real e a representao de um objeto. No desenvolvimento de programas, sempre trabalhamos com representaes de objetos. Essa representao precisa refletir os objetos reais, ou seja, objetos existentes no problema do mundo real que queremos solucionar.
3
Por exemplo, um sistema de conta corrente no manipula diretamente os clientes, contas e cheques (esses so os objetos reais do problema). Em vez disso, o software deve criar representaes desses objetos, com os mesmos atributos e comportamentos dos objetos do mundo real. Essa representao chamada de
1.3 Abstrao
Para entender isso, vamos voltar ao exemplo do sistema de conta de corrente. No mundo real existem vrios objetos Cliente, vrios objetos Conta e vrios objetos Agncia (pode ser somente um), ou seja, muito provavelmente no existir somente um cliente, uma conta e uma agncia. Todos os objetos cliente possuem o mesmo conjunto de atributos, por exemplo, todos os objetos cliente possuem nome e endereo, assim como todos os objetos conta possuem um nmero, um saldo, um histrico de transaes e todos os objetos agncia possui um nmero e um nome. Assim como os atributos, todos os objetos de um mesmo tipo compartilham do mesmo conjunto de comportamentos, por exemplo, todos os objetos Cliente fazem depsitos e saques. Apesar de cada objeto ter o mesmo conjunto de atributos, cada objeto possui valores prprios para cada atributo, ou seja, cada objeto nico. Essa explicao para objetos do mundo real vale para quando trabalhamos com a representao desses objetos no contexto de desenvolvimento desse sistema (programao). Portanto, podemos perceber que o sistema de conta corrente (programa de conta corrente) ser composto de vrios objetos, cada qual com um conjunto de atributos e comportamento em comum (se forem do mesmo tipo) e com valores prprios nos seus atributos. A figura abaixo ilustra os vrios objetos cliente, conta e agncia.
1.4 Para finalizar essa seo vamos fazer uma pequena reviso:
Um programa orientado a objeto composto por vrios objetos do mesmo tipo e de outros tipos que se relacionam. Chamamos esses objetos do mundo do software de representaes de objetos. Como num programa muito provavelmente existiro vrios objetos do mesmo tipo, devemos criar uma estrutura ou template que represente os atributos e comportamentos desses objetos do mesmo tipo, essa estrutura chamada de classe. Portanto classe uma estrutura a partir da qual os objetos (do software) so criados.
1.5 Histrico da Linguagem Java

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

Independncia de Plataforma A independncia de plataforma (portabilidade) a capacidade de o mesmo programa ser executado em diferentes plataformas e sistemas operacionais. Quando voc compila um programa em C ou na maioria das outras linguagens, o compilador transforma seu arquivo-fonte em cdigo de mquina instrues especficas para o processador que seu computador est executando. Se voc compilar seu cdigo em um sistema baseado em plataforma Intel, o programa resultante ser executado em outros sistemas baseados na plataforma Intel, mas no funcionar em computadores Macintosh, Commodore VIC-20 ou outras
mquinas. Se voc usar o mesmo programa em outras plataformas, deve transferir o seu cdigo fonte para a nova plataforma e recompil-lo para produzir o cdigo de mquina especfico para esse sistema. Em muitos casos , sero exigidas alteraes no cdigo fonte antes que ele seja compilado na nova mquina, devido a diferenas em seus processadores e outros fatores.
Os programas Java atingem essa independncia atravs da utilizao de uma mquina virtual (JVM Java Virtual Machine), uma espcie de computador dentro de outro. A mquina virtual pega os programas Java compilados e converte suas instrues em comandos que um sistema operacional possa manipular. O mesmo programa compilado, que existe em um formato chamado de bytecode, pode ser executado em qualquer plataforma e sistema operacional que possua uma JVM.
1.7 Compilador, Cdigo Fonte, JVM

Compilador Java javac Um programa fonte em Java pode ser desenvolvido em qualquer editor que permita gravar textos sem caracteres de formatao. Uma vez que o programa tenha sido salvo em um arquivo, preciso compil-lo. Para compilar um programa Java, a ferramenta oferecida pelo kit de desenvolvimento Java o compilador Java, javac. Na forma mais bsica de execuo, o javac invocado da linha de comando tendo por argumento o nome do arquivo com o cdigo Java a ser compilado. Arquivos com cdigo Java sempre utilizam a extenso .java. Por exemplo, se o cdigo a ser compilado est em um arquivo de nome Hello.java, class Hello { public static void main(String[] args) { System.out.println("Oi!"); } } sua compilao d-se atravs do comando: > javac Hello.java O resultado dessa execuo, se o programa fonte estiver sem erros, ser a criao de um arquivo Hello.class contendo o bytecode que poder ser executado em qualquer mquina. Cdigo Fonte Um arquivo contendo cdigo Java constitui uma unidade de compilao, podendo incluir comentrios, declarao relacionadas a pacotes e pelo menos uma definio de classe ou interface. Comentrios em Java podem ser expressos em trs formatos distintos: // O restante da linha corrente um comentrio. /* ... */ Comentrio no estilo C: todo o texto entre /* e */ um comentrio, podendo estender-se por diversas linhas. /** ... */ Comentrio no padro javadoc: o texto entre /** e */ ser utilizado para gerar a documentao do cdigo em formato hipertexto.
Declaraes relacionadas a pacotes podem ser: package nome.do.pacote; Opcional, mas se presente deve ser o primeiro comando do arquivo fonte. Indica que as definies que se seguem fazem parte do pacote especificado. import nome.do.pacote.Classe; import nome.do.pacote.*; Indica que a classe especificada ou, no segundo caso, quaisquer classes do pacote especificado sero utilizadas no cdigo fonte. Bytecodes Um dos grandes atrativos da plataforma tecnolgica Java a portabilidade do cdigo gerado. Esta portabilidade atingida atravs da utilizao de bytecodes. Bytecode um formato de cdigo intermedirio entre o cdigo fonte, o texto que o programador consegue manipular, e o cdigo de mquina, que o computador consegue executar. Na plataforma Java, o bytecode interpretado por uma mquina virtual Java (JVM). A portabilidade do cdigo Java obtida medida que mquinas virtuais Java esto disponveis para diferentes plataformas. Assim, o cdigo Java que foi compilado em uma mquina pode ser executado em qualquer mquina virtual Java, independentemente de qual seja o sistema operacional ou o processador que executa o cdigo:
Java Virtual Machine A Mquina Virtual Java (JVM) uma mquina de computao abstrata e um ambiente de execuo independente de plataforma. Programas escritos em Java e que utilizem as funcionalidades definidas pelas APIs dos pacotes da plataforma Java executam nessa mquina virtual. Uma das preocupaes associadas a execues nessas mquinas virtuais oferecer uma arquitetura de segurana para prevenir que applets e aplicaes distribudas executem fora de seu ambiente seguro (sandbox) a no ser quando assim habilitados. Um framework de segurana estabelecido atravs de funcionalidades dos pacotes java.security, java.security.acl, java.security.cert, java.security.interfaces e java.security.spec. Interpretador Java Uma vez que um programa Java tenha sido compilado e esteja pronto para ser interpretado por uma JVM, sua forma bsica de execuo atravs do interpretador Java. Por exemplo, se o arquivo Hello.class contm o bytecode correspondente ao cdigo fonte do arquivo Hello.java, sua execuo d-se atravs da linha de comando
> java Hello Observe que a extenso .class no includa na linha de comando. O interpretador java realiza os seguintes passos para executar o cdigo indicado: D incio execuo de uma mquina virtual Java; Carrega a classe indicada para a mquina virtual Java; Executa o mtodo main() presente nessa classe. Para que o interpretador possa localizar a classe para a mquina virtual, preciso que ela esteja localizada em um diretrio conhecido da mquina virtual, indicado pela varivel CLASSPATH. Esta deve ser definida com a lista de diretrios nos quais a JVM ir procurar pelos arquivos de classes. Por exemplo, para que os arquivos no diretrio corrente (indicado por '.') sejam localizados, definese o CLASSPATH como: > export CLASSPATH=$CLASSPATH:. > set CLASSPATH=%CLASSPATH%;. (linux/bash) (dos)
Unidade 2 - Programao Orientada a Objetos

2.1 Princpios da Linguagem Java
Os princpios da programao orientada a objetos so ilustrados atravs de exemplos na linguagem de programao Java. Aqueles interessados em outras linguagens de programao como C++, Smalltalk, Python, Eiffel podem encontrar aqui referncias a estratgias de programao orientada a objetos, mas sem os exemplos especficos nessas linguagens.
2.2 Classes
A definio de um modelo conceitual para o domnio da aplicao, contemplando as classes relevantes e suas associaes, um dos principais resultados das etapas de anlise e projeto orientado a objetos. A adoo de uma linguagem de modelagem, tal como o diagrama de classes UML, permite expressar esse resultado de maneira organizada e padronizada. Uma classe um gabarito para a definio de objetos. Atravs da definio de uma classe, descreve-se que propriedades -- ou atributos -- o objeto ter. Alm da especificao de atributos, a definio de uma classe descreve tambm qual o comportamento de objetos da classe, ou seja, que funcionalidades podem ser aplicadas a objetos da classe. Essas funcionalidades so descritas atravs de mtodos. Um mtodo nada mais que o equivalente a um procedimento ou funo, com a restrio que ele manipula apenas suas variveis locais e os atributos que foram definidos para um objeto desse tipo. Uma vez que estejam definidas quais sero as classes que iro compor uma aplicao, assim como qual deve ser sua estrutura interna e comportamento, possvel criar essas classes em Java.. O que uma Classe? Uma classe um gabarito para a definio de objetos. Atravs da definio de uma classe, descreve-se que propriedades -- ou atributos -- o objeto ter. Alm da especificao de atributos, a definio de uma classe descreve tambm qual o comportamento de objetos da classe, ou seja, que funcionalidades podem ser aplicadas a objetos da classe. Essas funcionalidades so descritas atravs de mtodos. Um mtodo nada mais que o equivalente a um procedimento ou funo, com a restrio que ele manipula apenas suas variveis locais e os atributos que foram definidos para a classe. Em UML (Unified Modeling Language), a representao para uma classe no diagrama de classes :
10
A especificao de uma classe composta por trs regies: Nome da classe Um identificador para a classe, que permite referenci-la posteriormente -- por exemplo, no momento da criao de um objeto. Atributos O conjunto de propriedades da classe. Para cada propriedade, especifica-se: nome: um identificador para o atributo. tipo: o tipo do atributo (inteiro, real, carter, etc.) valor_default: opcionalmente, pode-se especificar um valor inicial para o atributo. visibilidade: opcionalmente, pode-se especificar o quo acessvel um atributo de um objeto a partir de outros objetos. Valores possveis so: - (privativo), nenhuma visibilidade externa; + (pblico), visibilidade externa total; e # (protegido), visibilidade externa limitada. Mtodos O conjunto de funcionalidades da classe. Para cada mtodo, especifica-se sua assinatura, composta por: nome: um identificador para o mtodo. tipo: quando o mtodo tem um valor de retorno, o tipo desse valor. lista de argumentos: quando o mtodo recebe parmetros para sua execuo, o tipo e um identificador para cada parmetro. visibilidade: como para atributos, define o quo visvel um mtodo a partir de objetos de outros classes. As tcnicas de programao orientada a objetos recomendam que a estrutura de um objeto e a implementao de seus mtodos devem ser to privativos como possvel. Normalmente, os atributos de um objeto no devem ser visveis externamente. Da mesma forma, de um mtodo deve ser suficiente conhecer apenas sua especificao, sem necessidade de saber detalhes de como a funcionalidade que ele executa implementada.
11
2.3 Objetos
atravs de objetos que (praticamente) todo o processamento ocorre em aplicaes desenvolvidas com linguagens de programao orientadas a objetos. O uso racional de objetos, obedecendo aos bons princpios associados sua definio conforme estabelecido no paradigma de desenvolvimento orientado a objetos, chave para o desenvolvimento de bons sistemas de software. Toda linguagem de programao orientada a objetos oferece mecanismos para definir os tipos de objetos para cada aplicao atravs do conceito de classes. Objetos so instncias de classes; essas instncias precisam ser criadas para que, atravs de sua manipulao, possam realizar seu trabalho. Aps a concluso de suas atividades, objetos podem ser removidos. Arranjos de tipos primitivos ou de objetos so criados e manipulados de forma anloga a objetos. O que um objeto? Um objeto um elemento computacional que representa, no domnio da soluo, alguma entidade (abstrata ou concreta) do domnio de interesse do problema sob anlise. Objetos similares so agrupados em classes. No paradigma de orientao a objetos, tudo pode ser potencialmente representado como um objeto. Sob o ponto de vista da programao, um objeto no muito diferente de uma varivel no paradigma de programao convencional. Por exemplo, quando define-se uma varivel do tipo int em C ou em Java, essa varivel tem: - um espao em memria para registrar o seu estado atual (um valor); - um conjunto de operaes associadas que podem ser aplicadas a ela, atravs dos operadores definidos na linguagem que podem ser aplicados a valores inteiros (soma, subtrao, inverso de sinal, multiplicao, diviso inteira, resto da diviso inteira, incremento, decremento). Da mesma forma, quando se cria um objeto, esse objeto adquire um espao em memria para armazenar seu estado (os valores de seu conjunto de atributos, definidos pela classe) e um conjunto de operaes que podem ser aplicadas ao objeto (o conjunto de mtodos definidos pela classe). Um programa orientado a objetos composto por um conjunto de objetos que interagem atravs de "trocas de mensagens". Na prtica, essa troca de mensagem traduz-se na invocao de mtodos entre objetos. Propriedades de objetos Quando um objeto for ser utilizado em alguma aplicao (por outro objeto, normalmente), a nica informao necessria que deve ser conhecida "o que podemos fazer com ele?", ou seja, qual o conjunto de operaes associadas quele objeto. As tcnicas de programao orientada a objetos recomendam que a estrutura interna de um objeto e a implementao de seus mtodos devem ser to privativos como possvel.
12
H dois conceitos bsicos associados a essa viso de um objeto. O primeiro est associado ao fato de que cada objeto uma unidade que contm, internamente, toda a informao necessria para sua manipulao. Este o princpio da encapsulao -- cada componente de um programa deve agregar toda a informao relevante para sua manipulao como uma unidade (uma cpsula). O segundo conceito fundamental associado a um bom objeto o ocultamento da informao. Em outras palavras, quem usa o objeto no precisa nem deve conhecer como o objeto mantm sua informao ou como uma operao implementada -- cada componente de um programa deve manter oculta, sob sua guarda, esses aspectos relativos a decises de projeto. Na orientao a objetos, cada objeto deve ser manipulado exclusivamente atravs dos mtodos pblicos do objeto, dos quais apenas a assinatura deve ser revelada. O conjunto de assinaturas desses mtodos constitui a interface operacional da classe. O programador trabalha em um nvel alto de abstrao, sem preocupao com os detalhes internos da classe, simplificando a construo de programas que incorporam funcionalidades complexas, tais como interfaces grficas e aplicaes distribudas.
13
Unidade 3 - Classes em Java

3.1 Definio de Classes em Java
Em Java, classes so definidas atravs do uso da palavra-chave class. Para definir uma classe, utiliza-se a construo:
[modif] class NomeDaClasse { // corpo da classe... }
A primeira linha um comando que inicia a declarao da classe. Aps a palavra-chave class, segue-se o nome da classe, que deve ser um identificador vlido para a linguagem. O modificador modif opcional; se presente, pode ser uma combinao de public e abstract ou final. A definio da classe propriamente dita est entre as chaves { e }, que delimitam blocos na linguagem Java. Este corpo da classe usualmente obedece seguinte seqncia de definio: As variveis de classe, iniciando pelas public, seguidos pelas protected, pelas com visibilidade padro (sem modificador) e finalmente pelas private. Os atributos (ou variveis de instncia) dos objetos dessa classe, seguindo a mesma ordenao definida para as variveis de classe. Os construtores de objetos dessa classe. Os mtodos da classe, geralmente agrupados por funcionalidade. Toda classe pode tambm ter um mtodo main associado, que ser utilizado pelo interpretador Java para dar incio execuo de uma aplicao. Java tambm oferece outra estrutura, denominada interface, com sintaxe similar de classes mas contendo apenas a especificao da funcionalidade que uma classe deve conter, sem determinar como essa funcionalidade deve ser implementada. Propriedades de uma classe (meta-informao) podem ser obtidas atravs das funcionalidades oferecidas na classe java.lang.Class.
3.2 Construtores
Um construtor um (pseudo-)mtodo especial, definido para cada classe. O corpo desse mtodo determina as atividades associadas inicializao de cada objeto criado. Assim, o construtor apenas invocado no momento da criao do objeto atravs do operador new. A assinatura de um construtor diferencia-se das assinaturas dos outros mtodos por no ter nenhum tipo de retorno (nem mesmo void). Alm disto, o nome do construtor deve ser o prprio nome da classe.
14
O construtor pode receber argumentos, como qualquer mtodo. Usando o mecanismo de sobrecarga, mais de um construtor pode ser definido para uma classe. Toda classe tem pelo menos um construtor sempre definido. Se nenhum construtor for explicitamente definido pelo programador da classe, um construtor default, que no recebe argumentos, criado pelo compilador Java. No entanto, se o programador da classe criar pelo menos um mtodo construtor, o construtor default no ser criado automaticamente -- se ele o desejar, dever criar um construtor sem argumentos explicitamente. No momento em que um construtor invocado, a seguinte seqncia de aes executada para a criao de um objeto: O espao para o objeto alocado e seu contedo inicializado (bitwise) com zeros. O construtor da classe base invocado. Os membros da classe so inicializados para o objeto, seguindo a ordem em que foram declarados na classe. O restante do corpo do construtor executado. Seguir essa seqncia uma necessidade de forma a garantir que, quando o corpo de um construtor esteja sendo executado, o objeto j ter disposio as funcionalidades mnimas necessrias, quais sejam aquelas definidas por seus ancestrais. O primeiro passo garante que nenhum campo do objeto ter um valor arbitrrio, que possa tornar erros de no inicializao difceis de detectar.
15
Unidade 4 - Atributos
4.1 Atributos
A definio de atributos de uma classe Java reflete de forma quase direta a informao que estaria contida na representao da classe em um diagrama UML. Para tanto, a sintaxe utilizada para definir um atributo de um objeto :
[modificador] tipo nome [ = default];
onde
onde modificador (opcional), uma combinao de public, protected ou private; final; e static. tipo deve ser um dos tipos primitivos da linguagem Java ou o nome de uma classe; nome deve ser um identificador vlido. default (opcional) a especificao de um valor inicial para a varivel
4.2 Tipos Primitivos

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

boolean deuCerto; deuCerto = true;
Combinando definio e inicializao,

boolean deuCerto = true;
Caracteres Uma varivel do tipo char contm um carter Unicode, ocupando 16 bits de armazenamento em memria. O valor default de um atributo de classe do tipo char, se no especificado, o carter NUL (cdigo hexadecimal 0000). Um valor literal do tipo carter representado entre aspas simples (apstrofes), como em: char umCaracter = 'A'; Nesse caso, a varivel ou atributo umCaracter recebe o carter A, cdigo hexadecimal 0041 ou 65 decimal. Valores literais de caracteres podem tambm ser representados por seqncias de escape, como em '\n' (o carter newline). Unicode Unicode um padro internacional para a representao unificada de caracteres de diversas linguagens. Citando as palavras do consrcio Unicode: Caracteres Unicode so codificados em dois bytes, ao invs de um nico byte como no padro ASCII adotado em outras linguagens de programao. Dessa forma, possvel representar um nmero muito maior de caracteres, permitindo abrigar diversas linguagens. No entanto, para os usurios que utilizam caracteres do alfabeto latino, no h diferena perceptvel. Os caracteres com valores de cdigos hexadecimais entre 0000 (sendo 0020, ou 32 decimal, o primeiro carter no de controle) e 007F (127 decimal) correspondem codificao do alfabeto Basic Latin (equivalente a ASCII), que est contida em Unicode. Da mesma forma, caracteres com valores de cdigos hexadecimais entre 0080 (sendo 00A0, ou 160 decimal, o primeiro carter no de controle) e 00FF (255 decimal) correspondem codificao do alfabeto Latin-1 Supplement. Juntos, esses dois alfabetos constituem a codificao ISO 8859-1 (Latin-1), contida em Unicode: Seqncias de Escape A lista de seqncias de escape reconhecidas em Java : Seqncia
\b \t \n \f \r
Carter backspace tabulao horizontal newline form feed carriage return
17
Linguagem de Programao I \" \' \\ \xxx
aspas aspas simples contrabarra o carter com cdigo de valor octal xxx, que pode assumir valores entre 000 e 377 o carter Unicode com cdigo de valor hexadecimal xxxx, onde xxxx pode assumir valores entre 0000 e ffff
\uxxxx
Seqncias de escape Unicode (\u) so processadas antes das anteriores, podendo aparecer no apenas em variveis caracteres ou strings (como as outras seqncias) mas tambm em identificadores da linguagem Java. Inteiros Valores numricos inteiros em Java podem ser representados por variveis do tipo byte, short, int ou long. Todos os tipos contm valores inteiros com sinal, com representao interna em complemento de dois. O valor default para atributos desses tipos 0. Variveis do tipo byte ocupam 8 bits de armazenamento interno. Com esse nmero de bits, possvel representar valores na faixa de -128 a +127. Variveis do tipo short ocupam 16 bits, podendo assumir valores na faixa de -32.768 a +32.767. Variveis do tipo int ocupam 32 bits, podendo assumir valores na faixa de -2.147.483.648 a +2.147.483.647. Variveis do tipo long ocupam 64 bits, podendo assumir valores na faixa de 9.223.372.036.854.775.808 a +9.223.372.036.854.775.807. Constantes literais do tipo long podem ser identificadas em cdigo Java atravs do sufixo l ou L, como em: long valorQuePodeCrescer = 100L; Ao contrrio do que ocorre em C, no h valores inteiros sem sinal (unsigned) em Java. Combinaes da forma long int ou short int so invlidas em Java. Reais Valores reais, com representao em ponto flutuante, podem ser representados por variveis de tipo float ou double. Em qualquer situao, a representao interna desses valores segue o padro de representao IEEE 754, sendo 0.0 o valor default para tais atributos. Variveis do tipo float ocupam 32 bits, podendo assumir valores na faixa de 1.40239846E45 a 3.40282347E+38 (com nove dgitos significativos de preciso). Variveis do tipo double ocupam 64 bits, podendo assumir valores na faixa de 4.94065645841246544E-324 a 1.79769313486231570E+308 (com 18 dgitos significativos de preciso). Constantes literais do tipo float podem ser identificadas no cdigo Java pelo sufixo f ou F; do tipo double, pelo sufixo d ou D.
18
4.3 Classes wrappers

Alm dos tipos primitivos da linguagem Java, h classes pr-definidas em Java que oferecem uma srie de funcionalidades e facilidades para a manipulao desses tipos: classe Boolean; classe Character; classes para valores numricos inteiros; e classes para valores numricos reais. Strings no so tipos primitivos em Java, nem tampouco so seqncias de caracteres como em C. So objetos da classe String, tambm pr-definida em Java e que oferece diversas facilidades para a manipulao de strings. classe Boolean A classe java.lang.Boolean oferece facilidades para a manipulao de valores do tipo primitivo boolean. Por exemplo, o mtodo valueOf() permite converter uma string para um valor booleano. Se o argumento do mtodo a string "true" (independente de estar em letras maisculas ou minsculas), esse mtodo retorna o valor booleano verdadeiro (true): Examplo: Boolean.valueOf("True") returns true. Examplo: Boolean.valueOf("yes") returns false. Classe Character A classe java.lang.Character oferece diversas facilidades para a manipulao de valores do tipo carter. Por exemplo, dado que uma varivel foi definida como
char umCaracter = 'a';
as seguintes expresses retornariam o valor booleano true:

Character.isLetter(umCaracter); Character.isLetterOrDigit(umCaracter); Character.isLowerCase(umCaracter);
enquanto que as expresses a seguir retornariam false: Character.isDigit(umCaracter);

Character.isISOControl(umCaracter); Character.isSpaceChar(umCaracter); Character.isWhitespace(umCaracter); Character.isUpperCase(umCaracter);
19
H tambm funcionalidades para converso entre o valor de um dgito em uma dada base e sua representao como carter:
int Character.digit(char c, int radix); char Character.forDigit(int digit, int radix);
e para a converso entre letras minsculas e maisculas: char Character.toLowerCase(char c);

char Character.toUpperCase(char c);
Classes para manipular valores numricos inteiros Para cada tipo numrico inteiro, Java define uma classe correspondente com facilidades para manipulao de seus valores. Assim, so definidas as classes java.lang.Byte, java.lang.Short, java.lang.Integer e java.lang.Long. Em cada uma dessas classes so definidas duas constantes, que especificam qual os limites de valores representveis em uma varivel do tipo correspondente:
Byte.MIN_VALUE Byte.MAX_VALUE Short.MIN_VALUE Short.MAX_VALUE Integer.MIN_VALUE Integer.MAX_VALUE Long.MIN_VALUE Long.MAX_VALUE
Cada classe oferece tambm funcionalidades para converter uma representao de um valor da forma string para a forma numrica:
byte Byte.parseByte(String s); byte Byte.parseByte(String s, int radix); String Byte.toString(byte b); short Short.parseShort(String s); short Short.parseShort(String s, int radix); String Short.toString(short s); int int String String long long String String Integer.parseInt(String s); Integer.parseInt(String s, int radix); Integer.toString(int i); Integer.toString(int i, int radix); Long.parseLong(String s); Long.parseLong(String s, int radix); Long.toString(long l); Long.toString(long l, int radix);
20
Classes para manipular valores numricos reais Java oferece duas classes com facilidades para manipular valores numricos reais,
java.lang.Float e java.lang.Double.
Para cada uma das classes, so definidas constantes que representam os mnimo e mximo valores representveis, assim como as representaes internas para os valores infinito negativo, infinito positivo e a representao para Not A Number:
Float.MIN_VALUE Float.MAX_VALUE Float.NEGATIVE_INFINITY Float.POSITIVE_INFINITY Float.NaN Double.MIN_VALUE Double.MAX_VALUE Double.NEGATIVE_INFINITY Double.POSITIVE_INFINITY Double.NaN
H funcionalidades para testar se o valor de uma varivel corresponde a uma das situaes especiais de representao:
boolean Float.isInfinite(float v); boolean Float.isNaN(float v); boolean Double.isInfinite(double v); boolean Double.isNaN(double v);
H funcionalidades para a converso entre o valor de uma varivel e sua representao como string:
String Float.toString(float f); float Float.parseFloat(String s); String Double.toString(double d); double Double.parseDouble(String s);
H tambm funcionalidades para converter entre as representaes binrias (internas) de um nmero real e seu valor:
int float Float.floatToIntBits(float f); Float.intBitsToFloat(int bits);
long Double.doubleToLongBits(double d); double Double.longBitsToDouble(long bits);
Classe String
21
Ao contrrio do que ocorre em C e C++, strings em Java no so tratadas como seqncias de caracteres terminadas por NUL. So objetos, instncias da classe java.lang.String. Uma string pode ser criada como em:
String s = "abc";
O operador '+' pode ser utilizado concatenar strings:

System.out.println("String s: " + s);
possvel concatenar valores de outros tipos a strings:

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

System.out.println("Valor: " + Integer.toString(umInteiro));
A classe String define uma srie de funcionalidades para manipular strings, tais como: Obter o nmero de caracteres em uma string:
int length();
Concatenar strings:
String concat(String outro);
Comparar strings:
boolean equals(String outro); boolean equalsIgnoreCase(String outro); int compareTo(String outro);
Extrair caracteres e substrings:

int charAt(int posio); String substring(int pos_inicial); String substring(int pos_inicial, int pos_final);
Localizar substrings:
int indexOf(String substring); int indexOf(String substring, int pos_inicial); int lastIndexOf(String substring); int lastindexOf(String substring, int pos_inicial); boolean startsWith(String prefixo); boolean endsWith(String sufixo);
22
Unidade 5 - Mtodos
5.1 Mtodos
A forma genrica para a definio de um mtodo em uma classe
[modificador] tipo nome(argumentos) { corpo do mtodo }
onde modificador (opcional), uma combinao de: public, protected ou private; abstract ou final; e static. tipo um indicador do valor de retorno, sendo void se o mtodo no tiver um valor de retorno; nome do mtodo deve ser um identificador vlido argumentos so representados por uma lista de parmetros separados por vrgulas, onde cada parmetro obedece forma tipo nome. Mtodos so essencialmente procedimentos que podem manipular atributos de objetos para os quais o mtodo foi definido. Alm dos atributos de objetos, mtodos podem definir e manipular variveis locais; tambm podem receber parmetros por valor atravs da lista de argumentos. Uma boa prtica de programao manter a funcionalidade de um mtodo simples, desempenhando uma nica tarefa. O nome do mtodo deve refletir de modo adequado a tarefa realizada. Se a funcionalidade do mtodo for simples, ser fcil encontrar um nome adequado para o mtodo. Como ocorre para a definio de atributos, a definio de mtodos reflete de forma quase direta a informao que estaria presente em um diagrama de classes UML, a no ser por uma diferena vital: o corpo do mtodo. Mtodos de mesmo nome podem co-existir em uma mesma classe desde que a lista de argumentos seja distinta, usando o mecanismo de sobrecarga..
5.2 private
A palavra-chave private restringe a visibilidade do membro modificado, mtodo ou atributo, exclusivamente a objetos da prpria classe que contm sua definio.
23
5.3 public
Em Java, a visibilidade padro de classes, atributos e mtodos est restrita a todos os membros que fazem parte de um mesmo pacote. A palavra-chave public modifica essa visibilidade de forma a ampli-la, deixando-a sem restries. Uma classe definida como pblica pode ser utilizada por qualquer objeto de qualquer pacote. Em Java, uma unidade de compilao (um arquivo fonte com extenso .java) pode ter no mximo uma classe pblica, cujo nome deve ser o mesmo do arquivo (sem a extenso). As demais classes na unidade de compilao, no pblicas, so consideradas classes de suporte para a classe pblica e tm a visibilidade padro. Um atributo pblico de uma classe pode ser diretamente acessado e manipulado por objetos de outras classes. Um mtodo pblico de uma classe pode ser aplicado a um objeto dessa classe a partir de qualquer outro objeto de outra classe. O conjunto de mtodos pblicos de uma classe determina o que pode ser feito com objetos da classe, ou seja, determina o seu comportamento.
5.4 protected
A palavra-chave protected restringe a visibilidade do membro modificado, atributo ou mtodo, apenas prpria classe e quelas derivada desta.
5.5 abstract
Uma classe abstrata no pode ser instanciada, ou seja, no h objetos que possam ser construdos diretamente de sua definio. Por exemplo, a compilao do seguinte trecho de cdigo
abstract class AbsClass { public static void main(String[] args) { AbsClass obj = new AbsClass(); } }
geraria a seguinte mensagem de erro:

AbsClass.java:3: class AbsClass is an abstract class. It can't be instantiated. AbsClass obj = new AbsClass(); ^ 1 error
Classes abstratas correpondem a especificaes genricas, que devero ser concretizadas em classes derivadas. Mtodo abstrato
24
Uma classe abstrata pode conter um ou mais mtodos abstratos. Um mtodo abstrato no cria uma definio, mas apenas uma declarao de um mtodo que dever ser implementado em uma classe derivada. Se esse mtodo no for implementado na classe derivada, esta permanece como uma classe abstrata mesmo que no tenha sido assim declarada explicitamente. Por exemplo, a compilao de
abstract class AbsClass { abstract void meth(); } class DerClass extends AbsClass { public static void main(String[] args) { DerClass obj = new DerClass(); } }
gera dois erros:

AbsClass.java:5: class DerClass must be declared abstract. It does not define void meth() from class AbsClass. class DerClass extends AbsClass { ^ AbsClass.java:7: class DerClass is an abstract class. It can't be instantiated. DerClass obj = new DerClass(); ^ 2 errors
No entanto, se for includa uma implementao de meth() na classe derivada:

abstract class AbsClass { abstract void meth(); } class DerClass extends AbsClass { void meth() { } public static void main(String[] args) { DerClass obj = new DerClass(); } }
ento nenhum erro de compilao ocorre.
5.6 final
A palavra chave final pode ser utilizada como uma indicao de algo que no deve ser modificado ao longo do restante da hierarquia de descendentes de uma classe. Pode ser associada a atributos, a mtodos e a classes. Classe final Uma classe definida como final no pode ser estendida. Assim, a compilao do arquivo Reeleicao.java
final class Mandato { } public class Reeleicao extends Mandato { }
ocasionaria um erro de compilao:
25
Linguagem de Programao I caolho:Exemplos[39] javac Reeleicao.java Reeleicao.java:4: Can't subclass final classes: class Mandato public class Reeleicao extends Mandato { ^
1 error
Atributo final Um atributo final pode indicar um valor constante, que no deve ser alterado pela aplicao. Apenas valores de tipos primitivos podem ser utilizados para definir constantes. O valor do atributo deve ser definido no momento da declarao, pois no permitida nenhuma atribuio em outro momento. A utilizao de final para uma referncia a objetos permitida. Como no caso de constantes, a definio do valor (ou seja, a criao do objeto) tambm deve ser especificada no momento da declarao. No entanto, preciso ressaltar que o contedo do objeto em geral pode ser modificado -- apenas a referncia fixa. O mesmo vlido para arranjos. A partir de Java 1.1, possvel ter atributos de uma classe que sejam final mas no recebem valor na declarao, mas sim nos construtores da classe. (A inicializao deve obrigatoriamente ocorrer em uma das duas formas.) So os chamados blank finals, que introduzem um maior grau de flexibilidade na definio de constantes para objetos de uma classe, uma vez que essas podem depender de parmetros passados para o construtor. Argumentos de um mtodo que no devem ser modificados podem ser declarados como final, tambm, na prpria lista de parmetros. Mtodo final Um mtodo que definido como final em uma classe no pode ser redefinido em classes derivadas. Considere o seguinte exemplo j visto anteriormente:
1:class ComFinal { 2: final int f() { 3: return 1; 4: } 5:} 6: 7:public class ExtComFinal extends ComFinal { 8: int f() { 9: return 0; 10: } 11:}
A tentativa de compilao dessa unidade geraria a seguinte mensagem de erro

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

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

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

6.1 Manipulao de Objetos
Quando declara-se uma varivel cujo tipo o nome de uma classe, como em
String nome;
no est se criando um objeto dessa classe, mas simplesmente uma referncia para um objeto da classe String, a qual inicialmente no faz referncia a nenhum objeto vlido:
Quando um objeto dessa classe criado, obtm-se uma referncia vlida, que armazenada na varivel cujo tipo o nome da classe do objeto. Por exemplo, quando cria-se uma string como em
nome = new String("POO/Java");
nome uma varivel que armazena uma referncia para um objeto especfico da classe String -- o objeto cujo contedo "POO/Java":
importante ressaltar que a varivel nome mantm apenas a referncia para o objeto e no o objeto em si. Assim, uma atribuio como
String outroNome = nome;
no cria outro objeto, mas simplesmente uma outra referncia para o mesmo objeto:
29
O nico modo de aplicar os mtodos a um objeto atravs de uma referncia ao objeto. Seguindo com o mesmo exemplo, para criar um novo objeto como mesmo contedo do objeto existente, o mtodo clone() pode ser aplicado a este:
String outraString = nome.clone();
Em Java, a palavra-chave this utilizada por um objeto para fazer a referncia a si prprio.
6.2 this
Quando um mtodo aplicado a um objeto, de algum modo deve ser sinalizado ao mtodo a qual objeto a invocao est referindo-se. Por exemplo,
String String int x1 int x2 s1 = "java"; s2 = "linguagem de programao orientada a objetos"; = s1.length(); // 4 = s2.length(); // 44
Nesse exemplo, o mtodo aplicado s duas strings o mesmo -- length(). Como o mtodo sabe qual o objeto que ele deve "olhar" para saber o que fazer?
30
Por trs da resposta a essa pergunta est a presena de um "parmetro secreto", que passado a todo mtodo, que uma referncia ao objeto que est realizando a invocao. Em termos de uma linguagem procedimental, isso seria o equivalente a ter para as duas ltimas linhas do exemplo acima :
int x1 = length(s1); int x2 = length(s2);
Se necessrio, o prprio mtodo pode ter acesso a essa referncia em seu cdigo. Essa referncia passada atravs da palavra-chave this, reservada para esse propsito.
6.3 Exemplos de Uso de this

A palavra-chave this utilizada principalmente em dois contextos: - Diferenciar atributos de objetos de parmetros ou variveis locais de mesmo nome; - Acessar o mtodo construtor a partir de outros construtores. Esse exemplo ilustra esses dois usos
class ThisSample { int x; int y; // exemplo do primeiro caso: public ThisSample(int x, int y) { this.x = x; this.y = y; } // exemplo do segundo caso: public ThisSample( ) { this(1, 1); } }
6.4 Remoo de objetos

Em linguagens de programao orientadas a objetos, a criao de objetos um processo que determina a ocupao dinmica de muitos pequenos segmentos de memria. Se esse espao no fosse devolvido para reutilizao pelo sistema, a dimenso de aplicaes desenvolvidas com linguagens de programao orientadas a objetos estaria muito limitada.
31
As duas abordagens possveis so dedicar essa tarefa ao programador ou deixar que o sistema seja o responsvel por esta retomada de recursos. O problema da primeira abordagem que o programador pode no considerar todas as possibilidades, ocasionando problemas como "vazamento de memria" (memory leak). Na segunda abordagem, recursos adicionais do sistema so necessrios para a manuteno da informao necessria para saber quando um recurso pode ser retomado e para a execuo do processo que retoma os recursos. C++ uma linguagem que adota a primeira estratgia. A remoo de objetos efetivada explicitamente pelo programador (atravs do operador delete), que pode tambm especificar o procedimento que deve ser executado para a liberao de outros recursos alocados pelo objeto atravs de um mtodo destructor. Java, assim como Smalltalk e lisp, adota a abordagem de ter um garbage collector verificando que objetos no tm nenhuma referncia vlida, retomando o espao dispensado para cada um desses objetos. Dessa forma, o programador no precisa se preocupar com a remoo explcita de objetos. Adicionalmente, pode ser necessrio liberar outros recursos que tenham sido alocados para o objeto. O mtodo finalize() especifica o que deve ser feito antes do espao do objeto ser retomado pelo garbage collector. Esse mtodo definido na classe Object como protected. Portanto, se for necessrio redefini-lo o programador deve tambm declar-lo como protected. preciso observar que o uso de finalize() ocorre atravs da redefinio de mtodos. Assim, ao contrrio do que acontece com construtores (onde o mtodo correspondente na superclasse automaticamente invocado), o mtodo finalizador da superclasse deve ser invocado explicitamente (super.finalize()) ao final do corpo do finalizador local. Uma observao adicional com relao a garbage collectors que programadores no tm como atuar explicitamente sobre esse processo. No entanto, o programador pode: - remover explicitamente a referncia a um objeto para sinalizar ao GC que o objeto no mais necessrio e pode ser removido; - sugerir ao (mas no forar que o) sistema que execute o garbage collector atravs da invocao ao mtodo gc() da classe java.lang.System: public static void gc() - sugerir que o sistema exexute os mtodos finalize() de objetos descartados atravs do mtodo runFinalization da classe java.lang.System:
6.5 A Classe Object

A classe java.lang.Object a raiz a partir da qual todas as classes so definidas. Desse modo, as definies dessa classe esto disponveis para objetos de todas as demais classes. O mtodo equals, que permite comparar objetos por seus contedos, um dos mtodos definido nessa classe:
32
Linguagem de Programao I public boolean equals(Object obj)
O mtodo clone() permite criar duplicatas de um objeto O mtodo toString() permite converter uma representao interna do objeto em uma string que pode ser apresentada ao usurio: A partir do objeto retornado, da classe java.lang.Class, possvel obter o nome da classe usando o mtodo da classe Class getName(), que retorna uma string com o nome da classe.
33
Unidade 7 - Herana
7.1 Herana
Um dos grandes diferenciais da programao orientada a objetos em relao a outros paradigmas de programao est no conceito de herana, mecanismo atravs do qual definies existentes podem ser facilmente estendidas. Juntamente com a herana deve ser enfatizada a importncia do polimorfismo, que permite selecionar funcionalidades que um programa ir utilizar de forma dinmica, durante sua execuo. O conceito de encapsular estrutura e comportamento em um tipo no exclusivo da orientao a objetos; particularmente, a programao por tipos abstratos de dados segue esse mesmo conceito. O que torna a orientao a objetos nica o conceito de herana. Herana um mecanismo que permite que caractersticas comuns a diversas classes sejam fatoradas em uma classe base, ou superclasse. A partir de uma classe base, outras classes podem ser especificadas. Cada classe derivada ou subclasse apresenta as caractersticas (estrutura e mtodos) da classe base e acrescenta a elas o que for definido de particularidade para ela. Sendo uma linguagem de programao orientada a objetos, Java oferece mecanismos para definir classes derivadas a partir de classes existentes. fundamental que se tenha uma boa compreenso sobre como objetos de classes derivadas so criados e manipulados, assim como das restries de acesso que podem se aplicar a membros de classes derivadas. Tambm importante para uma completa compreenso da utilizao desse mecanismo em Java a compreenso de como relacionam-se interfaces e herana. Herana sempre utilizada em Java, mesmo que no explicitamente. Quando uma classe criada e no h nenhuma referncia sua superclasse, implicitamente a classe criada derivada diretamente da classe Object. por esse motivo que todos os objetos podem invocar os mtodos da classe Object, tais como equals() e toString().
7.2 Formas de Herana

H vrias formas de relacionamentos em herana: Extenso: subclasse estende a superclasse, acrescentando novos membros (atributos e/ou mtodos). A superclasse permanece inalterada, motivo pelo qual este tipo de relacionamento normalmente referenciado como herana estrita. Especificao: a superclasse especifica o que uma subclasse deve oferecer, mas no implementa nenhuma funcionalidade. Diz-se que apenas a interface (conjunto de especificao dos mtodos pblicos) da superclasse herdada pela subclasse. Combinao de extenso e especificao: a subclasse herda a interface e uma implementao padro de (pelo menos alguns de) mtodos da superclasse. A subclasse pode ento redefinir mtodos para especializar o comportamento em relao ao que oferecido pela superclasse, ou ter que oferecer alguma implementao para mtodos que a superclasse tenha
34
declarado mas no implementado. Normalmente, este tipo de relacionamento denominado herana polimrfica. A ltima forma , sem dvida, a que mais ocorre na programao orientada a objetos. Algumas modelagens introduzem uma forma de herana conhecida como contrao, que deve ser evitada.
7.3 Contrao
Contrao uma uma variante de herana onde a subclasse elimina mtodos da superclasse com o objetivo de criar uma "classe mais simples". A eliminao pode ocorrer pela redefinio de mtodos com corpo vazio. O problema com este mecanismo que ele viola o princpio da substituio, pois a subclasse j no pode mais ser utilizada em todos os pontos onde a superclasse poderia ser utilizada. Se a contrao parece ser uma soluo adequada em uma hierarquia de classes, provavelmente a hierarquia deve ser re-analisada para deteco de inconsistncias (problema pssaros-pinguins). De modo geral, o mecanismo de contrao deve ser evitado.
7.4 Sintaxe
A forma bsica de herana em Java a extenso simples entre uma superclasse e sua classe derivada. Para tanto, utiliza-se na definio da classe derivada a palavra-chave extends seguida pelo nome da superclasse. Assim, definir uma classe Ponto2D como em class Ponto2D {
// ... }
equivalente a
class Ponto2D extends Object { // ... }
O exemplo completo ilustra como uma classe Ponto2D pode ser utilizada como base para a definio de outra classe derivada Ponto3D atravs do mecanismo de extenso simples.
class Ponto2D { private int x; private int y; public Ponto2D(int x, int y) { this.x = x; this.y = y; } public Ponto2D( ) { this(0,0);
35
Linguagem de Programao I } public double distancia(Ponto2D p) { double distX = p.x - x; double distY = p.y - y; return(Math.sqrt(distX*distX + distY*distY)); } } class Ponto3D extends Ponto2D { private int z; public Ponto3D(int x, int y, int z) { super(x, y); this.z = z; } public Ponto3D( ) { z = 0; } public static void main(String[] args) { Ponto2D ref2 = new Ponto2D(); Ponto2D p2 = new Ponto2D(1,1); System.out.println("Distancia2: " + p2.distancia(ref2)); Ponto3D p3 = new Ponto3D(1,2,3); System.out.println("Distancia3: " + p3.distancia(ref2)); } }
7.5 Construo de Objetos Derivados

Durante a construo de um objeto de uma classe derivada, o construtor de sua superclasse executado (implicitamente ou explicitamente) antes de executar o corpo de seu construtor. Assim, ao se construir um objeto de uma classe derivada, o mtodo construtor da superclasse ser inicialmente invocado. Este, por sua vez, invocar o construtor de sua superclasse, at que o construtor da classe raiz de toda a hierarquia de objetos -- a classe Object - seja invocado. Como Object no tem uma superclasse, seu construtor executado e a execuo retorna para o construtor de sua classe derivada. Ento executa-se o restante do construtor de sua classe derivada e a execuo retorna para o construtor de sua classe derivada e assim sucessivamente, at que finalmente o restante do construtor da classe para a qual foi solicitada a criao de um objeto seja executada. Construtores da superclasse podem ser explicitamente invocados usando a palavra-chave super
7.6 A Palavra-Chave super
36
Java no oferece o mecanismo de herana mltipla, ou seja, no possvel criar uma classe derivada com mais de uma classe base. Por esse motivo, simples fazer uma referncia da classe derivada para sua superclasse; o mecanismo para tal o uso da palavra-chave super. Construtores da superclasse podem ser explicitamente invocados usando o mtodo super(). No exemplo do Ponto3D, isso feito para o construtor da classe derivada com argumentos:
public Ponto3D(int x, int y, int z) { super(x, y); this.z = z; }
A expresso super(x, y); na primeira linha do construtor est invocando o construtor da classe base, Ponto2D, que recebe dois argumentos. O efeito dessa invocao iniciar os valores dos atributos x e y do objeto com os valores dos parmetros x e y recebidos pelo mtodo construtor. A invocao do mtodo super(), se presente, deve estar na primeira linha. Implicitamente, o compilador faz a invocao do construtor super() default (sem argumentos) para cada construtor definido. Por esse motivo, o segundo construtor da classe Ponto3D no faz a invocao desse mtodo explicitamente. Assim,
public Ponto3D( ) { z = 0; }
equivale a
public Ponto3D( ) { super(); z = 0; }
Esse um dos motivos pelo qual sempre interessante ter o construtor default definido. Entretanto, a invocao direta pode ser interessante quando se deseja invocar algum construtor que no o default, como no exemplo anterior. Outro uso dessa palavra-chave como prefixo para referenciar mtodos da superclasse.
class Ponto2D { private int x; private int y; public Ponto2D(int x, int y) { this.x = x; this.y = y; } public Ponto2D( ) { this(0,0); }
37
public double distancia(Ponto2D p) { double distX = p.x - x; double distY = p.y - y; return(Math.sqrt(distX*distX + distY*distY)); } } class Ponto3D extends Ponto2D { private int z; public Ponto3D(int x, int y, int z) { super(x, y); this.z = z; } public Ponto3D( ) { z = 0; } public static void main(String[] args) { Ponto2D ref2 = new Ponto2D(); Ponto2D p2 = new Ponto2D(1,1); System.out.println("Distancia2: " + p2.distancia(ref2)); Ponto3D p3 = new Ponto3D(1,2,3); System.out.println("Distancia3: " + p3.distancia(ref2)); }
7.7 Restries de acesso

O exemplo da classe Ponto3D ilustra a forma bsica de herana -- uma vez que uma classe tenha sido definida como derivada de outra, ela preserva da superclasse os atributos (no caso, os valores das coordenadas x e y) e seus mtodos (no caso, o mtodo distancia(Ponto2D) aplicado a um Ponto3D). No entanto, deve ser observado que nenhum mtodo definido para a classe Ponto3D pode ter acesso aos atributos x e y, pois esses so declarados como private da classe Ponto2D. De fato, caso tente-se definir naquela classe um mtodo para calcular a distancia entre dois pontos no espao, tal como:
public double distancia(Ponto3D p) { double distX = p.x - x; double distY = p.y - y; double distZ = p.z - z; return(Math.sqrt(distX*distX + distY*distY + distZ*distZ)); }
os seguintes erros seriam detectados pelo compilador Java:

Ponto3Derr.java:35: No variable x defined in class Ponto3D. double distX = p.x - x;
38
Linguagem de Programao I ^ Ponto3Derr.java:35: Undefined variable: x double distX = p.x - x; ^ Ponto3Derr.java:36: No variable y defined in class Ponto3D. double distY = p.y - y; ^ Ponto3Derr.java:36: Undefined variable: y double distY = p.y - y; ^
ou seja, mesmo embora a classe Ponto3D tenha os atributos x e y, mtodos dessa classe no podem manipul-los diretamente. Uma alternativa para permitir que classes derivadas possam manipular atributos da superclasse declarar tais atributos como protected ao invs de private. Assim, objetos de classes derivadas tm acesso tanto de leitura como de escrita para esses atributos. Caso deseje-se dar acesso apenas de leitura a esses atributos, uma outra alternativa usar um mtodo acessor para cada atributo, ou seja, um mtodo que simplesmente retorna o valor do atributo. Nesse exemplo, a classe Ponto2D definiria dois mtodos,
public int getX() { return x; } public int getY() { return y; }
que permitem que qualquer objeto de qualquer classe consiga ler os valores de x e y -- mas no alter-los. Assim, a classe Ponto3D poderia definir o mtodo para a distncia no espao como
public double distancia(Ponto3D p) { double distX = p.getX() - this.getX(); double distY = p.getY() - this.getY(); double distZ = p.z - z; return(Math.sqrt(distX*distX + distY*distY + distZ*distZ)); }
que compilaria e executaria sem erros. Pode-se tambm permitir acesso de apenas leitura somente para as classes derivadas -nesse caso, os mtodos acessores seriam declarados como protected, como em
protected int getX() { return x; } protected int getY() { return y; }
O mtodo distancia(Ponto3D) no precisaria sofrer nenhuma modificao, mas outras classes no-derivadas de Ponto2D no teriam mais como invocar esses mtodos acessores.
39
Unidade 8 - Polimorfismo
8.1 Polimorfismo:
Polimorfismo o princpio pelo qual duas ou mais classes derivadas de uma mesma superclasse podem invocar mtodos que tm a mesma identificao (assinatura) mas comportamentos distintos, especializados para cada classe derivada, usando para tanto uma referncia a um objeto do tipo da superclasse. A deciso sobre qual o mtodo que deve ser selecionado, de acordo com o tipo da classe derivada, tomada em tempo de execuo, atravs do mecanismo de ligao tardia.
8.2 Ligao Tardia:

Quando o mtodo a ser invocado definido durante a compilao do programa, o mecanismo de ligao prematura (early binding) utilizado. Para a utilizao de polimorfismo, a linguagem de programao orientada a objetos deve suportar o conceito de ligao tardia (late binding), onde a definio do mtodo que ser efetivamente invocado s ocorre durante a execuo do programa. O mecanismo de ligao tardia tambm conhecido pelos termos dynamic binding ou run-time binding. Em Java, todas as determinaes de mtodos a executar ocorrem atravs de ligao tardia exceto em dois casos: - mtodos declarados como final no podem ser redefinidos e portanto no so passveis de invocao polimrfica da parte de seus descendentes; - e mtodos declarados como private so implicitamente finais. No caso de polimorfismo, necessrio que os mtodos tenham exatamente a mesma identificao, sendo utilizado o mecanismo de redefinio de mtodos (overriding). Esse mecanismo de redefinio muito diferente do mecanismo de sobrecarga de mtodos (overloading)..
8.3 Sobrecarga (overloading):

Na programao orientada a objetos, um mtodo aplicado a um objeto selecionado para execuo com base na classe a que ele pertence, no nome do mtodo e nos tipos de seus parmetros. O nome do mtodo com a lista de tipos de parmetros constituem a assinatura do mtodo. Atravs do mecanismo de sobrecarga, dois mtodos de uma classe podem ter o mesmo nome, desde que suas assinaturas sejam diferentes. Tal situao no gera conflito pois o compilador capaz de detectar qual mtodo deve ser escolhido a partir da anlise dos argumentos do mtodo.
40
Um exemplo do uso de sobrecarga em Java encontrado nos mtodos abs(), max() e min() da classe java.lang.Math, que tm implementaes alternativas para quatro tipos de argumentos distintos. O uso de polimorfismo em Java ilustrado atravs de um exemplo. Atravs desse exemplo introduzem-se os conceitos relacionados de upcasting e a motivao para a definio de mtodos abstratos.
8.4 Polimorfismo em Java:

Considere uma classe Veculo com duas classes derivadas, Automvel e Bicicleta:
Essas classes tm trs mtodos, definidos para veculos de forma geral e redefinidos mais especificamente para automveis e bicicletas:
checkList(), para verificar o que precisa ser analisado no veculo; adjust(), para realizar os reparos e a manuteno necessria; e cleanup(), para realizar procedimentos de limpeza do veculo.
A aplicao Oficina define um objeto que recebe objetos da classe Veculo. Para cada veculo recebido, a oficina executa na seqncia os trs mtodos da classe Veculo. No entanto, no h como saber no momento da programao se a Oficina estar recebendo um automvel ou uma bicicleta -- assim, o momento de deciso sobre qual mtodo ser aplicado s ocorrer durante a execuo do programa.
import java.util.*; class Veiculo { public Veiculo() { System.out.print("Veiculo "); } public void checkList() { System.out.println("Veiculo.checkList"); } public void adjust() { System.out.println("Veiculo.adjust");
41
Linguagem de Programao I } public void cleanup() { System.out.println("Veiculo.cleanup"); } } class Automovel extends Veiculo { public Automovel() { System.out.println("Automovel"); } public void checkList() { System.out.println("Automovel.checkList"); } public void adjust() { System.out.println("Automovel.adjust"); } public void cleanup() { System.out.println("Automovel.cleanup"); } } class Bicicleta extends Veiculo { public Bicicleta() { System.out.println("Bicicleta"); } public void checkList() { System.out.println("Bicicleta.checkList"); } public void adjust() { System.out.println("Bicicleta.adjust"); } public void cleanup() { System.out.println("Bicicleta.cleanup"); } } public class Oficina { Random r = new Random(); public Veiculo proximo() { Veiculo v; int code = r.nextInt(); if (code%2 == 0) v = new Automovel(); else v = new Bicicleta(); return v; } public void manter(Veiculo v) { v.checkList(); v.adjust(); v.cleanup(); } public static void main(String[] args) {
42
Linguagem de Programao I Oficina o = new Oficina(); Veiculo v; for (int i=0; i<4; ++i) { v = o.proximo(); o.manter(v); } } }
Este trecho de cdigo ilustra a utilizao da classe Oficina, considerando que os mtodos acima foram definidos para Veculo e para todas as suas classes derivadas. Um possvel resultado da interpretao dessa aplicao :
Veiculo Bicicleta Bicicleta.checkList Bicicleta.adjust Bicicleta.cleanup Veiculo Bicicleta Bicicleta.checkList Bicicleta.adjust Bicicleta.cleanup Veiculo Automovel Automovel.checkList Automovel.adjust Automovel.cleanup Veiculo Automovel Automovel.checkList Automovel.adjust Automovel.cleanup
Alguns pontos a destacar com relao a esse exemplo:
8.5 Upcasting:
O mtodo Oficina.proximo() realiza uma atribuio de um objeto Automvel varivel (referncia para objeto Veiculo) v quando o valor do nmero aleatrio gerado par (o resto da diviso inteira por 2 igual a 0). Essa atribuio de um objeto de uma classe mais especializada para uma referncia de uma classe ancestral denominada upcast. Esse mesmo tipo de atribuio realizado de Bicicleta para veculo quando o nmero aleatrio gerado mpar. Recuperando informao sobre um tipo O uso de polimorfismo est intimamente relacionado ao mecanismo de upcast, onde parte da informao sobre um objeto torna-se inacessvel - ou seja, informao momentaneamente perdida. Esse processo seguro do ponto de vista da orientao a objetos pois a interface da classe base nunca maior que a interface da classe derivada. H situaes onde interessante recuperar a referncia para o tipo original de um objeto, de modo a obter acesso sua funcionalidade completa. Para tanto, o mecanismo de downcast precisa ser utilizado:
43
Linguagem de Programao I Ref_orig = (Tipo_orig) Ref_upcast;
O problema com downcasting que preciso verificar se o objeto que est tendo sua referncia convertida realmente do tipo especificado, ou caso contrrio seria impossvel garantir sua manipulao correta aps a converso. Em Java, todas as operaes de downcasting so verificadas atravs do mecanismo de Run-Time Type Identification (RTTI) suportado pela linguagem. Lembre-se que possvel, para qualquer objeto, obter a indicao de a qual classe ele pertence atravs do mtodo getClass().
8.6 Uso de mtodos abstratos:

Apesar de mtodos da classe Veculo terem sido definidos, estes nunca so invocados nesse exemplo. (Se fossem, algo estaria errado.) Isso ilustra uma situao onde mtodos abstratos poderiam ser utilizados, pois a definio do corpo desses mtodos de fato irrelevante. Ainda mais, se uma classe como essa s contm mtodos abstratos, ela poderia ser implementada como uma interface Java. importante observar que, quando polimorfismo est sendo utilizado, o comportamento que ser adotado por um mtodo s ser definido durante a execuo. Embora em geral esse seja um mecanismo que facilite o desenvolvimento e a compreenso do cdigo orientado a objetos, h algumas situaes onde o resultado da execuo pode ser no-intuitivo, como ilustra esse exemplo que usa polimorfismo em construtores.
8.7 Polimorfismo em construtores:

A invocao de mtodos com ligao tardia abre uma possibilidade de invocar construtores cujo comportamento poderia ser diferenciado polimorficamente. A ttulo de exemplo, considere o seguinte cdigo:
abstract class Base { abstract void m(); public Base() { System.out.println("Base: inicio construcao"); m(); System.out.println("Base: fim construcao"); } } public class Derivada extends Base { int valor = 1; void m() { System.out.println("Derivada.m: " + valor); } public Derivada(int v) { System.out.println("Derivada: inicio construcao"); valor = v; System.out.println("Derivada: fim construcao"); } public static void main(String[] args) { new Derivada(10);
44
Linguagem de Programao I } }
envolvendo uma classe Derivada e uma classe Base cujo construtor invoca um mtodo implementado na classe derivada e apresenta o seguinte resultado.
Base: inicio construcao Derivada.m: 0 Base: fim construcao Derivada: inicio construcao Derivada: fim construcao
O resultado dessa execuo pode ser explicado pela seqncia de aes que obedecida para a construo de um objeto a partir do momento no qual seu construtor invocado. O comportamento apresentado nesse exemplo pode ser diferente daquele intuitivamente esperado por um programador que esteja analisando um cdigo onde esta situao. Em um programa de maior porte, pode levar a situaes de erro de difcil deteco. A recomendao que se faz com relao utilizao de mtodos no corpo de construtores No invoque mtodos no corpo de construtores a menos que isto seja seguro. Mtodos seguros para invocao a partir de construtores so aqueles que no podem ser redefinidos.
45
Unidade 9 - Interfaces
9.1 Interface:
Uma interface Java uma classe abstrata para a qual todos os mtodos so implicitamente abstract e public, e todos os atributos so implicitamente static e final. Em outros termos, uma interface Java implementa uma "classe abstrata pura". A sintaxe para a declarao de uma interface similar quela para a definio de classes, porm seu corpo define apenas assinaturas de mtodos e constantes. Uma interface estabelece uma espcie de contrato que obedecido por uma classe. Quando uma classe implementa uma interface, garante-se que todas as funcionalidades especificadas pela interface sero oferecidas pela classe.
9.2 Declarao de interface:

A sintaxe para a definio de uma interface Java equivale quela da definio de uma classe, apenas usando a palavra chave interface ao invs da palavra chave class. Por exemplo, para definir uma Interface1 que declara um mtodo void met1() a sintaxe :
interface Interface1 { void met1(); }
A diferena entre uma classe abstrata e uma interface Java que a interface obrigatoriamente no tem um "corpo" associado. Para que uma classe seja abstrata basta que ela seja assim declarada, mas a classe pode incluir atributos de objetos e definio de mtodos, pblicos ou no. Na interface, apenas mtodos pblicos podem ser declarados -- mas no definidos. Da mesma forma, no possvel definir atributos -- apenas constantes pblicas. Enquanto uma classe abstrata "estendida" (palavra chave extends) por classes derivadas, uma interface Java "implementada" (palavra chave implements) por outras classes.
9.3 Implementao de Interfaces:

Uma vez que interfaces estejam definidas, como so usadas? Interfaces so especificaes que so ou sero implementadas atravs de classes Java. Por exemplo, uma interface Abc definida como
interface Abc { void a(int i); int b(String s); String c(); }
46
Indica que qualquer classe implementando essa especificao oferece pelo menos os trs mtodos, exatamente com as assinaturas descritas. No necessrio saber como os mtodos esto sendo implementados. Uma classe Xyz que implementa a especificao de uma interface Abc declarada com a sintaxe:
class Xyz implements Abc { // declaraes, outros mtodos void a(int valor) { ... } int b(String nome) { ... } String c( ) { ... } }
na classe que o corpo de cada um dos mtodos da interface efetivamente especificado, determinando como ocorre a implementao.
9.4 Definio de Constantes:

Outro uso de interfaces Java para a definio de constantes que devem ser compartilhadas por diversas classes. Neste caso, a recomendao implementar interfaces sem mtodos, pois as classes que implementarem tais interfaces no precisam tipicamente redefinir nenhum mtodo:
interface Coins { int PENNY = 1, NICKEL = 5, DIME = 10, QUARTER = 25, DOLAR = 100; } class CokeMachine implements Coins { int price = 3*QUARTER; // ... }
47
Unidade 10 10.1 Identificadores
Identificadores
Nomes de classes, variveis e mtodos devem ser identificadores vlidos da linguagem. Esses identificadores so seqncias de caracteres Unicode. As regras para a definio de identificadores so: - Um nome pode ser composto por letras (minsculas e/ou maisculas), dgitos e os smbolos _ e $. - Um nome no pode ser iniciado por um dgito (0 a 9). - Letras maisculas so diferenciadas de letras minsculas. - Uma palavra-chave da linguagem Java no pode ser um identificador. Alm dessas regras obrigatrias, o uso da conveno padro para identificadores Java torna a codificao mais uniforme e pode facilitar o entendimento de um cdigo.
10.2 Palavras Reservadas em Java:

As palavras a seguir so de uso reservado em Java e no podem ser utilizadas como nomes de identificadores:
abstract boolean break byte case catch char class const continue default do double else extends final finally float for goto if implements import instanceof int interface long native new null package private protected public return short static super switch synchronized this throw throws transient try void volatile while
10.3 Conveno para identificadores:
48
Embora no seja obrigatrio, o conhecimento e uso da seguinte conveno padro para atribuir nomes em Java pode facilitar bastante a manuteno de um programa: - Nomes de classes so iniciados por letras maisculas. - Nomes de mtodos, atributos e variveis so iniciados por letras minsculas. - Em nomes compostos, cada palavra do nome iniciada por letra maiscula -- as palavras no so separadas por nenhum smbolo. - Detalhes sobre as convenes de codificao sugeridas pelos projetistas da linguagem Java podem ser encontrados no documento Code Conventions for the JavaTM Programming Language
49
Unidade 11 public static void gc()11.1 Expresses:
Expresses
Expresses em Java so terminadas por ";", podendo incluir expresses do tipo operao aritmtica, operao lgica inteira, operao lgica booleana, condies, atribuio, retorno, e operaes sobre objetos.
11.1 Expresses Aritmticas:

Expresses aritmticas envolvem atributos, variveis e/ou constantes numricas (inteiras ou reais). Os operadores aritmticos definidos em Java incluem soma (+); subtrao (-); multiplicao (*); diviso (/); resto da diviso (%), apenas para operandos inteiros; incremento (++), operador unrio definido apenas para operandos inteiros, podendo ocorrer antes da varivel (pr-incremento) ou aps a varivel (ps-incremento); e decremento (--), operador unrio definido apenas para operandos inteiros, podendo ocorrer antes da varivel (pr-decremento) ou aps a varivel (ps-decremento).
11.2 Expresses Lgicas Inteiras:
50
Operaes lgicas sobre valores inteiros atuam sobre a representao binria do valor armazenado, operando internamente bit a bit. Operadores desse tipo so: - complemento (~), operador unrio que reverte os valores dos bits na representao interna; - OR bit-a-bit (|), operador binrio que resulta em um bit 1 se pelo menos um dos bits na posio era 1; - AND bit-a-bit (&), operador binrio que resulta em um bit 0 se pelo menos um dos bits na posio era 0; - XOR bit-a-bit (^), operador binrio que resulta em um bit 1 se os bits na posio eram diferentes; - deslocamento esquerda (<<), operador binrio que recebe a varivel cujo contedo ser deslocado e um segundo operando que especifica o nmero de posies a deslocar esquerda; - deslocamento direita com extenso de sinal (>>), operador binrio que recebe a varivel cujo contedo ser deslocado e um segundo operando que especifica o nmero de posies a deslocar direita. Os bits inseridos esquerda tero o mesmo valor do bit mais significativo da representao interna; - deslocamento direita com extenso 0 (>>>), operador binrio que recebe a varivel cujo contedo ser deslocado e um segundo operando que especifica o nmero de posies a deslocar direita. Os bits inseridos esquerda tero o valor 0.. Por exemplo, queremos resolver o seguinte problema: Calcular a mdia de todos os alunos que cursaram uma disciplina X, a partir da leitura das notas da 1 e 2 prova, passando por um clculo de mdia aritmtica. Aps a mdia calculada, devemos anunciar se o aluno foi aprovado ou reprovado por nota. Somente esto aprovados os alunos com mdia maior ou igual 5,0.
11.3 Expresses Lgicas Booleanas:

As operaes lgicas booleanas operam sobre valores booleanos. Operadores booleanos incluem: - complemento lgico (!), operador unrio que retorna true se o argumento false ou retorna false se o argumento true; - OR lgico booleano (|), operador binrio que retorna true se pelo menos um dos dois argumentos true; - OR lgico condicional (||), operador binrio que retorna true se pelo menos um dos dois argumentos true. Se o primeiro argumento j true, o segundo argumento no nem avaliado; - AND lgico booleano (&), operador binrio que retorna false se pelo menos um dos dois argumentos false; - AND lgico condicional (&&), operador binrio que retorna false se pelo menos um dos dois argumentos false. Se o primeiro argumento j false, o segundo argumento no nem avaliado;
51
- XOR booleano (^), operador binrio que retorna true quando os dois argumentos tm valores lgicos distintos.
11.4 Condies:
Condies permitem realizar testes baseados nas comparaes entre valores numricos. Operadores condicionais incluem: - maior (>), retorna true se o primeiro valor for exclusivamente maior que o segundo; - maior ou igual (>=), retorna true se o primeiro valor for maior que ou igual ao segundo; - menor (<), retorna true se o primeiro valor for exclusivamente menor que o segundo; - menor ou igual (<=), retorna true se o primeiro valor for menor que ou igual ao segundo; - igual (==), retorna true se o primeiro valor for igual ao segundo; - diferente (!=), retorna true se o primeiro valor no for igual ao segundo. Assim como C e C++, Java oferece o operador condicional ternrio, ?:. Na expresso b ? s1 : s2, b booleano (varivel ou expresso). O resultado da expresso ser o resultado da expresso (ou varivel) s1 se b for verdadeiro, ou o resultado da expresso (ou varivel) s2 se b for falso. 11.6 Atribuio: O operador binrio = atribui o valor da expresso do lado direito varivel esquerdado operador. Os tipos da expresso e da varivel devem ser compatveis. O operador de atribuio pode ser combinado com operadores aritmticos e lgicos, como em C e C++. Assim, a expresso a += b equivale a a=a+b
11.5 Retorno:
Mtodos em Java tm sua execuo encerrada de duas maneiras possveis. A primeira vlida quando um mtodo no tem um valor de retorno (o tipo de retorno void): a execuo encerrada quando o bloco do corpo do mtodo chega ao final. A segunda alternativa encerra a execuo do mtodo atravs do comando return:
52
Linguagem de Programao I return;
sem valor de retorno.

return expresso;
o valor de retorno o resultado da expresso.
11.6 Operaes Sobre Objetos:

Criao de objeto Dada uma classe Cls, possvel (em princpio) criar um objeto dessa classe usando o operador new:
Cls obj = new Cls();
A "funo" direita do operador new um construtor da classe Cls. Aplicao de mtodos A classe pode definir mtodos que podem ser aplicados aos seus objetos. A aplicao de um mtodo meth(), definido em uma classe Cls, a um objeto obj, construdo a partir da especificao de Cls, se d atravs da construo
obj.meth()
assumindo que a assinatura de meth determinasse que nenhum argumento passado para o mtodo. Tomando como exemplo a varivel System.out, o envio de dados para a tela se d atravs da aplicao do mtodo print (ou println(), para impresso seguida de muana de linha) tendo como argumento a varivel ou string que se deseja imprimir, como em
System.out.println("Hello");
Verificao de tipo Dado um objeto obj e uma classe Cls, possvel verificar dinamicamente (durante a execuo do mtodo) se o objeto pertence ou no classe. O operador instanceof retorna true se o objeto esquerda do operador da classe especificada direita do operador. Assim,
obj instanceof Cls
retornaria true.
53
Unidade 12 -
Fluxo de Controle de Execuo
12.1 Comandos de Fluxo de Controle de Execuo:

A ordem de execuo normal de comandos em um mtodo Java seqencial. Comandos de fluxo de controle permitem modificar essa ordem natural de execuo atravs dos mecanismos de escolha ou de iterao.
12.2 Escolha:
if A estrutura if permite especificar um comando (ou bloco de comandos) que deve apenas ser executado quando uma determinada condio for satisfeita:
if (condio) { bloco_comandos }
Quando o bloco de comandos composto por uma nica expresso, as chaves que delimitam o corpo do bloco podem ser omitidas:
if (condio) expresso;
Embora a indentao do cdigo no seja mandatria, uma recomendao de boa prtica de programao. if else
if ... else permite expressar duas alternativas de execuo, uma para o caso da condio ser
verdadeira e outra para o caso da condio ser falsa :

if (condio) { bloco_comandos_caso_verdade } else { bloco_comandos_caso_falso }
switch
54
Linguagem de Programao I switch ... case tambm um comando que expressa alternativas de execuo, mas onde as condies esto restritas comparao de uma varivel inteira com valores constantes: switch (varivel) { case valor1: bloco_comandos break; case valor2: bloco_comandos break; ... case valorn: bloco_comandos break; default: bloco_comandos }
12.3 Iterao:
while
while permite expressar iteraes que devem ser executadas se e enquanto uma condio for
verdadeira:
while (condio) { bloco_comandos }
do while
do ... while tambm permite expressar iteraes, mas neste caso pelo menos uma execuo do bloco de comandos garantida: do { bloco_comandos } while (condio);
for O comando for permite expressar iteraes combinando uma expresso de inicializao, um teste de condio e uma expresso de incremento:
for (inicializao; condio; incremento) { bloco_comandos }
55
Embora Java no suporte o operador "," de C/C++, no comando for mltiplas expresses de inicializao e de incremento podem ser separadas por vrgulas. break
continue e break so comandos que permitem expressar a quebra de um fluxo de execuo. break j foi utilizado juntamente com switch para delimitar bloco de comandos de cada case. No corpo de uma iterao, a ocorrncia do comando break interrompe a iterao, passando o controle para o
prximo comando aps o comando de iterao.

continue tambm interrompe a execuo da iterao, mas apenas da iterao corrente. Aps um continue, a condio de iterao reavaliada e, se for verdadeira, o comando de iterao continua
executando. Em situaes onde h diversos comandos de iterao aninhados, os comandos break e continue transferem o comando de execuo para o ponto imediatamente aps o bloco onde ocorrem. Se for necessrio especificar transferncia para o fim de outro bloco de iterao, os comandos break e continue rotulados podem ser utilizados: label: { for (...; ...; ...) { ... while (...) { ... if (...) break label; ... } ... } ... }
56
Unidade 13 13.1 Arranjos em Java:
Arranjos em Java
Arranjos podem ser definidos para literais ou para objetos Assim como objetos, so criados com o comando new: Criar referncia para um arranjo de inteiros int array1[]; Criar espao para armazenar 100 inteiros em um arranjo array1: array1 = new int[100]; Combinando declarao e criao de espao: int array1[] = new int[100]; Arranjos podem ser criados com a especificao de algum contedo: int array2[] = {2, 4, 5, 7, 9, 11, 13}; O acesso a elementos individuais de um arranjo especificado atravs de um ndice inteiro. O elemento inicial, assim como em C e C++, tem ndice 0. Assim, do exemplo acima,
int x = array2[3];
faz com que a varivel x receba o valor 7, o contedo da quarta posio. O acesso a elementos do arranjo alm do ltimo ndice permitido -- por exemplo, a array2[7] - gera um erro em tempo de execuo (uma exceo). A dimenso de um arranjo pode ser obtida atravs do campo length presente em todos os arranjos. Assim, a expresso
int y = array2.length;
Faz com que y receba o valor 7, o nmero de elementos no arranjo..
57
Unidade 14 14.1 Strings:

A classe java.lang.String uma seqncia de caracteres imutvel. Representa uma cadeia de caracteres Unicode Otimizada para ser lida, mas no alterada Nenhum mtodo de String modifica o objeto armazenado H duas formas de criar Strings Atravs de construtores, metodos, fontes externas, etc: String s1 = new String("Texto"); String s2 = objeto.getText(); // mtodo de API String s3 = coisa.toString(); Atravs de atribuio de um literal String s3 = "Texto";
Strings
Strings criados atravs de literais so automaticamente armazenadas em um pool para possvel reuso; Mesmo objeto reutilizado: comparao de Strings iguais criados atravs de literais revelam que se tratam do mesmo objeto; Pool de strings Como Strings so objetos imutveis, podem ser reusados Strings iguais criados atravs de literais so o mesmo objeto String um = "Um"; String dois = "Um"; if (um == dois) System.out.println("um e dois so um!"); Mas Strings criados de outras formas no so String tres = new String("Um"); if (um != tres) System.out.println("um nao trs!"); Todos os blocos de texto abaixo so impressos
58
Literais so automaticamente guardados no pool. Outros Strings podem ser acrescentados no pool usando intern(): quatro = tres.intern(); if (um == quatro) System.out.println("quatro um!"); Principais Mtodos de String Mtodos que criam novos Strings: String concat(String s): retorna a concatenao do String atual com outro passado como parmetro String replace(char old, char new): troca todas as ocorrncias de um caractere por outro String substring(int start, int end): retorna parte do String incluindo a posio inicial e exclundo a final String toUpperCase() e String toLowerCase(): retorna o String em caixa alta e caixa baixa respectivamente Mtodos para pesquisa boolean endsWith(String) e startsWith(String) int indexOf(String), int indexOf(String, int offset): retorna posio char charAt(int posio): retorna caractere em posio Outros mtodos char[] toCharArray(): retorna o vetor de char correspondente ao String int length(): retorna o comprimento do String
14.2 StringBuffer:
A classe StringBuffer uma seqncia de caracteres mutvel Representa uma cadeia de caracteres Unicode Otimizada para ser alterada, mas no lida StringBuffers podem ser criados atravs de seus construtores StringBuffer buffer1 = new StringBuffer(); StringBuffer buffer2 = new StringBuffer("Texto inicial"); StringBuffer buffer3 = new StringBuffer(40); Mtodos de StringBuffer operam sobre o prprio objeto
59
StringBuffer append(String s): adiciona texto no final StringBuffer insert(int posio, String s): insere na posio void setCharAt(int posio, char c): substitui na posio String toString(): transforma o buffer em String para que possa ser lido Exemplo: StringBuffer buffer = new StringBuffer("H"); buffer.append("e").append("l").append("l").append("o"); System.out.println(buffer.toString()); Quando usar String e StringBuffer Use String para manipular com valores constantes Textos carregados de fora da aplicao Valores literais Textos em geral que no sero modificados intensivamente Use StringBuffer para alterar textos Acrescentar, concatenar, inserir, etc. Prefira usar StringBuffer para construir Strings Concatenao de strings usando "+" extremamente cara: um novo objeto criado em cada fase da compilao apenas para ser descartado em seguida Use StringBuffer.append() e, no final, transforme o resultado em String
14.3 java.util.StringTokenizer:
Classe utilitria que ajuda a dividir texto em tokens Recebe um String e uma lista de tokens Usa um Enumeration para iterar entre os elementos Exemplo: String regStr = "Primeiro,Segundo,Terceiro,Quarto"; StringTokenizer tokens = new StringTokenizer(regStr, ","); String[] registros = null; List regList = new ArrayList(); while (tokens.hasMoreTokens()) { String item = tokens.nextToken(); regList.add(item);
60
} int size = regList.size(); registros = (String[])regList.toArray(new String[size]);
61
Unidade 15 15.1 Pacote
Pacote
No desenvolvimento de pequenas atividades ou aplicaes, vivel manter o cdigo e suas classes no diretrio corrente. No entanto, para grandes aplicaes preciso organizar as classes de maneira a evitar problemas com nomes duplicados de classes, e localizar o cdigo da classe de forma eficiente. Em Java, a soluo para esse problema est na organizao de classes e interfaces em pacotes. Essencialmente, uma classe Xyz que pertence a um pacote nome.do.pacote tem o nome completo nome.do.pacote.Xyz e o compilador Java espera encontrar o arquivo Xyz.class em um subdiretrio nome/do/pacote. Este, por sua vez, deve estar localizado sob um dos diretrios especificados na varivel de ambiente CLASSPATH.
62
Unidade 16 -
Ncleo de Funcionalidades
16.1 Ncleo de Funcionalidades

Tudo em Java est organizado em classes. Algumas classes so desenvolvidas pelo programador da aplicao e outras j esto disponveis atravs do ncleo de funcionalidades da plataforma Java. As classes que compem o ncleo de funcionalidades Java esto organizadas em pacotes. Um package Java um mecanismo para agrupar classes de finalidades afins ou de uma mesma aplicao. Alm de facilitar a organizao conceitual das classes, o mecanismo de pacotes permite localizar cada classe necessria durante a execuo da aplicao. No entanto, a principal funcionalidade de um pacote Java evitar a exploso do espao de nome, ou seja, classes com o mesmo nome em pacotes diferentes podem ser diferenciadas pelo nome completo, pacote.classe. Entre os principais pacotes oferecidos como parte do ncleo Java esto: java.lang java.util
java.io
java.awt
java.applet
java.net
Observe que esses nomes seguem a conveno Java, pela qual nomes de pacotes (assim como nomes de mtodos) so grafados em letras minsculas, enquanto nomes de classes tm a primeira letra (de cada palavra, no caso de nomes compostos) grafada com letra maiscula. Alm dessas funcionalidades bsicas, h tambm APIs definidas para propsitos mais especficos compondo a extenso padronizada ao ncleo Java.
16.2 java.lang:
O pacote java.lang contm as classes que constituem recursos bsicos da linguagem, necessrios execuo de qualquer programa Java. Entre as classes desse pacote destacam-se: Object expressa o conjunto de funcionalidades comuns a todos os objetos Java;
63
Class e ClassLoader representa classes Java e o mecanismo para carreg-las dinamicamente; String e StringBuffer permite a representao e a manipulao de strings, fixos ou modificveis; Math contm a definio de mtodos para clculo de funes matemticas (trigonomtricas, logartimicas, exponenciais, etc) e de constantes, tais como Math.E e Math.PI; Boolean, Character, Byte, Short, Integer, Long, Float, Double so classes wrappers, permitindo a manipulao de valores dos tipos literais da linguagem como se fossem objetos; System, Runtime e Process so classes que permitem interao da aplicao com o ambiente de execuo; Thread, Runnable, ThreadGroup classes que do suporte execuo de mltiplas linhas de execuo; Throwable, Error e Exception classes que permitem a definio e manipulao de situaes de erros e condies inesperadas de execuo, tais como OutOfMemoryError, ArithmeticException (por exemplo, diviso inteira por zero) e ArrayIndexOutOfBoundsException (acesso a elemento de arranjo alm da ltima posio ou antes da primeira posio). Sub-pacotes relacionados incluem java.lang.ref, de referncias a objetos, e o pacote java.lang.reflect, que incorpora funcionalidades para permitir a manipulao do contedo de classes, ou seja, identificao de seus mtodos e campos. Observe que funes matemticas so definidas em java.lang.Math, no em classes do pacote java.math, que define funcionalidades para manipular nmeros inteiros e reais de preciso arbitrria.
16.3 System
A classe System oferece algumas funcionalidades bsicas de interface com o sistema no qual a mquina virtual Java est executando. A documentao desta classe descreve: Entre as facilidades fornecidas pela classe System esto a entrada padro (in), a sada padro (out), e os erros de sada de streams (err); alcance s "propriedades externamente definidas"; meios de carregar arquivos e bibliotecas; e um mtodo para copiar rapidamente uma parcela de um array. Entre as facilidades oferecidas esto o conjunto de variveis correspondentes aos dispositivos padres de entrada e sada, um mtodo de classe para obter uma leitura de relgio com preciso de milissegundos, long CurrentTimeMillis(), e um mtodo de classe para encerrar a execuo da mquina virtual Java, void exit(int status), onde por conveno um valor de status diferente de zero indica alguma situao anormal de trmino da execuo.
64
Uma classe intimamente relacionada a System a classe Runtime, para a qual existe um nico objeto representando o ambiente no qual a mquina virtual Java est executando. Atravs desta classe possvel disparar novos processos atravs do mtodo exec().
16.4 Utilitrios de Propsito Genrico:

O pacote java.util oferece, alm de estruturas de dados, algumas classes utilitrias de propsito genrico.
16.5 Date
Permite representar uma data e hora usando uma representao interna em milissegundos decorridos desde a meia-noite (GMT) de 01 de janeiro de 1970. O construtor default cria um objeto com a data e hora corrente. Para obter o valor associado a esse objeto, o mtodo long getTime() utilizado.
16.6 Random
Implementa um gerador de nmeros pseudo-aleatrios, com mtodos double nextDouble() e float nextFloat() gerando valores uniformemente distribudos entre 0,0 e 1,0; long nextLong() e int nextInt() geram valores inteiros uniformemente distribudos ao longo da faixa de valores possveis. O mtodo double nextGaussian() retorna um valor com distribuio normal (mdia 0, desvio padro 1). A semente do gerador de nmeros pseudo-aleatrios obtida a partir do tempo corrente. Outro valor pode ser especificado no construtor ou com o mtodo setSeed() -- para um mesmo valor inicial, uma mesma seqncia de nmeros ser gerada.
65
Unidade 17 - Exerccios para programao

orientada a objetos
1) Faa um programa em Java que leia 3 nmeros e calcule a sua mdia. O programa deve ser modularizado. Utilize uma funo para calcular e retornar a mdia dos nmeros. Essa funo deve receber os trs nmeros como parmetro. 2) Crie um programa em Java que leia o raio de uma esfera (do tipo real) e passe esse valor para a funo volumeEsfera. Essa funo deve calcular o volume da esfera na tela e retornar o seu valor. Para o clculo do volume deve ser usada a seguinte frmula: Volume = (4.0 / 3.0) * PI * raio3 3) Faa um programa em Java em que o usurio entre com um valor de base e um valor de expoente. O programa deve calcular a potncia. O programa deve ser modularizado. Voc deve decidir se a subrotina ser um procedimento ou uma funo. 4) Cite exemplos de objetos do mundo real. Identifique atributos e comportamentos para esses objetos. Agrupe esses objetos nas suas respectivas classes. Faa isso usando a notao UML para classes e objetos. 5) Quando um mtodo construtor chamado? 6) Qual a funo de um mtodo modificador numa classe? E de um mtodo recuperador? 7) Analise o seguinte trecho de cdigo e identifique se existe algum erro. Caso exista, explique qual o erro e como solucion-lo.
//classe Retangulo public class Retngulo{ private double base, altura; //mtodos }
66
//classe calcula que cria objeto retangulo public class CalculaRetangulo{ public static void main(String args[]){ Retangulo r = new Retangulo() r.base = 5.0; r.altura = 6.0 } }
8) A seguinte classe tem dois mtodos static. Programe outra classe chamada UsaCalculos.java e demonstre como esses mtodos static podem ser chamados dessa classe.
public class Calculos{ public static int potencia(int base, int exp){ int pote=1; for (int i=1;i<=exp;i++) pote = pote * base; return pote; } public static int fatorial(int nu){ int fat=1; for (int i=1;i<=nu;i++) fat = fat * nu; return fat; } }
67
68

04-Linguagem Programaçãoi

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

04-Linguagem Programaçãoi

Enviado por

Direitos autorais:

Formatos disponíveis

Linguagem de Programao I

UNIDADE 1 1.1 1.2 1.3 1.4 1.5 1.6 1.7

PARADIGMA DE PROGRAMAO ORIENTADA A OBJETO......................................................................... 3

UNIDADE 2 2.1 2.2 2.3

UNIDADE 3 3.1 3.2

UNIDADE 4 4.1 4.2 4.3

UNIDADE 5 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8

UNIDADE 6 6.1 6.2 6.3 6.4 6.5

UNIDADE 7 7.1 7.2 7.3 7.4 7.5 7.6 7.7

UNIDADE 8 8.1 8.2 8.3 8.4

8.5 8.6 8.7

UNIDADE 9 9.1 9.2 9.3 9.4

UNIDADE 10 10.1 10.2 10.3

UNIDADE 11 11.1 11.2 11.3 11.4 11.5 11.6

UNIDADE 12 12.1 12.2 12.3

UNIDADE 14 14.1 14.2 14.3

UNIDADE 16 16.1 16.2 16.3 16.4 16.5 16.6

Unidade 1 - Paradigma de Programao Orientada a Objeto

1.1 Um pouco de histria

1.2 Orientao a objeto Conceitos bsicos

1.5 Histrico da Linguagem Java

1.6 Principal Caracterstica

1.7 Compilador, Cdigo Fonte, JVM

Unidade 2 - Programao Orientada a Objetos

Unidade 3 - Classes em Java

4.2 Tipos Primitivos

Exemplo de declarao e uso:

Combinando definio e inicializao,

Carter backspace tabulao horizontal newline form feed carriage return

Linguagem de Programao I \" \' \\ \xxx

4.3 Classes wrappers

as seguintes expresses retornariam o valor booleano true:

enquanto que as expresses a seguir retornariam false: Character.isDigit(umCaracter);

e para a converso entre letras minsculas e maisculas: char Character.toLowerCase(char c);

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

O operador '+' pode ser utilizado concatenar strings:

possvel concatenar valores de outros tipos a strings:

onde implicitamente ocorre uma converso da forma

Extrair caracteres e substrings:

geraria a seguinte mensagem de erro:

gera dois erros:

No entanto, se for includa uma implementao de meth() na classe derivada:

ento nenhum erro de compilao ocorre.

ocasionaria um erro de compilao:

A tentativa de compilao dessa unidade geraria a seguinte mensagem de erro

Uma simples anlise dessa declarao mostra que:

poderia ser utilizada.

5.8 Definio do Corpo de Mtodos

Unidade 6 - Manipulao de Objetos

6.3 Exemplos de Uso de this

6.4 Remoo de objetos

6.5 A Classe Object

Linguagem de Programao I public boolean equals(Object obj)

7.2 Formas de Herana

7.5 Construo de Objetos Derivados

7.6 A Palavra-Chave super

7.7 Restries de acesso

os seguintes erros seriam detectados pelo compilador Java:

8.2 Ligao Tardia:

8.3 Sobrecarga (overloading):

8.4 Polimorfismo em Java:

Alguns pontos a destacar com relao a esse exemplo:

Linguagem de Programao I Ref_orig = (Tipo_orig) Ref_upcast;