Академический Документы
Профессиональный Документы
Культура Документы
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
MTODOS ................................................................................................................................................................. 23 PRIVATE .................................................................................................................................................................... 23 PUBLIC ...................................................................................................................................................................... 24 PROTECTED................................................................................................................................................................ 24 ABSTRACT.................................................................................................................................................................. 24 FINAL ....................................................................................................................................................................... 25 STATIC ...................................................................................................................................................................... 27 DEFINIO DO CORPO DE MTODOS .............................................................................................................................. 28 MANIPULAO DE OBJETOS .................................................................................................................. 29
MANIPULAO DE OBJETOS ......................................................................................................................................... 29 THIS ......................................................................................................................................................................... 30 EXEMPLOS DE USO DE THIS ........................................................................................................................................... 31 REMOO DE OBJETOS ................................................................................................................................................ 31 A CLASSE OBJECT ....................................................................................................................................................... 32 HERANA ............................................................................................................................................... 34
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
POLIMORFISMO: ........................................................................................................................................................ 40 LIGAO TARDIA: ....................................................................................................................................................... 40 SOBRECARGA (OVERLOADING): ..................................................................................................................................... 40 POLIMORFISMO EM JAVA: ............................................................................................................................................ 41
UPCASTING: .............................................................................................................................................................. 43 USO DE MTODOS ABSTRATOS: ..................................................................................................................................... 44 POLIMORFISMO EM CONSTRUTORES: .............................................................................................................................. 44 INTERFACES ............................................................................................................................................ 46
INTERFACE: ............................................................................................................................................................... 46 DECLARAO DE INTERFACE:......................................................................................................................................... 46 IMPLEMENTAO DE INTERFACES: ................................................................................................................................. 46 DEFINIO DE CONSTANTES: ........................................................................................................................................ 47 IDENTIFICADORES .............................................................................................................................. 48
IDENTIFICADORES ....................................................................................................................................................... 48 PALAVRAS RESERVADAS EM JAVA: ................................................................................................................................. 48 CONVENO PARA IDENTIFICADORES: ............................................................................................................................. 48 EXPRESSES ....................................................................................................................................... 50
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 13 13.1
UNIDADE 15 15.1
NCLEO DE FUNCIONALIDADES ..................................................................................................................................... 63 JAVA.LANG: ............................................................................................................................................................... 63 SYSTEM .................................................................................................................................................................... 64 UTILITRIOS DE PROPSITO GENRICO: .......................................................................................................................... 65 DATE........................................................................................................................................................................ 65 RANDOM .................................................................................................................................................................. 65
Linguagem de Programao I
Linguagem de Programao I
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.
Linguagem de Programao I
Linguagem de Programao I
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.
Linguagem de Programao I
Linguagem de Programao I
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
Linguagem de Programao I
> 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)
Linguagem de Programao I
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
Linguagem de Programao I
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
Linguagem de Programao I
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
Linguagem de Programao I
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
Linguagem de Programao I
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
Linguagem de Programao I
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
Linguagem de Programao I
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
[modificador] tipo nome [ = default];
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
16
Linguagem de Programao I
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
17
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
Linguagem de Programao I
19
Linguagem de Programao I
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);
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
Linguagem de Programao I
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);
Classe String
21
Linguagem de Programao I
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";
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);
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
Linguagem de Programao I
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
Linguagem de Programao I
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(); } }
Classes abstratas correpondem a especificaes genricas, que devero ser concretizadas em classes derivadas. Mtodo abstrato
24
Linguagem de Programao I
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(); } }
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 { }
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:}
26
Linguagem de Programao I
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
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);
27
Linguagem de Programao I
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
Linguagem de Programao I
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
Linguagem de Programao I
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
Linguagem de Programao I
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.
31
Linguagem de Programao I
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:
32
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
Linguagem de Programao I
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().
34
Linguagem de Programao I
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)); } }
36
Linguagem de Programao I
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
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)); }
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
Linguagem de Programao I
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.
40
Linguagem de Programao I
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.
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
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
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().
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
Linguagem de Programao I
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.
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.
46
Linguagem de Programao I
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.
47
Linguagem de Programao I
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.
48
Linguagem de Programao I
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
Linguagem de Programao I
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.
50
Linguagem de Programao I
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.
51
Linguagem de Programao I
- 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
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
Linguagem de Programao I
Unidade 12 -
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
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
Linguagem de Programao I
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
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
Linguagem de Programao I
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;
57
Linguagem de Programao I
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
Linguagem de Programao I
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
Linguagem de Programao I
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
Linguagem de Programao I
61
Linguagem de Programao I
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
Linguagem de Programao I
Unidade 16 -
Ncleo de Funcionalidades
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
Linguagem de Programao I
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
Linguagem de Programao I
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.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
Linguagem de Programao I
//classe Retangulo public class Retngulo{ private double base, altura; //mtodos }
66
Linguagem de Programao I
//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
Linguagem de Programao I
68